package serviceGame

import (
	"context"
	"crypto/md5"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/encoding/gcharset"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"log"
	"time"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/consts"
	"tyj_admin/internal/dao"
	"tyj_admin/internal/model/do"
	"tyj_admin/internal/model/entity"
	"tyj_admin/internal/service"
	"tyj_admin/internal/serviceGame/internal"
	"tyj_admin/library/libUtils"
)

type IGameOrder interface {
	GetOrders(ctx context.Context, req *game.OrderSearchReq) (res *game.OrderSearchRes, err error)
	GetOrderCount(ctx context.Context, req *game.OrderCountReq) (res *game.OrderCountRes, err error)
	ChangeCoin(ctx context.Context, req *game.AddCoinReq) (res *game.AddCoinRes, err error)
	Deposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error)
	GetOrderLog(ctx context.Context, req *game.OrderLogReq) (res *game.OrderLogRes, err error)
	GetOrderLogPlatform(ctx context.Context, req *game.OrderLogPlatformReq) (res *game.OrderLogPlatformRes, err error)
	GetOrderBehavior(ctx context.Context, req *game.OrderBehaviorReq) (res *game.OrderBehaviorRes, err error)
	GetRechargePer(ctx context.Context, req *game.RechargePerReq) (res *game.RechargePerRes, err error)
	GameRechargeControl(ctx context.Context, req *game.RechargeControlReq) (res *game.RechargeControlRes, err error)
	GetRechargeControl(ctx context.Context, req *game.GetRechargeControlReq) (res *game.GetRechargeControlRes, err error)
	AddRechargeControl(ctx context.Context, req *game.AddRechargeControlReq) (res *game.AddRechargeControlRes, err error)
	DeleteRechargeControl(ctx context.Context, req *game.DeleteRechargeControlReq) (res *game.DeleteRechargeControlRes, err error)
	ChangeOrderState(ctx context.Context, req *game.ChangeOrderStateReq) (res *game.ChangeOrderStateRes, err error)
	GetGMOrderList(ctx context.Context, req *game.GetGMOrderListReq) (res *game.GetGMOrderListRes, err error)
	CheckRechargeSign(ctx context.Context, req *game.CheckRechargeSignReq) (res *game.CheckRechargeSignRes, err error)
	AddRechargeSign(ctx context.Context, req *game.AddRechargeSignReq) (res *game.AddRechargeSignRes, err error)
	ResetRechargeSign(ctx context.Context, req *game.ResetRechargeSignReq) (res *game.ResetRechargeSignRes, err error)
	GetTransactionId(ctx context.Context, req *game.GetTransactionIdReq) (res *game.GetTransactionIdRes, err error)
}

type gameOrderImpl struct {
}

var gameOrderService = gameOrderImpl{}

func GameOrder() IGameOrder {
	return &gameOrderService
}

func (o gameOrderImpl) ChangeCoin(ctx context.Context, req *game.AddCoinReq) (res *game.AddCoinRes, err error) {
	res = new(game.AddCoinRes)
	mqttMoney := internal.MqttChangeMoney{}
	mqttMoney.Body.Money = req.Amount
	mqttMoney.Body.Uids = req.Uid
	mqttMoney.Body.Type = req.AmountType
	mqttMoney.Body.ModuleType = "changeMoney"
	mqttMoney.ModuleId = "webadmin"
	mqttMoney.ReqId = 1
	js, err := json.Marshal(mqttMoney)
	connectCh := make(chan bool)
	server := "192.168.2.100:3005"
	internal.SendMqttMoney(js, connectCh, server)
	defer close(connectCh)
	var result bool
	for {
		select {
		case result = <-connectCh:
			if result == false {
				err = gerror.New("失败")
				return
			} else {
				return
			}
		}
	}

}

type AndroIdRecharge struct {
	GmMessage string `json:"gmMessage"`
	Md5Sign   string `json:"md5Sign"`
}

type Recharge struct {
	Uid        string `json:"uid"`
	Server     string `json:"server"`
	Channel    string `json:"channel"`
	RechargeId string `json:"rechargeId"`
	OrderNo    string `json:"orderNo"`
	PayTime    string `json:"payTime"`
	Amount     string `json:"amount"`
	Status     string `json:"status"`
}

type IosRecharge struct {
	OrderId   string `json:"orderId"`
	Account   string `json:"uid"`
	Receipt   string `json:"receipt"`
	Server    string `json:"server"`
	TimeStamp string `json:"timeStamp"`
	ItemId    string `json:"itemId"`
	Gm        string `json:"gm"`
	Token     string `json:"token"`
}

type DepositResult struct {
	Status int         `json:"status"`
	Code   interface{} `json:"code"`
	Msg    string      `json:"msg"`
}

func checkQuickMd5(nt_data string, sign string, md5Sign string) bool {
	return md5Sign == fmt.Sprintf("%x", md5.Sum([]byte(nt_data+sign+internal.Md5key)))
}
func encryptData(code_data string) string {
	dataArr := []rune(code_data)
	keyArr := []byte(internal.CallbackKey)
	keyLen := len(keyArr)

	var tmpList []int

	for index, value := range dataArr {
		base := int(value)
		dataString := base + int(0xFF&keyArr[index%keyLen])
		tmpList = append(tmpList, dataString)
	}

	var str string

	for _, value := range tmpList {
		str += "@" + fmt.Sprintf("%d", value)
	}
	return str
}

var timeFormat = "2006-01-02 15:04:05"

func (o gameOrderImpl) Deposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error) {
	gmMessage := Recharge{}
	//gmMessage.Server = fmt.Sprint(req.ServerId)
	gmMessage.RechargeId = fmt.Sprint(req.DepositId)
	//gmMessage.Channel = req.Channel

	gmMessage.OrderNo = fmt.Sprintf("GM%v%v", req.Uid, time.Now().UnixMilli())
	//gmMessage.OrderNo = fmt.Sprintf("GM%v%v%v", req.Uid, 11111111111, 22222)
	if req.Count == 1 {
		gmMessage.OrderNo = fmt.Sprintf("G2M%v%v", req.Uid, time.Now().UnixMilli())
	}
	gmMessage.PayTime = time.Now().Format(timeFormat)
	gmMessage.Amount = fmt.Sprint(req.Amount)
	gmMessage.Status = "SUCCESS"
	unit, err := internal.GetUnitByUid(ctx, req.Uid, req.ServerId)
	//uid, err := internal.GetIdToUid(ctx, req.Uid)
	if err != nil {
		log.Println("GetOrders 1 : ", req.Uid)
		return nil, err
	}
	if req.ServerId != unit.Server {
		var serverInfo entity.GameLoginUrl
		for _, v := range internal.ServerList {
			if v.Id == unit.Server {
				serverInfo = v
				break
			}
		}
		return nil, errors.New("区服选择错误！当前id在<" + fmt.Sprint(serverInfo.Id) + "><" + serverInfo.Name + ">区")
	}
	gmMessage.Server = fmt.Sprint(unit.Server)
	gmMessage.Channel = unit.Channel
	gmMessage.Uid = fmt.Sprint(unit.Uid)
	recharge := AndroIdRecharge{}
	data, _ := json.Marshal(gmMessage)
	recharge.GmMessage = encryptData(string(data))
	recharge.Md5Sign = fmt.Sprintf("%x", md5.Sum([]byte(recharge.GmMessage+internal.Md5key)))
	fmt.Println("Deposit - json: ", string(data), recharge.Md5Sign)
	url := internal.RechargeServer + "/gmPay/notify"
	rs, err := g.Client().Post(ctx, url, recharge)
	if err != nil {
		log.Println("Post 1 : ", req.Uid, url, gjson.MustEncodeString(recharge))
		return nil, err
	}

	src := string(rs.ReadAll())
	tmp, _ := gcharset.ToUTF8("UTF-8", src)
	fmt.Println("Deposit - json: ", tmp)

	go insertRechargeLog(ctx, gmMessage, tmp)
	if tmp != "SUCCESS" {
		g.Log().Info(ctx, " Deposit === DecodeToJson err ", req.Uid, err.Error())
		return nil, errors.New(tmp)
	}

	return
}

func insertRechargeLog(ctx context.Context, req Recharge, remark string) (err error) {
	_, err = dao.GameRechargeLog.Ctx(ctx).Insert(&do.GameRechargeLog{
		UnitId:  req.Uid,
		Channel: req.Channel,
		Server:  req.Server,
		Amount:  req.Amount,
		Config:  req.RechargeId,
		TradeNo: req.OrderNo,
		User:    service.Context().GetLoginUser(ctx).UserName,
		Remark:  remark,
	})
	return
}

func (o gameOrderImpl) GetOrders(ctx context.Context, req *game.OrderSearchReq) (res *game.OrderSearchRes, err error) {
	if req.PageSize == 0 {
		req.PageSize = 10
	}
	orderModel := dao.GameRecharge.Ctx(ctx)
	if req.Account != "" {
		uid, err := internal.AccountToUids(ctx, req.Account)
		if err != nil {
			return nil, err
		}
		orderModel = orderModel.Where(`unitId in (?) `, uid)
	}
	if req.Uid != 0 {
		uid, err := internal.GetIdToUid(ctx, int64(req.Uid))
		if err != nil {
			return nil, err
		}
		orderModel = orderModel.Where(`unitId=? `, uid)
	}
	if req.Channel != "" {
		orderModel = orderModel.Where(`channel=?`, req.Channel)
	}
	if req.ExternalOrderId != "" {
		orderModel = orderModel.Where(`externalTradeNo=?`, req.ExternalOrderId)
	}
	if req.OrderId != "" {
		orderModel = orderModel.Where(`tradeNo=?`, req.OrderId)
	}
	if req.Status != 0 {
		orderModel = orderModel.Where(`status=?`, req.Status)
	}

	res = new(game.OrderSearchRes)
	res.Total, err = orderModel.Count()
	if err != nil {
		log.Println("GetOrdersBy", err.Error())
	}

	orderModel.Page(int(req.PageNum), int(req.PageSize)).OrderDesc("createTime").Scan(&res.Orders)
	for k, v := range res.Orders {
		res.Orders[k].StringId = fmt.Sprint(v.UnitId)
		uid, _ := internal.GetIdToUid(ctx, v.UnitId)
		res.Orders[k].Uid = int32(uid)
	}
	return
}

func (o gameOrderImpl) GetOrderCount(ctx context.Context, req *game.OrderCountReq) (res *game.OrderCountRes, err error) {
	res = new(game.OrderCountRes)
	sql := fmt.Sprintf(`select unitId,sum(amount) as amount,max(server) as server from game_recharge  where 1=1 and status=2`)
	if req.GM == 0 {
		sql = fmt.Sprintf(`%s and tradeNo NOT LIKE 'GM%%'`, sql)
	}
	if req.Server != 0 {
		sql = fmt.Sprintf(`%s and server=%d`, sql, req.Server)
	}
	sql = fmt.Sprintf(`%s group by unitId`, sql)

	sql = fmt.Sprintf(`select u.account,r.unitId as id,r.amount as allMoney,r.server as serverId from  (%s) as r inner join game_unit as u on u.uid=r.unitId where 1=1`, sql)
	sql = internal.CompareSqlType(sql, req.Amount, "r.amount", req.CompareType)
	res.Total, err = g.Model().Raw(sql).Count()
	if err != nil {
		log.Println("GetOrderCount 1 : ", err.Error())
		return
	}
	err = g.Model().Raw(sql).Page(req.PageNo, req.PageSize).OrderAsc("u.account").Scan(&res.Orders)
	if err != nil {
		log.Println("GetOrderCount 2 : ", err.Error())
		return
	}
	for k, v := range res.Orders {
		if v.Id == 0 {
			continue
		}
		res.Orders[k].StringId = fmt.Sprint(v.Id)
		log.Println("GetOrderCount 31 : ", v.Id)
		uid, err := internal.GetIdToUid(ctx, v.Id)
		if err != nil {
			log.Println("GetOrderCount 3 : ", v.Id, uid, err.Error())
			continue
		}
		res.Orders[k].Uid = int32(uid)
	}
	log.Println("GetOrderCount 4 : ", gjson.MustEncodeString(res.Orders))
	return
}

func (o gameOrderImpl) GetOrderLog(ctx context.Context, req *game.OrderLogReq) (res *game.OrderLogRes, err error) {
	res = new(game.OrderLogRes)

	g.Try(ctx, func(ctx context.Context) {
		modelTotal := dao.GameRegister.Ctx(ctx)
		if req.StartTime != 0 {
			modelTotal = modelTotal.Where(`UNIX_TIMESTAMP(create_time)>?`, req.StartTime/1000)
		}
		if req.EndTime != 0 {
			modelTotal = modelTotal.Where(`UNIX_TIMESTAMP(create_time)<?`, req.EndTime/1000)
		}
		if req.Channel != "" {
			modelTotal = modelTotal.Where(`channel=?`, req.Channel)
			if req.ServerId != 0 {
				modelTotal = modelTotal.Where(`server like ?`, "<"+fmt.Sprint(req.ServerId)+">")
			}
		}
		modelTotal.Group("channel").FieldMax("channel", "channel").FieldCount("account", "totalAccount").Scan(&res.AccountTotal)

		var sql = fmt.Sprintf("select max(r.channel) as channel, sum(r.amount) as amount, u.account from game_recharge as r inner join game_unit as u on u.uid=r.unitId where r.status=2 and r.tradeNo NOT LIKE 'GM%%' ")
		if req.StartTime != 0 {
			sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)>%d`, req.StartTime/1000)
		}
		if req.EndTime != 0 {
			sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)<%d`, req.EndTime/1000)
		}
		if req.RechargeTotal > 0 {
			sql = internal.CompareSqlType(sql, req.RechargeTotal, "r.amount", req.CompareType1)
		}
		if req.Channel != "" {
			sql += fmt.Sprintf(` and r.channel="%s"`, req.Channel)
			if req.ServerId != 0 {
				sql += fmt.Sprintf(` and r.server=%d`, req.ServerId)
			}
		}
		sql += fmt.Sprint(" group by u.account,r.channel")

		amountSql := fmt.Sprintf(`select max(a.channel) as channel, sum(a.amount) as totalAmount from (%s) as a WHERE 1=1 `, sql)
		if req.RechargeMin > 0 {
			amountSql = internal.CompareSqlType(amountSql, req.RechargeMin, "a.amount", req.CompareType)
		}
		amountSql += " group by a.channel"
		g.Model().Raw(amountSql).Scan(&res.AmountTotal)

		accountSql := fmt.Sprintf(`select max(a.channel) as channel, count(1) as totalAccount from (%s) as a WHERE 1=1 `, sql)
		if req.RechargeMin > 0 {
			accountSql = internal.CompareSqlType(accountSql, req.RechargeMin, "a.amount", req.CompareType)
		}
		accountSql += " group by a.channel"
		g.Model().Raw(accountSql).Scan(&res.RechargeAccountTotal)

		log.Printf("GetOrderLog: %v, %v, %v", gjson.MustEncodeString(res.AmountTotal), gjson.MustEncodeString(res.AccountTotal), gjson.MustEncodeString(res.RechargeAccountTotal))
	})
	return
}

func (o gameOrderImpl) GetOrderLogPlatform(ctx context.Context, req *game.OrderLogPlatformReq) (res *game.OrderLogPlatformRes, err error) {
	res = new(game.OrderLogPlatformRes)

	g.Try(ctx, func(ctx context.Context) {
		var sql = fmt.Sprintf("select r.channel, sum(r.amount) as amount,u.account, r.platform from game_recharge as r inner join game_unit as u on u.uid=r.unitId where r.status=2 and r.tradeNo NOT LIKE 'GM%%' ")
		if req.StartTime != 0 {
			sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)>%d`, req.StartTime/1000)
		}
		if req.EndTime != 0 {
			sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)<%d`, req.EndTime/1000)
		}
		if req.RechargeTotal > 0 {
			sql = internal.CompareSqlType(sql, req.RechargeTotal, "r.amount", req.CompareType1)
		}
		if req.Channel != "" {
			sql += fmt.Sprintf(` and r.channel="%s"`, req.Channel)
			if req.ServerId != 0 {
				sql += fmt.Sprintf(` and r.server=%d`, req.ServerId)
			}
		}
		sql += fmt.Sprint(" group by u.account,r.channel,r.platform")

		amountSql := fmt.Sprintf(`select a.channel, sum(a.amount) as totalAmount, a.platform from (%s) as a WHERE 1=1 `, sql)
		if req.RechargeMin > 0 {
			amountSql = internal.CompareSqlType(amountSql, req.RechargeMin, "a.amount", req.CompareType)
		}
		amountSql += " group by a.channel,a.platform"
		g.Model().Raw(amountSql).Scan(&res.AmountTotal)

		log.Printf("GetOrderLog: %v, %v, %v", gjson.MustEncodeString(res.AmountTotal), gjson.MustEncodeString(res.AccountTotal), gjson.MustEncodeString(res.RechargeAccountTotal))
	})
	return
}

func (o gameOrderImpl) GetOrderBehavior(ctx context.Context, req *game.OrderBehaviorReq) (res *game.OrderBehaviorRes, err error) {
	res = new(game.OrderBehaviorRes)
	if req.StartTime == "" {
		return nil, errors.New("填写注册时间！")
	}
	g.Try(ctx, func(ctx context.Context) {
		modelTotal := dao.GameRegister.Ctx(ctx)
		modelTotal = modelTotal.Where(`STR_TO_DATE(create_time, "%Y-%m-%d")=?`, req.StartTime)
		modelTotal.Fields("max(channel) as channel, count(1) as totalAccount").Group("channel").Scan(&res.Account)

		sql := fmt.Sprintf(`select account from game_register where STR_TO_DATE(create_time, "%%Y-%%m-%%d")="%s"`, req.StartTime)
		sql = fmt.Sprintf(`select u.account,u.uid from game_unit as u inner join (%s) as a on a.account=u.account`, sql)

		amountSql := fmt.Sprintf(`select max(r.channel) as channel, sum(r.amount) as totalAmount, STR_TO_DATE(r.createTime, "%%Y-%%m-%%d") as createTime 
			from game_recharge as r inner join (%s) as c on c.uid=r.unitId where r.status=2 and r.tradeNo NOT LIKE 'GM%%' group	by r.channel,STR_TO_DATE(r.createTime, "%%Y-%%m-%%d")`, sql)
		g.Model().Raw(amountSql).Scan(&res.AmountList)

		accountSql := fmt.Sprintf(`SELECT max( a.channel ) AS channel,count(a.account) as totalAccount,a.createTime as createTime  
FROM (SELECT max( r.channel ) AS channel, c.account  AS account,min(STR_TO_DATE( r.createTime, "%%Y-%%m-%%d" )) AS createTime 
FROM game_recharge AS r INNER JOIN (%s) AS c ON c.uid = r.unitId WHERE r.STATUS = 2 AND r.tradeNo NOT LIKE 'GM%%' GROUP BY r.channel, c.account) as a 
GROUP BY a.channel,a.createTime`, sql)
		g.Model().Raw(accountSql).Scan(&res.RechargeAccount)

		log.Printf("GetOrderBehavior: %v, %v, %v", gjson.MustEncodeString(res.Account), gjson.MustEncodeString(res.AmountList), gjson.MustEncodeString(res.RechargeAccount))
	})
	return
}

func (o gameOrderImpl) GetRechargePer(ctx context.Context, req *game.RechargePerReq) (res *game.RechargePerRes, err error) {
	res = new(game.RechargePerRes)
	if req.StartTime == "" || req.EndTime == "" {
		return nil, errors.New("填写注册时间！")
	}
	g.Try(ctx, func(ctx context.Context) {
		modelTotal := dao.GameRegister.Ctx(ctx)
		modelTotal = modelTotal.Where(`tradeNo NOT LIKE 'GM%'`).Where(`STR_TO_DATE(create_time, "%Y-%m-%d")>=?`, req.StartTime).Where(`STR_TO_DATE(create_time, "%Y-%m-%d")<=?`, req.EndTime)
		modelTotal.Fields("max(channel) as channel, count(1) as totalAccount, STR_TO_DATE(create_time, \"%Y-%m-%d\") as createTime").Group("channel,STR_TO_DATE(create_time, \"%Y-%m-%d\")").Scan(&res.Account)

		sql := fmt.Sprintf(`select account,STR_TO_DATE(create_time, "%%Y-%%m-%%d") as createTime  from game_register where STR_TO_DATE(create_time, "%%Y-%%m-%%d")>="%s" and STR_TO_DATE(create_time, "%%Y-%%m-%%d")<="%s"`, req.StartTime, req.EndTime)
		sql = fmt.Sprintf(`select u.account,u.uid,a.createTime from game_unit as u inner join (%s) as a on a.account=u.account`, sql)
		accountSql := fmt.Sprintf(`select max(r.channel) as channel, count(DISTINCT  c.account) as totalAccount, c.createTime
			from game_recharge as r inner join (%s) as c on c.uid=r.unitId where status=2 and tradeNo NOT LIKE 'GM%%' group	by r.channel,c.createTime`, sql)
		g.Model().Raw(accountSql).Scan(&res.RechargeAccount)

		log.Printf("GetOrderBehavior: %v, %v", gjson.MustEncodeString(res.Account), gjson.MustEncodeString(res.RechargeAccount))
	})
	return
}

func (o gameOrderImpl) GameRechargeControl(ctx context.Context, req *game.RechargeControlReq) (res *game.RechargeControlRes, err error) {
	res = new(game.RechargeControlRes)
	model := dao.GameRechargeControl.Ctx(ctx)
	var list []*entity.GameRechargeControl
	model.Where("channel=?", req.Channel).Scan(&list)
	if len(list) == 0 {
		res.State = 1
	}
	return
}

func (o gameOrderImpl) GetRechargeControl(ctx context.Context, req *game.GetRechargeControlReq) (res *game.GetRechargeControlRes, err error) {
	res = new(game.GetRechargeControlRes)
	dao.GameRechargeControl.Ctx(ctx).Scan(&res.Control)

	return
}

func (o gameOrderImpl) AddRechargeControl(ctx context.Context, req *game.AddRechargeControlReq) (res *game.AddRechargeControlRes, err error) {
	res = new(game.AddRechargeControlRes)
	_, err = dao.GameRechargeControl.Ctx(ctx).Insert(do.GameRechargeControl{Channel: req.Channel})
	return
}

func (o gameOrderImpl) DeleteRechargeControl(ctx context.Context, req *game.DeleteRechargeControlReq) (res *game.DeleteRechargeControlRes, err error) {
	res = new(game.DeleteRechargeControlRes)
	_, err = dao.GameRechargeControl.Ctx(ctx).Where("channel=?", req.Channel).Delete()
	return
}

func (o gameOrderImpl) ChangeOrderState(ctx context.Context, req *game.ChangeOrderStateReq) (res *game.ChangeOrderStateRes, err error) {
	res = new(game.ChangeOrderStateRes)
	update := g.Map{
		dao.GameRecharge.Columns().Status: req.State,
	}
	if req.Remark != "" {
		update[dao.GameRecharge.Columns().Remark] = req.Remark
	}
	_, err = dao.GameRecharge.Ctx(ctx).Where(dao.GameRecharge.Columns().TradeNo, req.Order).Update(update)
	if err == nil {
		res.ResData = 1
	}
	return
}

func (o gameOrderImpl) GetGMOrderList(ctx context.Context, req *game.GetGMOrderListReq) (res *game.GetGMOrderListRes, err error) {
	res = new(game.GetGMOrderListRes)
	model := dao.GameRechargeLog.Ctx(ctx)
	if req.Uid != 0 {
		id, _ := internal.GetIdToUid(ctx, int64(req.Uid))
		model = model.Where("unitId=?", id)
	}
	if req.ServerId != 0 {
		model = model.Where("server=?", req.ServerId)
	}
	if req.TradeNo != "" {
		model = model.Where("tradeNo=?", req.TradeNo)
	}
	if req.CTime != "" {
		t, _ := time.ParseInLocation(consts.TIME_FORMAT, req.CTime, time.Local)
		model = model.Where("UNIX_TIMESTAMP(create_time)>=?", t.Unix())
	}
	if req.ETime != "" {
		t, _ := time.ParseInLocation(consts.TIME_FORMAT, req.ETime, time.Local)
		model = model.Where("createTime<=?", t.Unix())
	}
	if req.User != "" {
		model = model.Where("user=?", req.User)
	}
	if req.Config != 0 {
		model = model.Where("config=?", req.Config)
	}
	if req.Channel != "" {
		model = model.Where("channel=?", req.Channel)
	}
	res.Total, err = model.Count()
	if err != nil {
		return nil, err
	}
	err = model.Page(req.PageNum, req.PageSize).Scan(&res.List)
	return
}

func (o gameOrderImpl) CheckRechargeSign(ctx context.Context, req *game.CheckRechargeSignReq) (res *game.CheckRechargeSignRes, err error) {
	res = new(game.CheckRechargeSignRes)
	if req.ServerId == 0 {
		ip := libUtils.GetClientIp(ctx)
		data := []entity.GameRouter{}
		err := dao.GameRouter.Ctx(ctx).Where("router_ip=?", ip).Scan(&data)
		//log.Printf("data: %s", gjson.MustEncodeString(data))
		if len(data) == 0 {
			return nil, err
		}
		req.ServerId = int32(data[0].Id)
	}
	if req.Id == 0 || req.ServerId == 0 {
		return res, errors.New("账号为空")
	}
	list := []entity.GameRechargeLevel{}
	err = dao.GameRechargeLevel.Ctx(ctx).Where("unitId=?", req.Id).Where("server=?", req.ServerId).Scan(&list)
	if err != nil {
		log.Printf("CheckRechargeSign: %v, %v", gjson.MustEncodeString(res), err)
		return res, err
	}
	for _, v := range list {
		res.List = append(res.List, v.Config)
	}
	return
}

// http://192.168.2.100:4111/frontApi/game/setOrderLevel?unitId=1&server=&time=250726&token&config=101
func (o gameOrderImpl) AddRechargeSign(ctx context.Context, req *game.AddRechargeSignReq) (res *game.AddRechargeSignRes, err error) {
	serverId := req.ServerId
	if serverId == 0 {
		ip := libUtils.GetClientIp(ctx)
		data := []entity.GameRouter{}
		err := dao.GameRouter.Ctx(ctx).Where("router_ip=?", ip).Scan(&data)
		//log.Printf("AddRechargeSign data: %s", gjson.MustEncodeString(data))
		if len(data) == 0 {
			log.Printf("AddRechargeSign err : %s", err.Error())
			return nil, err
		}
		serverId = int32(data[0].Id)
	}

	if req.Id == 0 || serverId == 0 || req.Config == 0 || req.Time == 0 {
		return nil, errors.New("参数为空")
	}
	token := fmt.Sprintf("%x", md5.Sum([]byte("#colony"+fmt.Sprint(req.Id)+fmt.Sprint(req.ServerId)+fmt.Sprint(req.Config)+fmt.Sprint(req.Time)+"$")))
	if req.Token != token {
		log.Printf("[%s]AddRechargeSign failed, token error, md5: %s", gjson.MustEncodeString(req), token)
		return nil, errors.New("token err")
	}
	req.ServerId = serverId

	count, err := dao.GameRechargeLevel.Ctx(ctx).Where("unitId=?", req.Id).Where("server=?", req.ServerId).Where("config=?", req.Config).Count()
	if err != nil {
		log.Printf("req: %s, AddRechargeSign:  err: %v", gjson.MustEncodeString(req), err)
		return nil, err
	}
	if count > 0 {
		log.Printf("req: %s, AddRechargeSign: count：%v", gjson.MustEncodeString(req), count)
		return nil, errors.New("is in list")
	}

	_, err = dao.GameRechargeLevel.Ctx(ctx).Insert(do.GameRechargeLevel{UnitId: req.Id, Server: req.ServerId, Config: req.Config})
	if err != nil {
		log.Printf("req: %s, AddRechargeSign: %v, err: %v", gjson.MustEncodeString(req), gjson.MustEncodeString(res), err)
		return nil, err
	}
	return nil, errors.New("ok")
}

func (o gameOrderImpl) ResetRechargeSign(ctx context.Context, req *game.ResetRechargeSignReq) (res *game.ResetRechargeSignRes, err error) {
	user := service.Context().GetLoginUser(ctx)
	fulluser, err1 := service.User().GetUserByUsername(ctx, user.UserName)
	if err1 != nil {
		return nil, err1
	}
	password := libUtils.EncryptPassword(req.Password, fulluser.UserSalt)
	if fulluser.UserPassword != password {
		log.Printf("ResetRechargeSign 密码错误! fulluser: %v, pwd: %s", gjson.MustEncodeString(fulluser), password)
		return nil, errors.New("密码错误!")
	}
	result, err := dao.GameRechargeLevel.Ctx(ctx).Where("1=1").Delete()
	if err != nil {
		log.Printf("ResetRechargeSign: %v", err)
		return nil, err
	}
	rows, err := result.RowsAffected()
	if err != nil {
		log.Printf("ResetRechargeSign: %v", err)
		return nil, err
	}
	log.Printf("ResetRechargeSign: %v", rows)
	return
}

func (o gameOrderImpl) GetTransactionId(ctx context.Context, req *game.GetTransactionIdReq) (res *game.GetTransactionIdRes, err error) {
	res = new(game.GetTransactionIdRes)

	// 查询订单（示例订单号）
	order, err := internal.QueryAppleOrder(req.Order)
	if err != nil {
		log.Printf("查询失败: %v", err)
		return
	}
	res.Order = order
	return
}