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})
		}
		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 {
		return
	}
	err = clog.Insert(log)
	if err != nil {
		logger.Logger.Warn("InsertItemLog error:", err)
		return
	}
	*ret = true
	return
}

// GetItemCount 获取v卡兑换消耗数量
func GetItemCount(platform string, snid, id int32, tp int) (count int64) {
	c := ItemLogsCollection(platform)
	if c == nil {
		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.Warn("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.Warn("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) UpdateState(req *model.UpdateParam, res *model.UpdateRes) error {
	c := ItemLogsCollection(req.Platform)
	if c == nil {
		return nil
	}
	err := c.UpdateId(req.LogId, bson.M{"$set": bson.M{"status": req.State}})
	return err
}

func (svc *ItemLogSvc) GetClawdollItemLog(args *model.ClawdollItemLogReq, ret *model.GetClawdollItemLogRet) (err error) {
	itemTypeIds := []int32{common.GainWayClawdollCostItem, common.GainWayItemShopChangeDoll, common.GainWayItemBagChangeDoll, common.GainWayClawdollCatch}
	cond := bson.M{"snid": args.Snid, "typeid": bson.M{"$in": itemTypeIds}}

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

	err = c.Find(cond).All(&ret.Logs)
	return
}

func (svc *ItemLogSvc) GetItemLog(req *model.GetItemLogParam, res *model.GetItemLogRes) error {
	c := ItemLogsCollection(req.Plt)
	if c == nil {
		return nil
	}

	err := c.Find(bson.M{"snid": req.SnId, "ts": bson.M{"$gt": req.Ts}}).All(&res.Logs)
	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
		return err
	}
	return nil
}

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 collection not found 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.Warn("ItemLogSvc.Insert error:", err)
		return err
	}
	*res = true
	return nil
}

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