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"
	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)
}

// GetTaskTimes 获取任务完成进度
func GetTaskTimes(p *Player, id int32) int64 {
	if p.WelfData != nil && p.WelfData.Task[id] != nil {
		return p.WelfData.Task[id].N
	}
	return 0
}

// IsTaskFinish 是否任务完成
func IsTaskFinish(p *Player, id int32) bool {
	data := srvdata.PBDB_TaskMgr.GetData(id)
	if data == nil {
		return false
	}
	if p.WelfData != nil && p.WelfData.Task[id] != nil {
		return p.WelfData.Task[id].N >= data.GetTargetTimes()
	}
	return false
}

// IsTaskReward 是否任务奖励已领取
func IsTaskReward(p *Player, id int32) bool {
	if p.WelfData != nil && p.WelfData.Task != nil {
		if data := p.WelfData.Task[id]; data != nil && data.Ts > 0 {
			t := srvdata.PBDB_TaskMgr.GetData(id)
			switch t.ActivityType {
			case common.TaskActivityTypeEveryDay, common.TaskActivityTypePermitEveryDay:
				if common.TsInSameDay(time.Now().Unix(), data.Ts) {
					return true
				}

			case common.TaskActivityTypeWeek:
				if common.TsInSameWeek(time.Now().Unix(), data.Ts) {
					return true
				}

			case common.TaskActivityTypeNovice, common.TaskActivityTypeInvite, common.TaskActivityTypeAchieve:
				if data.Ts > 0 {
					return true
				}
			case common.TaskActivityTypePermit:
				startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
				endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
				if startTs > 0 {
					return data.Ts >= startTs && data.Ts < endTs
				}
				return true
			}
		}
	}
	return false
}

func SendReward(p *Player, m map[int64]int64, tp int32) {
	isPermit := p.GetIsPermit()
	add := p.GetSkillAdd(common.SkillIdTask)
	var items []*model.Item
	for k, v := range m {
		if k == common.ItemIDPermit && isPermit {
			v += int64(float64(v) * common.PermitAdd)
		}
		// 皮肤技能每日任务金币加成
		if tp == common.TaskActivityTypeEveryDay && add > 0 && k == common.ItemIDCoin {
			v += int64((float64(v) * float64(add)) / 100.0)
		}
		items = append(items, &model.Item{
			ItemId:  int32(k),
			ItemNum: v,
		})
	}
	gain := int32(0)
	giveType := int32(-1)
	switch tp {
	case 1:
		gain = common.GainWayItemTaskEveryDay
		giveType = model.SystemFreeGive_GiveType_TaskEveryDay
	case 2:
		gain = common.GainWayItemWeekActive
		giveType = model.SystemFreeGive_GiveType_TaskWeekActive
	case 3:
		gain = common.GainWayItemTaskNewPlayer
		giveType = model.SystemFreeGive_GiveType_TaskNewPlayer
	case 4:
		gain = common.GainWayItemTaskInvite
		giveType = model.SystemFreeGive_GiveType_TaskInvite
	case 5:
		gain = common.GainWayItemTaskAchievement
		giveType = model.SystemFreeGive_GiveType_TaskAchievement
	case 6:
		gain = common.GainWayItemTaskPermit
		giveType = model.SystemFreeGive_GiveType_TaskPermit
	}
	BagMgrSingleton.AddItems(&model.AddItemParam{
		Platform:   p.Platform,
		SnId:       p.SnId,
		Change:     items,
		Add:        0,
		GainWay:    gain,
		Operator:   "system",
		Remark:     "任务奖励",
		GameId:     0,
		GameFreeId: 0,
	})
	for _, v := range items {
		tp := int32(-1)
		if v.ItemId == common.ItemIDCoin {
			tp = model.SystemFreeGive_CoinType_Coin
		} else if v.ItemId == common.ItemIDDiamond {
			tp = model.SystemFreeGive_CoinType_Diamond
		}
		if !p.IsRob && tp >= 0 && giveType >= 0 {
			LogChannelSingleton.WriteMQData(
				model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, giveType, tp, v.ItemNum))
		}
	}
}

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.GetPlayer(sid)
	if p == nil {
		return nil
	}

	add := p.GetSkillAdd(common.SkillIdTask)
	ret := &taskproto.SCTaskList{
		Tp: msg.GetTp(),
	}

	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.GetPlayer(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 {
				SendReward(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()
			}
			LogChannelSingleton.WriteLog(taskLog)
			ret.OpCode = taskproto.OpResultCode_OPRC_Success
		}
	}

	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.GetPlayer(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
}