package main

import (
	"time"

	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/mq"
	taskproto "mongo.games.com/game/protocol/task"
	"mongo.games.com/game/srvdata"
)

const (
	TaskStateFinish = 1 // 任务完成
	TaskStateReward = 2 // 任务奖励已领取
)

func init() {
	// 获取任务列表
	common.Register(int(taskproto.TaskPacketID_PACKET_CSTaskList), taskproto.CSTaskList{}, CSTaskList)
	// 领取任务奖励
	common.Register(int(taskproto.TaskPacketID_PACKET_CSTaskReward), taskproto.CSTaskReward{}, CSTaskReward)
	//  测试用：直接增加任务计数
	common.Register(int(taskproto.TaskPacketID_PACKET_CSDebugInc), taskproto.CSTaskDebugInc{}, CSTaskDebugInc)
}

func CSTaskList(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSTaskList %v", data)
	msg, ok := data.(*taskproto.CSTaskList)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		return nil
	}

	add := p.GetSkillAdd(common.SkillIdTask)
	ret := &taskproto.SCTaskList{
		Tp: msg.GetTp(),
	}
	if msg.GetTp() == common.TaskActivityTypeConsume {
		conf := WelfareMgrSington.GetConfig(p.Platform).ConsumeConfig
		if conf != nil {
			ret.StartTs = common.StrTimeToTs(conf.StartTime)
			ret.EndTs = common.StrTimeToTs(conf.EndTime)
			ret.On = conf.GetOn() == common.On
		}
	}

	for _, v := range srvdata.TaskMgr.GetActivityType(msg.GetTp()) {
		item := &taskproto.TaskData{
			Id:       v.Id,
			N:        GetTaskTimes(p, v.Id),
			TargetN:  v.GetTargetTimes(),
			Status:   0,
			Reward:   make(map[int64]int64),
			TaskType: v.GetTaskType(),
		}
		// 皮肤技能每日任务金币加成
		for k, vv := range v.GetAward() {
			if v.GetActivityType() == common.TaskActivityTypeEveryDay && add > 0 && k == common.ItemIDCoin {
				vv += int64((float64(vv) * float64(add)) / 100.0)
			}
			item.Reward[k] = vv
		}
		if item.N > item.TargetN {
			item.N = item.TargetN
		}
		if IsTaskReward(p, v.Id) {
			item.Status = TaskStateReward
		} else if IsTaskFinish(p, v.Id) {
			item.Status = TaskStateFinish
		}
		ret.List = append(ret.List, item)
	}
	p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCTaskList), ret)
	logger.Logger.Tracef("SCTaskList %v", ret)
	return nil
}

func CSTaskReward(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSTaskReward %v", data)
	msg, ok := data.(*taskproto.CSTaskReward)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		return nil
	}

	add := p.GetSkillAdd(common.SkillIdTask)
	now := time.Now()

	ret := &taskproto.SCTaskReward{
		OpCode: taskproto.OpResultCode_OPRC_Error,
		Tp:     msg.GetTp(),
		Id:     msg.GetId(),
		Reward: make(map[int64]int64),
	}
	isPermit := p.GetIsPermit()
	f := func(id int32) {
		if IsTaskFinish(p, id) && !IsTaskReward(p, id) {
			p.WelfData.Task[id].Ts = time.Now().Unix()
			// 任务完成记录
			taskLog := &model.BackendPermitTask{
				Platform: p.Platform,
				StartTs:  PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs,
				SnId:     p.SnId,
				TaskId:   id,
				Ts:       now.Unix(),
			}
			data := srvdata.PBDB_TaskMgr.GetData(id)
			if data != nil {
				SendTaskReward(p, data.Award, msg.Tp)
				for k, vv := range data.GetAward() {
					if k == common.ItemIDPermit && isPermit {
						vv += int64(float64(vv) * common.PermitAdd)
					}
					// 皮肤技能每日任务金币加成
					if data.GetActivityType() == common.TaskActivityTypeEveryDay && add > 0 && k == common.ItemIDCoin {
						vv += int64((float64(vv) * float64(add)) / 100.0)
					}
					ret.Reward[k] = ret.Reward[k] + vv
				}
				for k, v := range ret.Reward {
					taskLog.Gain = append(taskLog.Gain, model.AwardItem{
						Id:  int32(k),
						Num: v,
					})
				}
				taskLog.TaskName = data.GetDes()
				taskLog.ActivityType = data.GetActivityType()
				taskLog.TaskType = data.GetTaskType()
			}
			mq.Write(taskLog)
			ret.OpCode = taskproto.OpResultCode_OPRC_Success
		}
	}

	if msg.GetTp() == common.TaskActivityTypeConsume {
		conf := WelfareMgrSington.GetConfig(p.Platform).ConsumeConfig
		if conf == nil || conf.GetOn() != common.On || now.Unix() < common.StrTimeToTs(conf.StartTime) || now.Unix() >= common.StrTimeToTs(conf.EndTime) {
			p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCTaskReward), ret)
			logger.Logger.Tracef("SCTaskReward %v", ret)
			return nil
		}
	}

	if msg.Tp > 0 && msg.Id == 0 {
		// 一键领取
		for _, v := range srvdata.TaskMgr.GetActivityType(msg.GetTp()) {
			f(v.GetId())
		}
		ret.OpCode = taskproto.OpResultCode_OPRC_Success
	} else {
		f(msg.GetId())
	}

	p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCTaskReward), ret)
	logger.Logger.Tracef("SCTaskReward %v", ret)
	return nil
}

func CSTaskDebugInc(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	if !common.Config.IsDevMode {
		return nil
	}

	logger.Logger.Tracef("CSTaskDebugInc %v", data)
	msg, ok := data.(*taskproto.CSTaskDebugInc)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		return nil
	}

	id := msg.GetId()
	taskType := int32(-1)
	d := srvdata.PBDB_TaskMgr.GetData(id)
	if d != nil {
		taskType = d.TaskType
	}

	p.ResetTaskN(taskType)
	TaskSubjectSingleton.Touch(int(taskType), &TaskData{
		SnId:  p.SnId,
		Num:   int64(msg.GetAddNum()),
		Debug: true,
	})

	ret := &taskproto.SCTaskDebugInc{
		OpCode: taskproto.OpResultCode_OPRC_Success,
	}
	p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCDebugInc), ret)
	logger.Logger.Tracef("CSTaskDebugInc %v", ret)
	return nil
}