package cache

import (
	"strings"

	"gitee.com/liuxuezhan/mylib/GameServer/CSV"
	proto "gitee.com/liuxuezhan/mylib/Protocol"
	"gitee.com/liuxuezhan/mylib/Utils/wlog"
	"gitee.com/liuxuezhan/mylib/common"
	"gitee.com/liuxuezhan/mylib/wtime"
)

var (
	readonlyMinMaxLevelIDTripleArray MinMaxLevelIDTripleArray
	readonlyLevelRequireToTaskIDMap  map[string][]int64
	refreshDispatchTaskTime          = uint64(0)
)

type Asset_DispatchTask struct {
	Basic
	AssetData  *proto.ST_DispatchTaskAsset_PB
	nextTaskId uint64
}

func (object *Asset_DispatchTask) ReUse() {
	object.AssetData = &proto.ST_DispatchTaskAsset_PB{LastRefreshTime: proto.SetUint64(0)}
	object.Dirty()
}

func (this *Asset_DispatchTask) ToClientString() []byte {
	return common.AddVersionInfoBeforeData(this.ToServerString(), this.versionid)
}

func (this *Asset_DispatchTask) ToServerString() []byte {
	this.RLock()
	defer this.RUnlock()
	return proto.Marshal(this.AssetData)
}

func (object *Asset_DispatchTask) FromString(pb []byte) {

	if 0 != len(pb) {
		object.AssetData = &proto.ST_DispatchTaskAsset_PB{}
		err := proto.Unmarshal(pb, object.AssetData)
		if nil != err {
			wlog.Error(err)
		}
		if object.SafeRefreshTask() {
			object.Dirty()
		}
	} else {
		object.ReUse()
	}

	for _, task := range object.AssetData.GetTaskList() {
		if task.GetId() > object.nextTaskId {
			object.nextTaskId = task.GetId() + 1
		}
	}
}

/**
@brief 设置最后刷新时间
*/
func (object *Asset_DispatchTask) SafeResetLastRefreshTime() *Asset_DispatchTask {
	object.Lock()
	defer object.Unlock()

	object.AssetData.LastRefreshTime = proto.SetUint64(0)
	object.Dirty()
	return object
}

/**
@brief 从配置中读取刷新时间
*/
func (object *Asset_DispatchTask) GetRefreshSecondsFromConfig() uint64 {
	return refreshDispatchTaskTime
}

/**
@brief 处理完成的任务
*/
func (object *Asset_DispatchTask) SafeRefreshTask() bool {
	object.Lock()
	defer object.Unlock()

	//>>>转换已完成任务状态
	dirty := false
	now := uint64(wtime.GetNowTime().Unix())
repeat:
	for i := 0; i < len(object.AssetData.TaskList); i++ {
		task := object.AssetData.TaskList[i]
		if 0 == task.GetStartTime() ||
			uint32(proto.DispatchTaskStatus_DTS_NOT_RECEIVED) == task.GetStatus() ||
			uint32(proto.DispatchTaskStatus_DTS_FINISHED) == task.GetStatus() {
			//>>>没有开始的任务过期
			if 0 == object.AssetData.GetLastRefreshTime() ||
				now > task.GetCreateTime()+object.GetRefreshSecondsFromConfig() {
				dirty = true
				if 1 < len(object.AssetData.TaskList) {
					object.AssetData.TaskList = append(object.AssetData.TaskList[:i], object.AssetData.TaskList[i+1:]...)
					goto repeat
				}

				object.AssetData.TaskList = make([]*proto.ST_DispatchTaskEntry_PB, 0)
				break
			}
			continue
		}
		//>>>进行中的任务有可能已经完成
		if uint32(proto.DispatchTaskStatus_DTS_WORKING) == task.GetStatus() {
			taskEntry := CSV.Mgr.CSV_DispatchTask.GetEntryPtr(int64(task.GetTaskID()))
			if now >= task.GetStartTime()+uint64(taskEntry.FinishTime*60) {
				task.Status = proto.SetUint32(uint32(proto.DispatchTaskStatus_DTS_CAN_REWARD))
				dirty = true
				continue
			}
		}
	}
	return dirty
}

/**
@brief 填充事件
*/
func (object *Asset_DispatchTask) SafeFillDispatchTask(mainCityLevel uint32, nextTaskId func() (bool, uint32)) bool {
	object.Lock()
	defer object.Unlock()

	//任务到期自动刷新
	if 0 != object.AssetData.GetLastRefreshTime() &&
		wtime.GetNow() < object.AssetData.GetLastRefreshTime()+object.GetRefreshSecondsFromConfig() {
		return false
	}
	if 0 == mainCityLevel {
		return false
	}

	const maxRepeatedTimes = 32 //最大重试次数32次

	repeatedTimes := 0
	dirty := false
	now := uint64(0)
	maxTaskNumber := int64(CSV.GetGameConfigValueUint32("DISPATCH_TASK_MAX_NUMBER"))
	loopCount := maxTaskNumber - int64(len(object.AssetData.TaskList))
	for i := int64(0); i < loopCount; {
		if repeatedTimes > maxRepeatedTimes {
			break
		}
		valid, taskID := nextTaskId()
		if !valid {
			repeatedTimes++
			continue
		}
		now = uint64(wtime.GetNowTime().Unix())
		object.AssetData.TaskList = append(object.AssetData.TaskList, &proto.ST_DispatchTaskEntry_PB{
			Id:              proto.SetUint64(object.nextTaskId),
			TaskID:          proto.SetUint32(uint32(taskID)),
			Status:          proto.SetUint32(uint32(proto.DispatchTaskStatus_DTS_NOT_RECEIVED)),
			CreateTime:      proto.SetUint64(now),
			StartTime:       proto.SetUint64(0),
			FinishedPercent: proto.SetUint32(0),
		})
		i++
		object.nextTaskId++
		dirty = true
	}
	if 0 != now {
		//随机到数据后修改最后刷新时间
		object.AssetData.LastRefreshTime = proto.SetUint64(now)
	}
	return dirty
}

/**
@brief 通过等级获取ID列表
*/
func (object *Asset_DispatchTask) LevelToIDArray(level uint32) []int64 {
	for _, triple := range readonlyMinMaxLevelIDTripleArray {
		if triple.minLevel <= level && triple.maxLevel >= level {
			return readonlyLevelRequireToTaskIDMap[triple.key]
		}
	}
	return nil
}

type MinMaxLevelIDTriple struct {
	minLevel uint32
	maxLevel uint32
	key      string
}

type MinMaxLevelIDTripleArray []*MinMaxLevelIDTriple

func (object MinMaxLevelIDTripleArray) Len() int {
	return len(object)
}

func (object MinMaxLevelIDTripleArray) Less(i, j int) bool {
	return object[i].minLevel < object[j].minLevel
}

func (object MinMaxLevelIDTripleArray) Swap(i, j int) {
	object[i], object[j] = object[j], object[i]
}

/**
@brief 解析最大最小值
*/
func parseMinMax(input string) (uint32, uint32) {
	input = strings.TrimSpace(input)
	levelLimit := strings.Split(input, ":")
	if 2 != len(levelLimit) {
		return 0, 0
	}
	return common.StringToUint32(levelLimit[0]), common.StringToUint32(levelLimit[1])
}

/**
@brief 初始化英雄派遣
*/
func initDispatchTask() {
	tmpArray := make(MinMaxLevelIDTripleArray, 0)
	tmpMap := make(map[string][]int64)
	refreshDispatchTaskTime = uint64(CSV.GetGameConfigValueUint32("AUTO_REFRESH_DISPATCH_TASK_TIME")) * 60
	for _, id := range CSV.Mgr.CSV_DispatchTask.GetIDList() {
		entry := CSV.Mgr.CSV_DispatchTask.GetEntryPtr(id)
		levelRequire := entry.LevelRequire
		tmpMap[entry.LevelRequire] = append(tmpMap[levelRequire], entry.ID)
		min, max := parseMinMax(levelRequire)
		tmpArray = append(tmpArray, &MinMaxLevelIDTriple{
			minLevel: min,
			maxLevel: max,
			key:      levelRequire,
		})
	}
	readonlyMinMaxLevelIDTripleArray = tmpArray
	readonlyLevelRequireToTaskIDMap = tmpMap
}

/**
@brief 获取派遣任务资产
*/
func (userData *Info) GetDispatchTaskAsset() *Asset_DispatchTask {
	return userData.info.AssetData_DispatchTask
}