package svc

import (
	"errors"
	"net/rpc"

	"github.com/globalsign/mgo"
	"github.com/globalsign/mgo/bson"

	"mongo.games.com/game/common"
	"mongo.games.com/game/dbproxy/mongo"
	"mongo.games.com/game/model"
	"mongo.games.com/goserver/core/logger"
)

func ItemLogsCollection(plt string) *mongo.Collection {
	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, model.ItemLogDBName)
	if s != nil {
		c_itemlog, first := s.DB().C(model.ItemLogCollName)
		if first {
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"logtype"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"itemid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"createts"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"-createts"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"typeid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gameid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gamefreeid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"snid", "logtype", "itemid", "typeid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"roomconfigid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"typeid", "roomconfigid"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"-ts"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"seq"}, Background: true, Sparse: true})
			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gamedif"}, Background: true, Sparse: true})
		}
		return c_itemlog
	}
	return nil
}

type ItemLogSvc struct {
}

func (svc *ItemLogSvc) InsertItemLog(log *model.ItemLog, ret *bool) (err error) {
	clog := ItemLogsCollection(log.Platform)
	if clog == nil {
		logger.Logger.Errorf("ItemLogSvc.InsertItemLog get collection fail platform:%v", log.Platform)
		return
	}
	err = clog.Insert(log)
	if err != nil {
		logger.Logger.Warn("InsertItemLog error:", err)
		return
	}
	*ret = true
	return
}

func (svc *ItemLogSvc) Insert(req *model.InsertItemLogReq, res *bool) error {
	if len(req.Logs) == 0 {
		return nil
	}

	clog := ItemLogsCollection(req.Logs[0].Platform)
	if clog == nil {
		logger.Logger.Errorf("ItemLogSvc.Insert get collection fail platform:%v", req.Logs[0].Platform)
		return nil
	}
	var docs []interface{}
	for _, v := range req.Logs {
		docs = append(docs, v)
	}
	if err := clog.Insert(docs...); err != nil {
		logger.Logger.Errorf("ItemLogSvc.Insert error: %v", err)
		return err
	}
	*res = true
	return nil
}

func (svc *ItemLogSvc) UpdateState(req *model.UpdateParam, res *model.UpdateRes) error {
	c := ItemLogsCollection(req.Platform)
	if c == nil {
		logger.Logger.Errorf("ItemLogSvc.UpdateState get collection fail platform:%v", req.Platform)
		return nil
	}
	err := c.UpdateId(req.LogId, bson.M{"$set": bson.M{"status": req.State}})
	if err != nil {
		logger.Logger.Errorf("ItemLogSvc.UpdateState error: %v", err)
	}
	return err
}

// GetItemCount 获取v卡兑换消耗数量
func GetItemCount(platform string, snid, id int32, tp int) (count int64) {
	c := ItemLogsCollection(platform)
	if c == nil {
		logger.Logger.Errorf("ItemLogSvc.GetItemCount get collection fail platform:%v", platform)
		return 0
	}
	var err error
	var swapN int64
	var costN int64
	type m struct {
		Count int64 `bson:"count"`
	}
	tc := new(m)
	// 兑换返还
	err = c.Pipe([]bson.M{
		{"$match": bson.M{"snid": snid, "logtype": 0, "itemid": id, "typeid": common.GainWay_Exchange}},
		{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": "$count"}}},
	}).AllowDiskUse().One(tc)
	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
		logger.Logger.Error("GetItemCount swapN error:", err)
		return 0
	}
	swapN = tc.Count

	// 消耗总数量
	tc = new(m)
	err = c.Pipe([]bson.M{
		{"$match": bson.M{"snid": snid, "logtype": 1, "itemid": id, "typeid": common.GainWay_Exchange}},
		{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": "$count"}}},
	}).AllowDiskUse().One(tc)
	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
		logger.Logger.Error("GetItemCount costN error:", err)
		return 0
	}
	costN = tc.Count

	if tp == 0 {
		// 获得数量 = 获得总数量 - 兑换返还 - 比赛返回
	} else {
		// 消耗数量 = 消耗总数量 - 兑换返还
		count = costN - swapN
	}
	if count < 0 {
		count = 0
	}
	return count
}

func (svc *ItemLogSvc) GetItemCount(req *model.ItemCountParam, count *int64) error {
	*count = GetItemCount(req.Platform, req.Snid, req.Id, req.Tp)
	return nil
}

func (svc *ItemLogSvc) GetClawdollItemLog(args *model.ClawdollItemLogReq, ret *model.GetClawdollItemLogRet) (err error) {

	limitDataNum := 200
	var Logs []model.RetClawdollItemLog
	for _, typeId := range args.TypeIds {
		var SubLogs []model.RetClawdollItemLog
		var sql []bson.M
		sql = append(sql, bson.M{"snid": args.Snid, "typeid": typeId})

		switch typeId {
		case common.GainWay_ShopBuy: // 充值记录
			sql = append(sql, bson.M{"itemid": common.ItemIDClawdoll})
		case common.GainWayItemShopChangeDoll: // 积分支出
			sql = append(sql, bson.M{"itemid": common.ItemDollCard})
		case common.GainWayItemFenGain: // 积分获取
			sql = append(sql, bson.M{"itemid": common.ItemDollCard})
		}

		c := ItemLogsCollection(args.Platform)
		if c == nil {
			return
		}

		err = c.Find(bson.M{"$and": sql}).Sort("-createts").Limit(limitDataNum).Select(bson.M{"itemid": 1, "createts": 1, "typeid": 1, "count": 1, "logtype": 1}).All(&SubLogs)

		Logs = append(Logs, SubLogs...)
	}

	ret.Logs = Logs
	return
}

func (svc *ItemLogSvc) GetClawdollSuccessItemLog(args *model.ClawdollSuccessItemLogReq, ret *model.GetClawdollSuccessItemLogRet) (err error) {
	itemTypeIds := []int32{common.GainWayClawdollCatch}
	cond := bson.M{"typeid": bson.M{"$in": itemTypeIds}}

	c := ItemLogsCollection(args.Platform)
	if c == nil {
		return
	}

	limitDataNum := 300
	var datas []model.ItemLog
	err = c.Find(cond).Sort("-createts").Limit(limitDataNum).All(&datas)
	if err != nil {
		logger.Logger.Error("GetClawdollSuccessItemLog error: ", err)
		return err
	}

	if datas == nil {
		logger.Logger.Error("GetClawdollSuccessItemLog datas == nil error")
		return nil
	}

	if len(datas) > 0 {
		type PInfo struct {
			SnId  int32
			Name  string // 昵称
			Roles *model.ModInfo
		}

		var retPlayerList []PInfo
		cplayerdata := PlayerDataCollection(args.Platform)
		if cplayerdata == nil {
			return err
		}

		var conds []int32
		tempMap := map[int32]byte{} // 存放不重复主键
		for i := 0; i < len(datas); i++ {
			l := len(tempMap)
			tempMap[datas[i].SnId] = 0
			if len(tempMap) != l { // 加入map后，map长度变化，则元素不重复
				conds = append(conds, datas[i].SnId)
			}
		}

		selecter := bson.M{"snid": bson.M{"$in": conds}}
		err = cplayerdata.Find(selecter).Select(bson.M{"snid": 1, "name": 1, "roles": 1}).All(&retPlayerList)
		if err != nil {
			logger.Logger.Error("GetClawdollSuccessItemLog find player is error", err)
			return err
		}

		for _, data := range datas {
			log := model.ClawdollSuccessItemLog{
				SnId: data.SnId,
				Time: data.CreateTs,
			}

			for _, playerData := range retPlayerList {
				if playerData.SnId == data.SnId {
					log.Name = playerData.Name
					// 头像模型ID
					roleId := common.DefaultRoleId
					if playerData.Roles != nil {
						roleId = int(playerData.Roles.ModId)
					}
					log.ModId = int32(roleId)

					ret.Logs = append(ret.Logs, log)
					break
				}
			}
		}
	}

	return
}

func (svc *ItemLogSvc) GetItemLog(req *model.GetItemLogParam, res *model.GetItemLogRes) error {
	c := ItemLogsCollection(req.Plt)
	if c == nil {
		logger.Logger.Errorf("ItemLogSvc.GetItemLog get collection fail platform:%v", req.Plt)
		return nil
	}

	err := c.Find(bson.M{"snid": req.SnId, "ts": bson.M{"$gt": req.Ts}}).Sort("ts", "seq").All(&res.Logs)
	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
		logger.Logger.Errorf("ItemLogSvc.GetItemLog error: %v", err)
		return err
	}
	return nil
}

func init() {
	rpc.Register(new(ItemLogSvc))
}