package task

import (
	"context"
	"encoding/json"
	"fmt"
	"server/internal/dao"
	"server/internal/model"
	"server/internal/model/do"
	"server/internal/service"
	"server/utility/ecode"
	"server/utility/tencent"
	"sort"
	"strconv"
	"strings"
	"time"
)

type sTask struct{}

func New() service.ITask {
	return &sTask{}
}

func init() {
	service.RegisterTask(New())
}

func (s *sTask) UserTaskRankingList(ctx context.Context, in *model.UserTaskRankingIn) (out *model.UserTaskRankingOut, err error) {

	// 判断排行类型
	var start, end time.Time
	if in.Type == 1 {
		// 日
		now := time.Now()
		// 当天开始时间
		start = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		// 当天结束时间
		end = time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, now.Location())

		fmt.Println("开始时间:", start)
		fmt.Println("结束时间:", end)

	} else if in.Type == 2 {
		// 周
		now := time.Now()
		loc := now.Location()
		weekday := int(now.Weekday())
		if weekday == 0 { // 周日是0
			weekday = 7
		}
		// 本周开始时间（周一 00:00:00）
		start = time.Date(now.Year(), now.Month(), now.Day()-weekday+1, 0, 0, 0, 0, loc)
		// 本周结束时间（周日 23:59:59）
		end = time.Date(now.Year(), now.Month(), now.Day()-weekday+7, 23, 59, 59, 0, loc)
	} else if in.Type == 3 {
		// 月
		now := time.Now()
		loc := now.Location()
		// 本月开始时间（1号 00:00:00）
		start = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, loc)
		// 下月1号
		nextMonth := start.AddDate(0, 1, 0)
		// 本月结束时间（本月最后一天 23:59:59）
		end = nextMonth.Add(-time.Second)
	} else {
		return nil, ecode.Params.Sub("排行方式错误")
	}
	m := dao.UserTasks.Ctx(ctx)

	// 构建查询条件
	if in.Page == 0 {
		in.Page = 1
	}

	if in.Size == 0 {
		in.Size = 10
	}

	if in.StoreId > 0 {
		m = m.Where(dao.UserTasks.Columns().StoreId, in.StoreId)
	}

	list := make([]model.UserTaskRankingArgs, 0)
	var total int
	// SELECT `uid`,`nickname` FROM `user` ORDER BY `uid` asc
	err = m.Page(in.Page, in.Size).LeftJoin(dao.Users.Table(), fmt.Sprintf("`%s`.`id` = `%s`.`user_id`", dao.Users.Table(), dao.UserTasks.Table())).
		Fields("username,avatar,count(*) num").Where(dao.UserTasks.Columns().Status, 3).
		WhereBetween(dao.UserTasks.Columns().CompletedAt, start, end).OrderDesc("num").OrderDesc("username").Group("user_id").
		ScanAndCount(&list, &total, false)
	if err != nil {
		return nil, ecode.Fail.Sub("查询排行榜失败")
	}

	// 判断登录查询当前任务完成数量，排名
	var rankingNum int
	var loginUserRanking []model.LoginUserRanking
	var loginUserRankingNum model.LoginUserRankingNum
	if in.OperatorId != 0 {
		err := dao.UserTasks.Ctx(ctx).Fields("count(*) num").Where(dao.UserTasks.Columns().UserId, in.OperatorId).Where(dao.UserTasks.Columns().Status, 3).
			WhereBetween(dao.UserTasks.Columns().CompletedAt, start, end).Group("user_id").
			Scan(&loginUserRankingNum)

		if err != nil {
			return nil, ecode.Fail.Sub("查询当前登录用户完成数失败")
		}

		err = dao.UserTasks.Ctx(ctx).LeftJoin(dao.Users.Table(), fmt.Sprintf("`%s`.`id` = `%s`.`user_id`", dao.Users.Table(), dao.UserTasks.Table())).
			Fields("username,count(*) num").Where(dao.UserTasks.Columns().Status, 3).
			WhereBetween(dao.UserTasks.Columns().CompletedAt, start, end).OrderDesc("num").OrderDesc("username").Group("user_id").
			Scan(&loginUserRanking)

		if err != nil {
			return nil, ecode.Fail.Sub("查询当前登录用户排名失败")
		}

		// 查找当前登录用户排名
		//index := sort.Search(len(loginUserRanking), func(i int) bool {
		//	return loginUserRanking[i].Num <= loginUserRankingNum.Num
		//})

		index, flag := sort.Find(len(loginUserRanking), func(i int) int {
			return strings.Compare(strconv.Itoa(loginUserRanking[i].Num), strconv.Itoa(loginUserRankingNum.Num))
		})

		if flag {
			rankingNum = index + 1
		}
	}

	return &model.UserTaskRankingOut{
		List:         list,
		Total:        total,
		CompletedNum: loginUserRankingNum.Num,
		RankingNum:   rankingNum,
	}, nil
}

// GetNonLoginTaskList 获取下发到指定网吧的任务列表(未登录)
func (s *sTask) GetNonLoginTaskList(ctx context.Context, in *model.GetNonLoginTaskListIn) (out *model.GetNonLoginTaskListOut, err error) {

	// TODO  调用外部接口
	// 调用外部接口
	data, err := tencent.GetNonLoginTaskList(ctx, in)
	if err != nil {
		return nil, err
	}

	var store *model.Store
	// 获取网吧账号 id用作存储task
	err = dao.Stores.Ctx(ctx).Where(dao.Stores.Columns().NetbarAccount, in.NetBarAccount).Scan(&store)
	if err != nil {
		return nil, ecode.Fail.Sub("查找网吧失败")
	}
	if store == nil {
		return nil, ecode.Fail.Sub("当前网吧不存在")
	}

	// TODO  任务列表数据处理
	if jsonData, ok := data.(map[string]interface{}); ok {
		// 现在可以访问 jsonData 中的字段
		list := jsonData["task_list"]

		// 将 interface{} 转换为结构体
		var result []model.MyData
		jsonBytes, err := json.Marshal(list)
		if err != nil {
			return nil, ecode.Fail.Sub("JSON序列化失败")
		}
		err = json.Unmarshal(jsonBytes, &result)
		if err != nil {
			return nil, ecode.Fail.Sub("JSON反序列化失败")
		}

		for _, v := range result {
			exist, err := dao.Tasks.Ctx(ctx).Where(dao.Tasks.Columns().QqNetbarTaskId, v.TaskId).Exist()
			if err != nil {
				return nil, ecode.Fail.Sub("查询该任务失败")
			}

			// 数据库是否存在，无则添加
			if !exist {
				_, err := dao.Tasks.Ctx(ctx).Insert(do.Tasks{
					QqNetbarTaskId:    v.TaskId,
					QqNetbarTaskMemo:  v.QQNetBarTaskMemo,
					QqNetbarTaskName:  v.QQNetBarTaskName,
					QqNetbarTaskRules: v.QQNetBarTaskRules,
					GameId:            in.Gid,
					StoreId:           store.Id,
				})
				if err != nil {
					return nil, ecode.Fail.Sub("添加任务失败")
				}
			}
		}
	}

	return &model.GetNonLoginTaskListOut{
		Data: data,
	}, err
}

func (s *sTask) GetLoginTaskList(ctx context.Context, in *model.GetLoginTaskListIn) (out *model.GetLoginTaskListOut, err error) {

	// TODO  调用外部接口
	// 调用外部接口
	data, err := tencent.GetLoginTaskList(ctx, in)
	if err != nil {
		return nil, err
	}

	// TODO  任务列表数据处理
	return &model.GetLoginTaskListOut{
		Data: data,
	}, err
}

func (s *sTask) GetTaskList(ctx context.Context, in *model.TaskListIn) (out *model.TaskListOut, err error) {

	var data []model.Tasks
	var total int
	m := dao.Tasks.Ctx(ctx)
	//err = m.Page(in.Page, in.Size).Where(do.Tasks{GameId: in.Gid, StoreId: in.StoreId}).LeftJoin(dao.StoreTaskRewards.Table(), fmt.Sprintf("`%s`.`id` = `%s`.`task_id`", dao.Tasks.Table(), dao.StoreTaskRewards.Table())).ScanAndCount(&data, &total, false)
	err = m.Page(in.Page, in.Size).Where(do.Tasks{GameId: in.Gid, StoreId: in.StoreId}).WithAll().ScanAndCount(&data, &total, false)

	if err != nil {
		return nil, ecode.Fail.Sub("任务列表获取失败")
	}
	return &model.TaskListOut{
		List:  data,
		Total: total,
	}, nil
}