package logic

import (
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"encoding/json"
	"errors"
	"net/http"
	"sort"
	"strconv"
	"time"
)

func (v *TaskList) Len() int {
	return len(v.Taskdata)
}

func (v *TaskList) Swap(i, j int) {
	v.Taskdata[i], v.Taskdata[j] = v.Taskdata[j], v.Taskdata[i]
}

func (v *TaskList) Less(i, j int) bool {
	return v.Taskdata[i].Taskstatus > v.Taskdata[j].Taskstatus
}


func SetHeader(w http.ResponseWriter) {
	w.Header().Set("Access-Control-Allow-Origin", "*") //允许访问所有域
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Uuid")
}

func SaveUserInfo(data *UserData) error {

	savestr,err := json.Marshal(data)
	if err != nil {
		return err
	}

	err = redishandler.GetRedisClient().HSet(redis.USER_DATA_KEY,strconv.Itoa(data.Userid),string(savestr))

	return err
}

func GetUserInfo(uuid int) (*UserData,error) {

	data,err := redishandler.GetRedisClient().HGet(redis.USER_DATA_KEY,strconv.Itoa(uuid))
	if err != nil {
		return nil,err
	}
	var tmp UserData
	err = json.Unmarshal([]byte(data),&tmp)
	if err != nil {
		return nil,err
	}

	return &tmp,nil
}

func GetUserLvConfig(lv int) *jsonconf.LevelDesc {
	for _,val := range  jsonconf.GetJsonConf().LevelConfig {
		if lv == val.Level {
			return &val
		}
	}
	return nil
}

func GetTaskConfig(taskid int) *jsonconf.AchieveDesc {
	for _,val := range jsonconf.GetJsonConf().TaskConfig {
		if val.Id == taskid {
			return &val
		}
	}
	return nil
}

func GetAchieveConfig(taskid int) *jsonconf.AchieveDesc {
	for _,val := range jsonconf.GetJsonConf().AchieventConfig {
		if val.Id == taskid {
			return &val
		}
	}
	return nil
}

func (uinfo *UserData) CalcTaskList(list *TaskList) {

	for k,val := range list.Taskdata {
		//未完成的才做判断
		if val.Taskstatus != 1 {
			continue
		}
		cfg := GetTaskConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcTaskList GetTaskConfig failed id=%v",val.Taskid)
			continue
		}


		if cfg.TaskType == DAILY_TASKTYPE_LOGIN {
			nowloginday := time.Now().Day()
			lasttime := time.Unix(int64(uinfo.LastLoginTime), 0)
			lastloginday := lasttime.Day()

			if nowloginday == lastloginday && val.Taskstatus == 1{
				list.Taskdata[k].Taskprogress = 1
				list.Taskdata[k].Taskstatus = 2
			}
		}else if cfg.TaskType == DAILY_TASKTYPE_GETGUANCNT {
			list.Taskdata[k].Taskprogress = uinfo.GetFromGuanCnt
			//当日提取存钱罐次数
			if uinfo.GetFromGuanCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		}else if cfg.TaskType == DAILY_TASKTYPE_PASSLEVEL {
			list.Taskdata[k].Taskprogress = uinfo.Task.PassLevel
			if uinfo.Task.PassLevel >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		}else if cfg.TaskType == DAILY_TASKTYPE_USEITEM {
			list.Taskdata[k].Taskprogress = uinfo.Task.UseItemCnt
			if uinfo.Task.UseItemCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_GETREDBAG {
			list.Taskdata[k].Taskprogress = uinfo.Task.GetRedbagCnt
			if uinfo.Task.GetRedbagCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		}else if cfg.TaskType == DAILY_TASKTYPE_GETGUANGOLD {
			list.Taskdata[k].Taskprogress = uinfo.Task.GetGuanGold
			if uinfo.Task.GetGuanGold >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		}else if cfg.TaskType == DAILY_TASKTYPE_ONLINEMIN {
			list.Taskdata[k].Taskprogress = uinfo.Task.OnlineMin
			if uinfo.Task.OnlineMin >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		}

	}

	//需要保存到redis
	SaveTaskInfo(uinfo.Userid,1,list)

	//排序
	sort.Sort(list)
}

func (uinfo *UserData) CalcAchieveProgress(ttype int) int {
	rtval := 0
	switch ttype {
	case ACHIEVETYPE_WATCHADDS:
		rtval = uinfo.Achieve.WatchAdsCnt
	case ACHIEVETYPE_USERLV:
		rtval = uinfo.Lv
	case ACHIEVETYPE_KILLSTAR:
		rtval = uinfo.Achieve.KillStar
	case ACHIEVETYPE_GETGUANCNT:
		rtval = uinfo.Achieve.SumGetGuan
	case ACHIEVETYPE_USEITEMCNT:
		rtval = uinfo.Achieve.SumUseItemCnt
	default:
		logger.Error("CalcAchieveProgress type wrong ttype=%v",ttype)
	}

	return rtval
}

//成就返回的是新的成就列表
func (uinfo *UserData) CalcAchieveList(list *TaskList)  *TaskList{
	newlist := new(TaskList)
	curtype := -1	//记录当前类型

	//第一遍首先将所有进度设置为正确的状态
	for k,val := range  list.Taskdata {
		cfg := GetAchieveConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcAchieveList GetTaskConfig failed id=%v",val.Taskid)
			continue
		}

		list.Taskdata[k].Taskprogress =uinfo.CalcAchieveProgress(cfg.TaskType)
		switch cfg.TaskType {
		case ACHIEVETYPE_WATCHADDS:
			if uinfo.Achieve.WatchAdsCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		case ACHIEVETYPE_USERLV:
			if uinfo.Lv >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		case ACHIEVETYPE_KILLSTAR:
			if uinfo.Achieve.KillStar >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		case ACHIEVETYPE_GETGUANCNT:
			if uinfo.Achieve.SumGetGuan >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		case ACHIEVETYPE_USEITEMCNT:
			if uinfo.Achieve.SumUseItemCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		default:
			logger.Error("CalcAchieveProgress type wrong ttype=%v",cfg.TaskType)
		}
	}


	for k,val := range list.Taskdata {

		cfg := GetAchieveConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcAchieveList GetTaskConfig failed id=%v",val.Taskid)
			continue
		}

		if val.Taskstatus == 2 {
			//未领取已完成 只需要加入第一种
			if curtype == cfg.TaskType {
				continue
			}else {
				//将类型加入返回列表
				newlist.Taskdata = append(newlist.Taskdata,list.Taskdata[k])
				curtype = cfg.TaskType
			}
		}else if val.Taskstatus == 1 {
			//未完成 返回第一个
			if curtype == cfg.TaskType {
				continue
			}else {
				//将类型加入返回列表
				newlist.Taskdata = append(newlist.Taskdata,list.Taskdata[k])
				curtype = cfg.TaskType
			}
		}else {
			//已领取  需要判断一下是否最后一项
			if k!= len(list.Taskdata)-1 {
				//不是最后一条数据
				nextcfg := GetAchieveConfig(list.Taskdata[k+1].Taskid)
				if nextcfg!=nil {
					if nextcfg.TaskType != cfg.TaskType {
						//下面一天不是此类型了
						newlist.Taskdata = append(newlist.Taskdata,list.Taskdata[k])
						curtype = cfg.TaskType
					}
				}

			} else {
				//最后一条 加入
				newlist.Taskdata = append(newlist.Taskdata,list.Taskdata[k])
				curtype = cfg.TaskType
			}
		}


	}

	//保存旧的列表
	SaveTaskInfo(uinfo.Userid,2,list)

	//将返回的列表排序
	sort.Sort(newlist)
	logger.Info("CalcAchieveList alist=%v",newlist)
	return newlist
}

func SaveTaskInfo(uuid ,tasktype int,list *TaskList) error {
	savestr,err := json.Marshal(list)
	if err != nil {
		logger.Error("SaveTaskInfo err =%v",err)
		return err
	}

	if tasktype == 1 {
		err = redishandler.GetRedisClient().HSet(redis.USER_TASKINFO_LIST,strconv.Itoa(uuid),string(savestr))
	}else if tasktype == 2 {
		err = redishandler.GetRedisClient().HSet(redis.USER_ACHIEVEMENTINFO_LIST,strconv.Itoa(uuid),string(savestr))
	}else {
		logger.Error("tasktype invalid")
		return errors.New("tasktype invalid")
	}
	return err
}

func GetTaskInfo(uuid ,tasktype int) (*TaskList,error) {
	var data string
	var err error
	if tasktype == 1 {
		data,err = redishandler.GetRedisClient().HGet(redis.USER_TASKINFO_LIST,strconv.Itoa(uuid))
	}else if tasktype == 2 {
		data,err = redishandler.GetRedisClient().HGet(redis.USER_ACHIEVEMENTINFO_LIST,strconv.Itoa(uuid))
	}else {
		logger.Error("tasktype invalid")
		return nil,errors.New("tasktype invalid")
	}

	var list TaskList
	err = json.Unmarshal([]byte(data),&list)
	if err != nil {
		logger.Error("GetTaskInfo err=%v",err)
		return nil,err
	}

	return &list,err
}

//处理领取任务
func (uinfo *UserData) HandleGetTaskReward(req *GettaskrewardReq,resp *GettaskrewardResp,list *TaskList) error {
	isfind := false
	index := -1
	var taskdesc *TaskListDesc
	for k,val := range list.Taskdata {
		if val.Taskid == req.Taskid {
			isfind = true
			index = k
			taskdesc = &val
			break
		}
	}

	if isfind && taskdesc != nil && index != -1{
		if taskdesc.Taskstatus != 2 {
			//状态不是可领取状态 无法领取
			resp.Code = ERROR_TASKCANNOTGET
			resp.Message = "当前任务未完成或已领取"
			return errors.New("当前任务未完成或已领取")
		}

		//状态对的情况 如果是成就下需要判断前置条件是否被
		if req.Tasktype == 2 && index > 0 {
			if list.Taskdata[index-1].Taskstatus != 0 {
				resp.Code = ERROR_TASKPRE_NOTGET
				resp.Message = "前置任务还未领取"
				return errors.New("当前任务未完成或已领取")
			}
		}
	}else {
		resp.Code = ERROR_TASKID_WRONG
		resp.Message = "当前任务id错误"
		return errors.New("当前任务id错误")
	}

	cfg := GetTaskConfig(taskdesc.Taskid)
	if cfg == nil || len (cfg.Reward) < 2{
		resp.Code = ERROR_SRV_ERROR
		resp.Message = "网络错误"
		return errors.New("获取配置失败")
	}

	//将状态置位已领取
	list.Taskdata[index].Taskstatus = 0
	//发奖励
	sub := len(cfg.Reward) / 2
	for i:=0;i<sub;i++ {
		rtype := cfg.Reward[i*2]
		rnum := cfg.Reward[i*2+1]
		r1,r2,r3,r4,r5,r6 :=uinfo.RewardUser(rtype,rnum,req.Gameid,req.Channel)
		if resp.Data.Lv != r1 {
			resp.Data.Lv = r1
		}
		resp.Data.Rewardstar += r2
		resp.Data.Chuiitem += r3
		resp.Data.Shuaitem += r4
		resp.Data.Swapitem += r5
		resp.Data.Eliminitem += r6

	}

	return nil
}

func (uinfo *UserData) RewardUser(rtype int,num int,gameid string,channel string) (int,int,int,int,int,int){
	switch rtype {
	case REWARDTYPE_STAR:
		return 0,num,0,0,0,0
	case REWARDTYPE_CHUI:
		return 0,0,num,0,0,0
	case REWARDTYPE_SHUA:
		return 0,0,0,num,0,0
	case REWARDTYPE_SWAP:
		return 0,0,0,0,num,0
	case REWARDTYPE_ELIMITE:
		return 0,0,0,0,0,num
	case REWARDTYPE_EXP:
		isup := uinfo.AddUserExp(num)
		if isup {
			return uinfo.Lv,0,0,0,0,0
		}else {
			return 0,0,0,0,0,0
		}
	case REWARDTYPE_GOLD:
		_,err :=AddCoinToSdk(uinfo.Userid,num,gameid,channel,100)
		if err != nil {
			logger.Error("RewardUser failer err=%v",err)
		}
		//uinfo.RealGold =
		uinfo.RealGold += num
	default:
		return 0, 0, 0, 0, 0, 0
	}
	return 0, 0, 0, 0, 0, 0
}

func InitUserInfo(data *UserLoginReq, resp *UserLoginResp, uuid int) error{

	var initdata UserData
	initdata.Lv = 1
	initdata.LvRewardGet = 1
	initdata.Exp = 0
	initdata.Userid = uuid
	initdata.ContinueLoginDay = 1
	initdata.GetFromGuanCnt = 0
	initdata.GuanGold = 0
	initdata.LastLoginTime = int(time.Now().Unix())
	initdata.RealGold = 0
	initdata.WatchAddsTime =WATCH_ADD_DAY_LIMIT

	for _,val := range jsonconf.GetJsonConf().WithDrawConfig {
		var tmp WithDrawDesc
		tmp.Cid = val.Id
		tmp.Cnum = val.Money
		if val.Isnew == 1 {
			tmp.Isnew = 1
		}else {
			tmp.Isnew = 2
		}
		tmp.Limitlv = val.Level
		if val.Id == 1 {
			tmp.Preisfind = 1
		}else {
			tmp.Preisfind = 0
		}
		initdata.WithDraw.Cashdata = append(initdata.WithDraw.Cashdata,tmp)
	}

	resp.Data.Guangold = initdata.GuanGold
	resp.Data.Leftads = initdata.WatchAddsTime
	resp.Data.Walletgold = initdata.RealGold

	err := SaveUserInfo(&initdata)
	if err != nil {
		logger.Error("InitUserInfo err=%v",err)
		return err
	}

	//初始化一下玩家的任务与成就数据数据
	err = InitTaskAndAchievement(uuid)

	return err
}

func InitTaskAndAchievement(uuid int) error{
	//先初始化任务
	tasklist := new(TaskList)
	for _,val := range jsonconf.GetJsonConf().TaskConfig {
		var tmp TaskListDesc
		tmp.Taskstatus = 1
		tmp.Taskid = val.Id
		tmp.Taskprogress = 0
		tasklist.Taskdata = append(tasklist.Taskdata,tmp)
	}

	err := SaveTaskInfo(uuid,1,tasklist)
	if err != nil {
		logger.Error("InitTaskAndAchievement err=%v",err)
		return err
	}

	achievelist := new(TaskList)
	for _,val := range jsonconf.GetJsonConf().AchieventConfig {
		var tmp TaskListDesc
		tmp.Taskstatus = 1
		tmp.Taskid = val.Id
		tmp.Taskprogress = 0
		achievelist.Taskdata = append(achievelist.Taskdata,tmp)
	}

	err = SaveTaskInfo(uuid,2,achievelist)
	if err != nil {
		logger.Error("InitTaskAndAchievement err=%v",err)
		return err
	}

	return nil
}

//计算当日可提取次数
func (u *UserData) CalcTotalCnt() int {
	maxtime := 0
	usertime := 0
	for _,val := range jsonconf.GetJsonConf().MoneyBoxTimeConfig {
		if maxtime < val.Times {
			maxtime = val.Times
		}
		if val.Login == u.ContinueLoginDay {
			usertime = val.Times
		}
	}

	if usertime == 0 {
		usertime = maxtime
	}
	return usertime
}

func (u *UserData) HandlePassDay() {
	isdiffday := false
	nowtime := time.Now()
	lasttime := time.Unix(int64(u.LastLoginTime), 0)
	nowdaynum := time.Now().Day()
	lastdaynum := time.Unix(int64(u.LastLoginTime), 0).Day()
	nowtimestamp := time.Date(nowtime.Year(), nowtime.Month(), nowtime.Day(), 0, 0, 0, 0, nowtime.Location())
	lasttimestamp := time.Date(lasttime.Year(), lasttime.Month(), lasttime.Day(), 0, 0, 0, 0, lasttime.Location())


	if nowdaynum == lastdaynum {
		//同一天
		if int64(u.LastLoginTime) - time.Now().Unix() > 86400 {
			//已经过了很多天了
			//u.LastLoginTime = int(time.Now().Unix())
			u.ContinueLoginDay = 1
			isdiffday = true
		}else {
			//t同一天 不做处理
		}
	}else {
		//不是同一天了
		isdiffday = true
		if nowtimestamp.Unix() > lasttimestamp.Unix() + 86399 {
			//超过一天了
			u.ContinueLoginDay = 1
		}else {
			u.ContinueLoginDay ++
		}
	}

	if isdiffday {
		//跨天了
		u.WatchAddsTime = WATCH_ADD_DAY_LIMIT
		//todo 重置任务相关的数据
		u.GetFromGuanCnt = 0

		u.Task.GetGuanGold = 0
		u.Task.GetRedbagCnt = 0
		u.Task.OnlineMin = 0
		u.Task.PassLevel = 0
		u.Task.UseItemCnt = 0
	}

	u.LastLoginTime = int(nowtime.Unix())

	SaveUserInfo(u)
}

func GetUserData(uuid int, req *UserLoginReq,resp *UserLoginResp) error{
	data,err := GetUserInfo(uuid)
	if err != nil || data == nil{
		resp.Code = ERROR_SRV_ERROR
		resp.Message = "ERROR_SRV_ERROR"
		return err
	}

	//此处要处理一下跨天逻辑
	data.HandlePassDay()

	//此处处理一下从sdk拉取钱包金币数量
	gold,err := GetCoinFromSdk(uuid,req.Gameid,req.Channel)
	if err != nil {
		data.RealGold = gold
	}

	SaveUserInfo(data)

	resp.Data.Walletgold = data.RealGold
	resp.Data.Leftads = data.WatchAddsTime
	resp.Data.Guangold = data.GuanGold
	resp.Data.Userlv = data.Lv
	resp.Data.Userexp = data.Exp

	return nil
}

//获取提现记录
func GetWithDrawList(uuid int) (*WithDrawList,error) {
	var list *WithDrawList
	list = new(WithDrawList)
	liststr,err := redishandler.GetRedisClient().HGet(redis.USER_WITHDRAW_RECORDLIST,strconv.Itoa(uuid))
	if err != nil {
		return nil,err
	}
	err = json.Unmarshal([]byte(liststr),list)
	if err != nil {
		return nil,err
	}
	return list,nil
}

func (uinfo *UserData)GetWithDrawData(money float32) (int,*WithDrawDesc){
	//处理提现状态
	for k,val := range uinfo.WithDraw.Cashdata {
		if val.Cnum == money{
			return k,&val
		}
	}
	return -1,nil
}

//添加提现记录
func AddWithDrawList(uuid int,data *WithDrawRecord) error {
	exist,err := redishandler.GetRedisClient().HExists(redis.USER_WITHDRAW_RECORDLIST,strconv.Itoa(uuid))
	if err != nil {
		return err
	}
	if !exist {
		//添加新的记录
		var tmp WithDrawList
		tmp.Withdata = append(tmp.Withdata,*data)

		savestr,err := json.Marshal(&tmp)
		if err != nil {
			return err
		}
		err =  redishandler.GetRedisClient().HSet(redis.USER_WITHDRAW_RECORDLIST,strconv.Itoa(uuid),string(savestr))
		return err
	}

	/*liststr,err := redishandler.GetRedisClient().HGet(redis.USER_WITHDRAW_RECORDLIST,strconv.Itoa(uuid))
	if err != nil {
		return err
	}

	var list WithDrawList
	err = json.Unmarshal([]byte(liststr),&list)
	if err != nil {
		return err
	}*/

	list,err := GetWithDrawList(uuid)
	if err != nil || list == nil{
		logger.Error("AddWithDrawList err=%v",err)
		return err
	}
	list.Withdata = append(list.Withdata,*data)
	savestr,err := json.Marshal(list)
	if err != nil {
		return err
	}
	err =  redishandler.GetRedisClient().HSet(redis.USER_WITHDRAW_RECORDLIST,strconv.Itoa(uuid),string(savestr))
	return err



}

//返回是否升级
func (uinfo* UserData) AddUserExp(num int) bool {
	totalexp := num
	isup := false
	for {
		lvcfg := GetUserLvConfig(uinfo.Lv)
		if lvcfg == nil {
			logger.Error("AddUserExp fail lv=%v",uinfo.Lv)
			break
		}
		//判断下是否满级了
		nexcfg := GetUserLvConfig(uinfo.Lv+1)
		if nexcfg == nil {
			//已经满级了
			uinfo.Exp += totalexp
			break
		}

		//计算一下当前升级需要剩下的

		needexp := lvcfg.Exp - uinfo.Exp
		if totalexp < needexp {
			//不够升级的
			uinfo.Exp += totalexp
			break
		}else {
			//够升级的 升一级
			uinfo.Lv ++
			uinfo.LvRewardGet = 1		//当前等级奖励置位可以领取
			isup = true
			totalexp -= needexp
			uinfo.Exp = 0
			continue
		}
	}

	return isup
}

func GetCoinFromSdk(uuid int,gameid string,channel string) (int,error) {
	return 0,nil
}

func AddCoinToSdk(uuid int,goldnum int,gameid string,channel string,atype int) (int,error) {
	//暂时先不对接 接口调通遗憾对接后台
	return 0,nil
}

func GetCashFromSDK(uuid int,goldnum int,gameid ,channel,openid,nickname,headurl string) (int,error) {
	//先不接
	return 0,nil
}