chirpnest/obj.go

package main

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"time"
)

var (
	cacheObjCastle *sync.Map
	cacheObjGuild  *sync.Map
	cacheObjUser   *sync.Map
	cacheObjItem   *sync.Map
	cacheObjMsg    *sync.Map
)

func getObjTypeId(objId int64) (int64, error) {
	var objTypeId int64

	stmt, err := db.Prepare(`SELECT o.obj_type_id FROM obj o WHERE o.id = ?`)
	if err != nil {
		return 0, err
	}
	defer stmt.Close()

	err = stmt.QueryRow(objId).Scan(&objTypeId)
	if err != nil {
		return 0, err
	}

	return objTypeId, nil
}

func getObjSubTypeId(objId int64) (int64, error) {
	var objSubTypeId int64

	stmt, err := db.Prepare(`SELECT o.obj_sub_type_id FROM obj o WHERE o.id = ?`)
	if err != nil {
		return 0, err
	}
	defer stmt.Close()

	err = stmt.QueryRow(objId).Scan(&objSubTypeId)
	if err != nil {
		return 0, err
	}

	return objSubTypeId, nil
}

func setObjSubTypeId(objId int64, objSubTypeID64 int64) error {
	stmt, err := db.Prepare(`UPDATE obj o SET o.obj_sub_type_id = ? WHERE o.id = ?;`)
	logOnError(err, "setObjSubTypeId : prepare update")
	if err != nil {
		return err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objSubTypeID64, objId)
	logOnError(err, "setObjSubTypeId : exec update")
	return err
}

func addObjMsg(msgID64 int64, msgChatID64 int64, msgUserID64 int64, msgSenderUserID64 int64, msgDate time.Time, msgText string) (int64, error) {
	tx, err := db.Begin()
	logOnError(err, "addObjMsg : start transaction")
	if err != nil {
		return 0, err
	}

	res, err := tx.Exec(`INSERT INTO obj (obj_type_id, obj_sub_type_id)
						          VALUES (` + strconv.Itoa(objTypeMessage) + `,` + strconv.Itoa(objSubTypeMessageUnknown) + `);`)
	logOnError(err, "addObjMsg : exec insert obj")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjMsg : rollback insert obj")
		return 0, err
	}

	objId, err := res.LastInsertId()
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjMsg : rollback get lastInsertId")
		return 0, err
	}

	stmt, err := tx.Prepare(`INSERT INTO obj_msg	(obj_id, msg_id, chat_id, user_id, sender_user_id, date, text)
							 VALUES 				(?,      ?,      ?,       ?,       ?,              ?,    ?);`)
	logOnError(err, "addObjMsg : prepare insert obj_msg")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjMsg : rollback prepare insert obj_msg")
		return 0, err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objId, msgID64, msgChatID64, msgUserID64, msgSenderUserID64, msgDate, msgText)
	logOnError(err, "addObjMsg : exec insert obj_msg")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjMsg : rollback exec insert obj_msg")
		return 0, err
	}

	err = tx.Commit()
	logOnError(err, "addObjMsg : commit")
	if err != nil {
		return 0, err
	}
	return objId, nil
}

func getObjMsg(objId int64) (*ChatWarsMessage, error) {
	var m *ChatWarsMessage

	if v, ok := cacheObjMsg.Load(objId); ok {
		m := v.(ChatWarsMessage)
		return m, nil
	}

	stmt, err := db.Prepare(`SELECT om.msg_id, om.chat_id, om.user_id, om.sender_user_id, om.date, om.text FROM obj_msg om WHERE om.obj_id = ?`)
	if err != nil {
		return m, err
	}
	defer stmt.Close()

	m = new(ChatWarsMessage)

	err = stmt.QueryRow(objId).Scan(&m.ID64, &m.ChatID64, &m.UserID64, &m.SenderUserID64, &m.Date, &m.Text)
	if err != nil {
		return m, err
	}

	cacheObjMsg.Store(objId, *m)

	return m, nil
}

func loadObjMsg() error {
	cacheObjMsg = new(sync.Map)

	return nil
}

func addObjCastle(logo string, name string) (int64, error) {
	tx, err := db.Begin()
	logOnError(err, "addObjCastle : start transaction")
	if err != nil {
		return 0, err
	}

	res, err := tx.Exec(`INSERT INTO obj (obj_type_id, obj_sub_type_id)
						          VALUES (` + strconv.Itoa(objTypeCastle) + `,` + strconv.Itoa(objSubTypeCastle) + `);`)
	logOnError(err, "addObjCastle : exec insert obj")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjCastle : rollback insert obj")
		return 0, err
	}

	objId, err := res.LastInsertId()
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjCastle : rollback get lastInsertId")
		return 0, err
	}

	stmt, err := tx.Prepare(`INSERT INTO obj_castle	(obj_id, logo, name)
							 VALUES 				(?,      ?,       ?);`)
	logOnError(err, "addObjCastle : prepare insert obj_castle")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjCastle : rollback prepare insert obj_castle")
		return 0, err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objId, logo, name)
	logOnError(err, "addObjCastle : exec insert obj_castle")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjCastle : rollback exec insert obj_castle")
		return 0, err
	}

	err = tx.Commit()
	logOnError(err, "addObjCastle : commit")
	if err != nil {
		return 0, err
	}
	return objId, nil
}

func getObjCastleID(s string) int64 {
	v, _ := cacheObjCastle.Load(s)
	c := v.(ChatWarsCastle)
	return c.ObjID64
}

func loadObjCastle() error {
	var (
		id   int64
		logo string
		name string
	)

	cacheObjCastle = new(sync.Map)

	castles, err := db.Query(`SELECT oc.obj_id, oc.logo, oc.name FROM obj_castle oc;`)
	if err != nil {
		return err
	}
	defer castles.Close()

	for castles.Next() {
		err = castles.Scan(&id, &logo, &name)
		if err != nil {
			return err
		}
		c := new(ChatWarsCastle)
		c.ObjID64 = id
		c.Logo = logo
		c.Name = name
		cacheObjCastle.Store(logo, *c)
		cacheObjCastle.Store(name, *c)
	}

	return nil
}

func addObjGuild(tag string, name string) (int64, error) {
	tx, err := db.Begin()
	logOnError(err, "addObjGuild : start transaction")
	if err != nil {
		return 0, err
	}

	res, err := tx.Exec(`INSERT INTO obj (obj_type_id, obj_sub_type_id)
						          VALUES (` + strconv.Itoa(objTypeGuild) + `,` + strconv.Itoa(objSubTypeGuild) + `);`)
	logOnError(err, "addObjGuild : exec insert obj")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjGuild : rollback insert obj")
		return 0, err
	}

	objId, err := res.LastInsertId()
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjGuild : rollback get lastInsertId")
		return 0, err
	}

	stmt, err := tx.Prepare(`INSERT INTO obj_guild	(obj_id, tag, name, chat_id, deposit_chat_id)
							 VALUES 				(?,      ?,   ?,    NULL,    NULL);`)
	logOnError(err, "addObjGuild : prepare insert obj_guild")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjGuild : rollback prepare insert obj_guild")
		return 0, err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objId, tag, name)
	logOnError(err, "addObjGuild : exec insert obj_guild")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjGuild : rollback exec insert obj_guild")
		return 0, err
	}

	err = tx.Commit()
	logOnError(err, "addObjGuild : commit")
	if err != nil {
		return 0, err
	}
	return objId, nil
}

func getObjGuildID(s string) int64 {
	if v, ok := cacheObjGuild.Load(s); ok {
		g := v.(ChatWarsGuild)
		return g.ObjID64
	} else {
		objID64, err := addObjGuild(s, ``)
		logOnError(err, "getObjGuildID")
		g := new(ChatWarsGuild)
		g.ObjID64 = objID64
		g.Tag = s
		g.Name = ``
		cacheObjGuild.Store(s, *g)
		return objID64
	}
}

func loadObjGuild() error {
	var (
		id   int64
		tag  string
		name string
	)

	cacheObjGuild = new(sync.Map)

	guilds, err := db.Query(`SELECT og.obj_id, og.tag, og.name FROM obj_guild og;`)
	if err != nil {
		return err
	}
	defer guilds.Close()

	for guilds.Next() {
		err = guilds.Scan(&id, &tag, &name)
		if err != nil {
			return err
		}
		g := new(ChatWarsGuild)
		g.ObjID64 = id
		g.Tag = tag
		g.Name = name
		cacheObjGuild.Store(tag, *g)
	}

	return nil
}

func addObjUser(name string) (int64, error) {
	tx, err := db.Begin()
	logOnError(err, "addObjUser : start transaction")
	if err != nil {
		return 0, err
	}

	res, err := tx.Exec(`INSERT INTO obj (obj_type_id, obj_sub_type_id)
						          VALUES (` + strconv.Itoa(objTypeUser) + `,` + strconv.Itoa(objSubTypeUser) + `);`)
	logOnError(err, "addObjUser : exec insert obj")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjUser : rollback insert obj")
		return 0, err
	}

	objId, err := res.LastInsertId()
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjUser : rollback get lastInsertId")
		return 0, err
	}

	stmt, err := tx.Prepare(`INSERT INTO obj_user	(obj_id, name)
							 VALUES 				(?,      ?);`)
	logOnError(err, "addObjUser : prepare insert obj_user")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjUser : rollback prepare insert obj_user")
		return 0, err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objId, name)
	logOnError(err, "addObjUser : exec insert obj_user")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjUser : rollback exec insert obj_user")
		return 0, err
	}

	err = tx.Commit()
	logOnError(err, "addObjUser : commit")
	if err != nil {
		return 0, err
	}
	return objId, nil
}

func getObjUserID(s string) int64 {
	if v, ok := cacheObjUser.Load(s); ok {
		u := v.(ChatWarsUser)
		return u.ObjID64
	} else {
		objID64, err := addObjUser(s)
		logOnError(err, "getObjUserID")
		u := new(ChatWarsUser)
		u.ObjID64 = objID64
		u.Name = s
		cacheObjUser.Store(s, *u)
		return objID64
	}
}

func loadObjUser() error {
	var (
		id   int64
		name string
	)

	cacheObjUser = new(sync.Map)

	users, err := db.Query(`SELECT ou.obj_id, ou.name FROM obj_user ou;`)
	if err != nil {
		return err
	}
	defer users.Close()

	for users.Next() {
		err = users.Scan(&id, &name)
		if err != nil {
			return err
		}
		u := new(ChatWarsUser)
		u.ObjID64 = id
		u.Name = name
		cacheObjUser.Store(name, *u)
	}

	return nil
}

func getObjMsgDate(objID64 int64) (time.Time, error) {
	m, err := getObjMsg(objID64)
	if err != nil {
		return time.Now(), err
	} else {
		return m.Date, nil
	}
}

func addObjXP(userID64 int64, expNow int64, expLvl int64, level int64, date time.Time) (int64, error) {
	tx, err := db.Begin()
	logOnError(err, "addObjXP : start transaction")
	if err != nil {
		return 0, err
	}

	res, err := tx.Exec(`INSERT INTO obj (obj_type_id, obj_sub_type_id)
						          VALUES (` + strconv.Itoa(objTypeExperience) + `,` + strconv.Itoa(objSubTypeExperience) + `);`)
	logOnError(err, "addObjXP : exec insert obj")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjXP : rollback insert obj")
		return 0, err
	}

	objId, err := res.LastInsertId()
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjXP : rollback get lastInsertId")
		return 0, err
	}

	stmt, err := tx.Prepare(`INSERT INTO obj_xp	(obj_id, user_id, val, target, level, date)
							 VALUES 			(?,      ?,       ?,   ?,      ?,     ?);`)
	logOnError(err, "addObjXP : prepare insert obj_xp")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjXP : rollback prepare insert obj_xp")
		return 0, err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objId, userID64, expNow, expLvl, level, date)
	logOnError(err, "addObjXP : exec insert obj_xp")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjXP : rollback exec insert obj_xp")
		return 0, err
	}

	err = tx.Commit()
	logOnError(err, "addObjXP : commit")
	if err != nil {
		return 0, err
	}
	return objId, nil
}

func addObjItem(code string, name string, itemTypeID64 int64, weight int) (int64, error) {
	tx, err := db.Begin()
	logOnError(err, "addObjItem : start transaction")
	if err != nil {
		return 0, err
	}

	res, err := tx.Exec(`INSERT INTO obj (obj_type_id, obj_sub_type_id)
						          VALUES (` + strconv.Itoa(objTypeItem) + `,` + fmt.Sprintf("%d", itemTypeID64) + `);`)
	logOnError(err, "addObjItem : exec insert obj")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjItem : rollback insert obj")
		return 0, err
	}

	objId, err := res.LastInsertId()
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjItem : rollback get lastInsertId")
		return 0, err
	}

	stmt, err := tx.Prepare(`INSERT INTO obj_item	(obj_id, intl_id, name, weight)
							 VALUES 				(?,      ?,       ?,    ?);`)
	logOnError(err, "addObjItem : prepare insert obj_item")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjItem : rollback prepare insert obj_item")
		return 0, err
	}
	defer stmt.Close()

	_, err = stmt.Exec(objId, code, name, weight)
	logOnError(err, "addObjItem : exec insert obj_item")
	if err != nil {
		err2 := tx.Rollback()
		logOnError(err2, "addObjItem : rollback exec insert obj_item")
		return 0, err
	}

	err = tx.Commit()
	logOnError(err, "addObjItem : commit")
	if err != nil {
		return 0, err
	}

	c := new(ChatWarsItem)
	c.ObjID64 = objId
	c.Code = code
	c.Name = name
	c.Weight = weight
	cacheObjItem.Store(code, *c)
	cacheObjItem.Store(strings.ToUpper(name), *c)

	return objId, nil
}

func getObjItemID(c string, n string) int64 {
	i := silentGetObjItemID(c, n)
	if i == 0 {
		w := TGCommand{
			Type:       commandSendMsg,
			Text:       fmt.Sprintf("Object unknown : %s - %s\n", c, n),
			ToUserID64: cfg.Bot.Admin,
		}
		TGCmdQueue <- w
	}
	return i
}

func silentGetObjItemID(code string, name string) int64 {
	c := strings.ToLower(code)
	n := strings.ToUpper(name)
	if v, ok := cacheObjItem.Load(c); ok {
		i := v.(ChatWarsItem)
		return i.ObjID64
	}
	if v, ok := cacheObjItem.Load(n); ok {
		i := v.(ChatWarsItem)
		return i.ObjID64
	}
	if ok, _ := regexp.MatchString(`(u|a|e)[0-9]+[a-z]{0,1}`, c); ok {
		r := regexp.MustCompile(`^((?P<Modifier>⚡\+[0-9]+) ){0,1}(?P<BaseName>.+?)( \+(?P<Atk>[0-9]+)⚔){0,1}( \+(?P<Def>[0-9]+)🛡){0,1}( \+(?P<Mana>[0-9]+)💧){0,1}$`)
		n2 := r.ReplaceAllString(n, "${BaseName}")
		if v, ok := cacheObjItem.Load(n2); ok {
			i := v.(ChatWarsItem)
			return i.ObjID64
		}
		fmt.Printf("silentGetObjItemID(unique) : Modifier : `%s`\n", r.ReplaceAllString(n, "${Modifier}"))
		fmt.Printf("silentGetObjItemID(unique) : BaseName : `%s`\n", r.ReplaceAllString(n, "${BaseName}"))
		fmt.Printf("silentGetObjItemID(unique) : Atk : `%s`\n", r.ReplaceAllString(n, "${Atk}"))
		fmt.Printf("silentGetObjItemID(unique) : Def : `%s`\n", r.ReplaceAllString(n, "${Def}"))
		fmt.Printf("silentGetObjItemID(unique) : Mana : `%s`\n", r.ReplaceAllString(n, "${Mana}"))

	}
	if len(c) == 0 {
		r := regexp.MustCompile(`^((?P<Modifier>⚡\+[0-9]+) ){0,1}(?P<BaseName>.+?)( \+(?P<Atk>[0-9]+)⚔){0,1}( \+(?P<Def>[0-9]+)🛡){0,1}( \+(?P<Mana>[0-9]+)💧){0,1}$`)
		n2 := r.ReplaceAllString(n, "${BaseName}")
		if v, ok := cacheObjItem.Load(n2); ok {
			i := v.(ChatWarsItem)
			return i.ObjID64
		}
		fmt.Printf("silentGetObjItemID(null) : Modifier : `%s`\n", r.ReplaceAllString(n, "${Modifier}"))
		fmt.Printf("silentGetObjItemID(null) : BaseName : `%s`\n", r.ReplaceAllString(n, "${BaseName}"))
		fmt.Printf("silentGetObjItemID(null) : Atk : `%s`\n", r.ReplaceAllString(n, "${Atk}"))
		fmt.Printf("silentGetObjItemID(null) : Def : `%s`\n", r.ReplaceAllString(n, "${Def}"))
		fmt.Printf("silentGetObjItemID(null) : Mana : `%s`\n", r.ReplaceAllString(n, "${Mana}"))

	}
	return 0

}

func loadObjItem() error {
	var (
		id      int64
		intl_id string
		name    string
		weight  int
	)

	cacheObjItem = new(sync.Map)

	items, err := db.Query(`SELECT oi.obj_id, oi.intl_id, oi.name, oi.weight FROM obj_item oi;`)
	if err != nil {
		return err
	}
	defer items.Close()

	for items.Next() {
		err = items.Scan(&id, &intl_id, &name, &weight)
		if err != nil {
			return err
		}
		c := new(ChatWarsItem)
		c.ObjID64 = id
		c.Code = intl_id
		c.Name = name
		c.Weight = weight
		cacheObjItem.Store(intl_id, *c)
		cacheObjItem.Store(strings.ToUpper(name), *c)
	}

	return nil
}