package model

import (
	"errors"
	"mongo.games.com/game/protocol/server"
	"time"

	"github.com/globalsign/mgo/bson"
	"mongo.games.com/goserver/core/logger"
)

var (
	ItemLogDBName   = "log"
	ItemLogCollName = "log_itemlog"
	ClawDollItemIds = []int32{40003, 40004, 80001, 80002}
)

type ItemLog struct {
	LogId        bson.ObjectId `bson:"_id"`
	Platform     string        //平台
	SnId         int32         //玩家id
	LogType      int32         //记录类型 0.获取 1.消耗
	ItemId       int32         //道具id
	ItemName     string        //道具名称
	Count        int64         //个数
	CreateTs     int64         //记录时间
	Ts           int64         // 纳秒时间戳
	Remark       string        //备注
	TypeId       int32         // 变化类型
	GameId       int64         // 游戏id,游戏中获得时有值
	GameFreeId   int64         // 场次id,游戏中获得时有值
	Cost         []*Item       // 消耗的道具
	Id           string        // 撤销的id，兑换失败
	RoomConfigId int32         // 房间配置id
	Offline      int32         // 离线时的记录
}

func NewItemLog() *ItemLog {
	log := &ItemLog{LogId: bson.NewObjectId()}
	return log
}

type ItemParam struct {
	Platform     string  // 平台
	SnId         int32   // 玩家id
	LogType      int32   // 记录类型 0.获取 1.消耗
	ItemId       int32   // 道具id
	ItemName     string  // 道具名称
	Count        int64   // 个数
	Remark       string  // 备注
	TypeId       int32   // 变化类型
	GameId       int64   // 游戏id,游戏中获得时有值
	GameFreeId   int64   // 场次id,游戏中获得时有值
	Cost         []*Item // 消耗的道具
	LogId        string  // 撤销的id，兑换失败
	RoomConfigId int32   // 房间配置id
	Offline      int32   // 离线记录
}

func NewItemLogEx(param ItemParam) *ItemLog {
	now := time.Now()
	itemLog := NewItemLog()
	itemLog.Platform = param.Platform
	itemLog.SnId = param.SnId
	itemLog.LogType = param.LogType
	itemLog.ItemId = param.ItemId
	itemLog.ItemName = param.ItemName
	itemLog.Count = param.Count
	itemLog.CreateTs = now.Unix()
	itemLog.Ts = now.UnixNano()
	itemLog.Remark = param.Remark
	itemLog.TypeId = param.TypeId
	itemLog.GameId = param.GameId
	itemLog.GameFreeId = param.GameFreeId
	itemLog.Cost = param.Cost
	itemLog.Id = param.LogId
	itemLog.RoomConfigId = param.RoomConfigId
	itemLog.Offline = param.Offline
	return itemLog
}

type ItemCountParam struct {
	Platform string
	Snid     int32 // 玩家id
	Id       int32 // 道具id
	Tp       int   // 类型 0.获取 1.消耗
}

func GetItemCount(param *ItemCountParam) (int64, error) {
	if rpcCli == nil {
		logger.Logger.Warnf("rpcCli is nil")
		return 0, errors.New("rpcCli is nil")
	}

	var ret int64
	err := rpcCli.CallWithTimeout("ItemLogSvc.GetItemCount", param, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Warnf("GetItemCount err:%v", err)
		return 0, err
	}

	return ret, err
}

type UpdateParam struct {
	Platform string
	LogId    bson.ObjectId
	State    int
}

type UpdateRes struct {
}

func UpdateItemState(param *UpdateParam) error {
	if rpcCli == nil {
		logger.Logger.Warnf("rpcCli is nil")
		return errors.New("rpcCli is nil")
	}

	var ret UpdateRes
	err := rpcCli.CallWithTimeout("ItemLogSvc.UpdateState", param, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Warnf("UpdateItemState err:%v", err)
		return err
	}

	return err
}

type ClawdollItemLogReq struct {
	Platform string
	Snid     int32   // 玩家id
	ItemIds  []int32 // 道具id
}

type GetClawdollItemLogRet struct {
	Logs []ItemLog
}

func GetClawdollItemLog(plt string, snid int32) (logs []ItemLog, err error) {

	if rpcCli == nil {
		logger.Logger.Error("model.GetClawdollItemLog rpcCli == nil")
		return
	}

	args := &ClawdollItemLogReq{
		Platform: plt,
		Snid:     snid,
	}

	args.ItemIds = append(args.ItemIds, ClawDollItemIds...)

	var ret GetClawdollItemLogRet

	//var ret ClawdollItemLogRet
	err = rpcCli.CallWithTimeout("ItemLogSvc.GetClawdollItemLog", args, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Warnf("GetClawdollItemLog err:%v", err)
		return
	}

	logs = ret.Logs

	return
}

type GetItemLogParam struct {
	Plt  string
	SnId int32
	Ts   int64
}

type GetItemLogRes struct {
	Logs []*ItemLog
}

func GetItemLog(plt string, snid int32, ts int64) ([]*ItemLog, error) {
	if rpcCli == nil {
		logger.Logger.Warnf("rpcCli is nil")
		return nil, errors.New("rpcCli is nil")
	}

	var ret GetItemLogRes
	err := rpcCli.CallWithTimeout("ItemLogSvc.GetItemLog", &GetItemLogParam{
		Plt:  plt,
		SnId: snid,
		Ts:   ts,
	}, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Errorf("GetItemLog err:%v", err)
		return nil, err
	}

	return ret.Logs, nil
}

type InsertItemLogReq struct {
	Logs []*ItemLog
}

func InsertItemLog(configItems map[int32]*server.DB_GameItem, param *AddItemParam, isOffline bool) error {
	if rpcCli == nil {
		logger.Logger.Warnf("rpcCli is nil")
		return errors.New("rpcCli is nil")
	}

	var logs []*ItemLog
	for _, v := range param.Change {
		num := v.ItemNum
		logType := 0
		if v.ItemNum < 0 {
			logType = 1
			num = -v.ItemNum
		}
		offline := 0
		if isOffline {
			offline = 1
		}
		// 日志
		name := ""
		if configItems != nil && configItems[v.ItemId] != nil {
			name = configItems[v.ItemId].GetName()
		}
		log := NewItemLogEx(ItemParam{
			Platform:     param.Platform,
			SnId:         param.SnId,
			LogType:      int32(logType),
			ItemId:       v.ItemId,
			ItemName:     name,
			Count:        num,
			Remark:       param.Remark,
			TypeId:       param.GainWay,
			GameId:       param.GameId,
			GameFreeId:   param.GameFreeId,
			Cost:         param.Cost,
			LogId:        param.LogId,
			RoomConfigId: param.RoomConfigId,
			Offline:      int32(offline),
		})
		logs = append(logs, log)
	}
	var ret bool
	err := rpcCli.CallWithTimeout("ItemLogSvc.Insert", &InsertItemLogReq{
		Logs: logs,
	}, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Errorf("InsertItemLog err:%v", err)
		return err
	}
	return nil
}