package service

import (
	"context"
	"encoding/json"
	"fmt"
	"hash/crc32"
	"time"

	"go-common/app/job/main/creative/model"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/queue/databus"
)

//commitTask for commit task
func (s *Service) commitTask() {
	for i := 0; i < s.c.Task.TableJobNum; i++ {
		go func(i int) {
			s.dispatchData(fmt.Sprintf("%02d", i))
		}(i)
	}
}

//shardingQueueIndex sharding queue index
func (s *Service) shardingQueueIndex(name string, ql int) (i int) { ////注：使用校验和取模的原因是：使得获取的消息均匀散入不同的worker队列中
	ch := crc32.ChecksumIEEE([]byte(name))
	i = int(ch) % ql
	return
}

func (s *Service) dispatchData(index string) { //index 分表后缀名
	var id int64
	limit := s.c.Task.RowLimit
	for {
		res, err := s.newc.UserTasks(context.Background(), index, id, limit)
		if err != nil {
			log.Error("s.newc.UserTasks table index(%s)|id(%d)|limit(%d)|err(%v)", index, id, limit, err)
			return
		}
		if len(res) == 0 {
			time.Sleep(600 * time.Second)
			id = 0 //reset id
			continue
		}
		id = res[len(res)-1].ID
		tks := make([]*model.UserTask, 0, len(res))
		for _, v := range res {
			target, ok := s.TaskMapCache[v.TaskID]
			if !ok || target == nil {
				continue
			}
			//过滤 非T+1的任务
			if target.TargetType != model.TargetType004 &&
				target.TargetType != model.TargetType005 &&
				target.TargetType != model.TargetType006 &&
				target.TargetType != model.TargetType007 &&
				target.TargetType != model.TargetType008 &&
				target.TargetType != model.TargetType009 {
				continue
			}
			tks = append(tks, v)
		}
		if len(tks) > 0 {
			s.taskQueue[s.shardingQueueIndex(index, s.c.Task.TableConsumeNum)] <- tks
		}
		time.Sleep(5 * time.Second)
	}
}

func (s *Service) initTaskQueue() {
	for i := 0; i < s.c.Task.TableConsumeNum; i++ {
		ut := make(chan []*model.UserTask, s.chanSize)
		s.taskQueue[i] = ut
		go func(ch chan []*model.UserTask) {
			s.updateTaskStateByGRPC(ch)
		}(ut)
	}
}

//updateTaskStateByGRPC for check task by call grpc.
func (s *Service) updateTaskStateByGRPC(c chan []*model.UserTask) {
	for msg := range c {
		for _, v := range msg {
			mid, tid := v.MID, v.TaskID
			reply, err := s.newc.CheckTaskState(context.Background(), mid, tid)
			if err != nil {
				if ec := ecode.Cause(err); ec.Code() == ecode.ServiceUnavailable.Code() {
					log.Error("s.newc.CheckTaskState mid(%d)|task id(%d)|err(%v)", mid, tid, err)
					return
				}
				log.Warn("s.newc.CheckTaskState mid(%d)|task id(%d)|err(%v)", mid, tid, err)
				continue
			}

			log.Info("updateTaskStateByGRPC mid(%d)|task id(%d)", mid, tid)
			if reply != nil && reply.FinishState {
				_, err := s.newc.UpUserTask(context.Background(), mid, tid)
				if err != nil {
					log.Error("DriveStateByUser s.newc.UpUserTask mid(%d)|task id(%d)|err(%v)", mid, tid, err)
					return
				}
			}

			time.Sleep(50 * time.Millisecond)
		}
	}
}

func (s *Service) initStatViewQueue() {
	for i := 0; i < s.statViewQueueLen; i++ {
		view := make(chan *model.StatView, s.chanSize)
		s.statViewSubQueue[i] = view
		go func(m chan *model.StatView) { //播放
			for v := range m {
				log.Info("StatView v(%+v)|指标：该UID下任意avid的获得-点击量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType015, v.Count)
				time.Sleep(time.Millisecond * 10)
			}
		}(view)
	}
}

func (s *Service) initStatLikeQueue() {
	for i := 0; i < s.statLikeQueueLen; i++ {
		li := make(chan *model.StatLike, s.chanSize)
		s.statLikeSubQueue[i] = li
		go func(m chan *model.StatLike) { //点赞
			for v := range m {
				log.Info("StatLike v(%+v)|指标：该UID下任意avid的获得-点赞量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType020, v.Count)
				time.Sleep(time.Millisecond * 10)
			}
		}(li)
	}
}

func (s *Service) initDatabusQueue() {
	for i := 0; i < s.databusQueueLen; i++ {
		tk := make(chan *databus.Message, s.chanSize)
		sh := make(chan *model.ShareMsg, s.chanSize)
		fl := make(chan *model.Stat, s.chanSize)       //粉丝数
		rela := make(chan *model.Relation, s.chanSize) //关注
		np := make(chan *model.Up, s.chanSize)         //最新投稿
		op := make(chan *model.Up, s.chanSize)         //最新投稿
		mp := make(chan *model.Up, s.chanSize)         //手机投稿

		//单个稿件计数
		stsh := make(chan *model.StatShare, s.chanSize)
		coin := make(chan *model.StatCoin, s.chanSize)
		fav := make(chan *model.StatFav, s.chanSize)
		rep := make(chan *model.StatReply, s.chanSize)
		dm := make(chan *model.StatDM, s.chanSize)

		s.taskSubQueue[i] = tk
		s.shareSubQueue[i] = sh
		s.followerQueue[i] = fl   //粉丝
		s.relationQueue[i] = rela //关注
		s.newUpQueue[i] = np      //新投稿
		s.oldUpQueue[i] = op      //投下5个稿
		s.mobileUpQueue[i] = mp   //手机投稿

		//单个稿件计数
		s.statShareSubQueue[i] = stsh
		s.statCoinSubQueue[i] = coin
		s.statFavSubQueue[i] = fav
		s.statReplySubQueue[i] = rep
		s.statDMSubQueue[i] = dm

		//水印设置、观看创作学院视频、参加激励计划
		go func(m chan *databus.Message) {
			s.startByTask(m)
		}(tk)
		//分享自己的稿件
		go func(m chan *model.ShareMsg) {
			for v := range m {
				log.Info("startByShare mid(%d)|v(%+v)|指标：该UID分享自己视频的次数≥1", v.MID, v)
				s.completeUserTask(v.MID, v.OID, model.TargetType002, 1)
				time.Sleep(time.Millisecond * 10)
			}
		}(sh)

		//关注哔哩哔哩创作中心和粉丝数判断
		go func(m chan *model.Stat) {
			for v := range m {
				log.Info("followerStat mid(%d)|v(%+v)|指标：该UID的粉丝数≥10 或者 1000", v.MID, v)
				s.completeUserTask(v.MID, 0, model.TargetType010, v.Follower) //新手任务粉丝数
				s.completeUserTask(v.MID, 0, model.TargetType022, v.Follower) //进阶任务粉丝数
			}
		}(fl)
		go func(m chan *model.Relation) {
			for v := range m {
				log.Info("relationMID mid(%d)|v(%+v)|指标：该UID的关注列表含有“哔哩哔哩创作中心", v.MID, v)
				s.completeUserTask(v.MID, 0, model.TargetType012, 1)
			}
		}(rela)

		// 该UID下开放浏览的稿件≥1
		go func(m chan *model.Up) {
			for v := range m {
				log.Info("newUP mid(%d)|v(%+v)|指标：该UID下开放浏览的稿件≥1", v.MID, v)
				s.completeUserTask(v.MID, v.AID, model.TargetType001, 1)
			}
		}(np)

		// 该UID下开放浏览的稿件≥5
		go func(m chan *model.Up) {
			for v := range m {
				log.Info("oldUP mid(%d)|v(%+v)|指标：该UID下开放浏览的稿件≥5", v.MID, v)
				s.completeUserTask(v.MID, v.AID, model.TargetType014, 1)
			}
		}(op)

		//单个稿件计数
		go func(m chan *model.StatReply) {
			for v := range m {
				log.Info("StatReply v(%+v)|指标：该UID下任意avid的获得-评论量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType016, v.Count)
				time.Sleep(time.Millisecond * 10)
			}
		}(rep)

		go func(m chan *model.StatShare) {
			for v := range m {
				log.Info("StatShare v(%+v)|指标：该UID下任意avid的获得-分享量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType017, v.Count)
				time.Sleep(time.Millisecond * 10)
			}
		}(stsh)

		go func(m chan *model.StatFav) {
			for v := range m {
				log.Info("StatFav v(%+v)|指标：该UID下任意avid的获得-收藏量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType018, v.Count)
				time.Sleep(time.Millisecond * 10)
			}

		}(fav)

		go func(m chan *model.StatCoin) {
			for v := range m {
				log.Info("StatCoin v(%+v)|指标：该UID下任意avid的获得-硬币量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType019, v.Count)
				time.Sleep(time.Millisecond * 10)
			}
		}(coin)

		go func(m chan *model.StatDM) {
			for v := range m {
				log.Info("StatDM v(%+v)|指标：该UID下任意avid的获得-弹幕量(%d)", v, v.Count)
				s.completeUserTask(s.getMIDByAID(v.ID), v.ID, model.TargetType021, v.Count)
				time.Sleep(time.Millisecond * 10)
			}
		}(dm)

		go func(m chan *model.Up) {
			for v := range m {
				log.Info("Mobile mid(%d)|v(%+v)|指标：该UID通过手机投稿的稿件≥1", v.MID, v)
				s.completeUserTask(v.MID, v.AID, model.TargetType013, 1)
				time.Sleep(time.Millisecond * 10)
			}
		}(mp)
	}
}

func (s *Service) startByTask(c chan *databus.Message) {
	for msg := range c {
		v := &model.TaskMsg{}
		if err := json.Unmarshal(msg.Value, v); err != nil {
			log.Error("startByTask json.Unmarshal(%v) error(%v)", string(msg.Value), err)
			continue
		}

		switch v.From {
		case model.MsgForWaterMark:
			log.Info("startByTask WaterMark mid(%d)|v(%+v)|指标：任务完成期间该UID的水印开关为打开状态", v.MID, v)
			s.completeUserTask(v.MID, 0, model.TargetType011, v.Count)

		case model.MsgForAcademyFavVideo:
			log.Info("startByTask AcademyFavVideo mid(%d)|v(%+v)|指标：该UID在创作学院的观看记录≥1", v.MID, v)
			s.completeUserTask(v.MID, 0, model.TargetType003, v.Count)

		case model.MsgForGrowAccount:
			log.Info("startByTask GrowAccount mid(%d)|v(%+v)|指标：该UID的激励计划状态为已开通", v.MID, v)
			s.completeUserTask(v.MID, 0, model.TargetType023, v.Count)

		case model.MsgForOpenFansMedal:
			log.Info("startByTask OpenFansMedal mid(%d)|v(%+v)|指标：该UID粉丝勋章为开启状态", v.MID, v)
			s.completeUserTask(v.MID, 0, model.TargetType024, v.Count)
		}
		time.Sleep(time.Millisecond * 10)
	}
}

func (s *Service) getMIDByAID(aid int64) (mid int64) {
	arc, err := s.arc.Archive(context.Background(), aid)
	if err != nil || arc == nil {
		log.Error("getMIDByAID s.arc.Archive aid(%d)|err(%v)", aid, err)
		return
	}
	mid = arc.Author.Mid
	return
}

func (s *Service) getTaskIDByTargetType(mid int64, ty int8) (tid int64) {
	userTasks, err := s.newc.UserTasksByMIDAndState(context.Background(), mid, model.TaskIncomplete)
	if err != nil {
		log.Error("s.newc.UserTasksByMIDAndState mid(%d)|err(%v)", mid, err)
		return
	}
	if len(userTasks) == 0 {
		return
	}

	for _, v := range userTasks {
		t, ok := s.TaskMapCache[v.TaskID]
		if ok && t.TargetType == ty {
			tid = v.TaskID
			break
		}
	}
	return
}

// completeUserTask update user task to complete
func (s *Service) completeUserTask(mid, aid int64, ty int8, count int64) {
	tid := s.getTaskIDByTargetType(mid, ty)
	if tid == 0 {
		return
	}
	target, ok := s.TaskMapCache[tid]
	if !ok || target == nil {
		return
	}

	if count >= target.TargetValue {
		if _, err := s.newc.UpUserTask(context.Background(), mid, tid); err != nil {
			log.Error("s.newc.UpUserTask mid(%d)|tid(%d)|err(%v)", mid, tid, err)
			return
		}
		log.Info("completeUserTask mid(%d)|aid(%d)|count(%d)|taskID(%d)|targetType(%d)|targetValue(%d)", mid, aid, count, tid, ty, target.TargetValue)
	}
}

// 对第30天未完成新手任务的UP主，发送消息通知；记录时间点为用户加入任务成就的时间;该消息有且仅发送一次。
func (s *Service) expireTaskNotify() {
	for i := 0; i < s.c.Task.TaskTableJobNum; i++ {
		go func(i int) {
			s.dispatchTasksNotify(fmt.Sprintf("%02d", i))
		}(i)
	}
}

func (s *Service) dispatchTasksNotify(index string) {
	var id int64
	ext := s.c.Task.TaskExpireTime
	th := s.c.Task.TaskSendHour
	tm := s.c.Task.TaskSendMiniute
	ts := s.c.Task.TaskSendSecond

	limit := s.c.Task.TaskRowLimitNum
	batchSize := s.c.Task.TaskBatchMidNum //每次发送mid数量
	for {
		now := time.Now()
		if now.Hour() != th || now.Minute() != tm || now.Second() != ts {
			// log.Info("dispatchTasksNotify minuts(%d) second(%d)", now.Minute(), now.Second())
			time.Sleep(1 * time.Second)
			continue
		}
		ctime := now.Unix() - ext //检查任务是否超过30天未完成
		year, month, day := time.Unix(ctime, 0).Date()
		start := time.Date(year, month, day, 0, 0, 0, 0, time.Local).Format("2006-01-02 15:04:05")
		end := time.Date(year, month, day, 23, 59, 59, 999, time.Local).Format("2006-01-02 15:04:05")
		log.Info("dispatchTasksNotify now(%s)|start(%s)|end(%s)", now.Format("2006-01-02 15:04:05"), start, end)

		midMap := make(map[int64]*model.UserTask)
		for {
			res, err := s.newc.UserTasksNotify(context.Background(), index, id, start, end, limit)
			if err != nil {
				log.Error("s.newc.UserTasksNotify table index(%s)|start(%s)|end(%s)|limit(%d)|err(%v)", index, start, end, limit, err)
				return
			}

			if len(res) == 0 {
				id = 0
				break
			}

			for _, v := range res {
				midMap[v.MID] = v
			}

			id = res[len(res)-1].ID //next limit
			time.Sleep(1 * time.Second)
		}

		if len(midMap) == 0 {
			continue
		}
		mids := make([]int64, 0, len(midMap))
		for mid := range midMap {
			mids = append(mids, mid)
		}

		var tmids []int64
		count := len(mids)/batchSize + 1
		for i := 0; i < count; i++ {
			if i == count-1 {
				tmids = mids[i*batchSize:]
			} else {
				tmids = mids[i*batchSize : (i+1)*batchSize]
			}
			if len(tmids) > 0 {
				s.taskNotifyQueue[s.shardingQueueIndex(index, s.c.Task.TaskTableConsumeNum)] <- tmids
			}
		}
	}
}

func (s *Service) initTaskNotifyQueue() {
	for i := 0; i < s.c.Task.TaskTableConsumeNum; i++ {
		ut := make(chan []int64, s.chanSize)
		s.taskNotifyQueue[i] = ut
		go func(ch chan []int64) {
			s.sendTaskNotify(ch)
		}(ut)
	}
}

func (s *Service) sendTaskNotify(c chan []int64) {
	for mids := range c {
		if len(mids) == 0 {
			time.Sleep(time.Second * 60)
			continue
		}

		for i := 1; i < 3; i++ {
			if err := s.newc.SendNotify(context.Background(), mids, s.c.Task.TaskMsgCode, s.c.Task.TaskTitle, s.c.Task.TaskContent); err != nil {
				log.Error("sendTaskNotify s.newc.SendNotify(%v) error(%v)", mids, err)
				time.Sleep(time.Millisecond * 10)
				continue
			} else {
				log.Info("sendTaskNotify s.newc.SendNotify mids(%+v)", mids)
				break
			}
		}
		time.Sleep(time.Millisecond * 10)
	}
}

// loadproc
func (s *Service) loadProc() {
	for {
		time.Sleep(3 * time.Minute)
		s.loadTasks()
		s.loadGiftRewards()
	}
}

//load tags
func (s *Service) loadTasks() {
	res, err := s.newc.Tasks(context.Background())
	if err != nil {
		log.Error("s.newc.Tasks error(%v)", err)
		return
	}
	if len(res) == 0 {
		return
	}
	s.TaskCache = res
	temp := make(map[int64]*model.Task)
	for _, v := range s.TaskCache {
		temp[v.ID] = v
	}
	s.TaskMapCache = temp
}

//load gift-reward
func (s *Service) loadGiftRewards() {
	res, err := s.newc.AllGiftRewards(context.Background())
	if err != nil {
		log.Error("s.newc.AllGiftRewards error(%v)", err)
		return
	}
	if len(res) == 0 {
		return
	}
	s.GiftRewardCache = res
}

// 检查用户是否有奖励可领取
func (s *Service) checkRewardReceive(c context.Context, mid int64) (is bool) {
	tasks, err := s.newc.UserTasksByMID(c, mid)
	if err != nil {
		log.Error("s.newc.UserTasksByMID mid(%v)|error(%v)", mid, err)
		return
	}
	groupMap := make(map[int64][]*model.UserTask)
	giftMap := make(map[int8][]*model.UserTask)
	for _, v := range tasks {
		groupMap[v.TaskGroupID] = append(groupMap[v.TaskGroupID], v)
		if _, ok := s.GiftRewardCache[v.TaskType]; ok {
			giftMap[v.TaskType] = append(giftMap[v.TaskType], v)
		}
	}

	groupNum := 0                  // 组奖励 已完成个数
	giftNum := make(map[int8]bool) // 礼包奖励 已完成个数
	for _, ts := range groupMap {
		for _, t := range ts {
			if t.State == model.TaskIncomplete {
				groupNum++
				if _, ok := s.GiftRewardCache[t.TaskType]; ok {
					giftNum[t.TaskType] = true
				}
				break
			}
		}
	}

	r1, err := s.newc.BaseRewardCount(c, mid) // 组奖励 已领取个数
	if err != nil {
		log.Error("s.newc.BaseRewardCount mid(%v)|error(%v)", mid, err)
		return
	}
	r2, err := s.newc.GiftRewardCount(c, mid) // 礼包奖励 已领取个数
	if err != nil {
		log.Error("s.newc.GiftRewardCount mid(%v)|error(%v)", mid, err)
		return
	}

	total := len(groupMap) + len(giftMap) //奖励总数
	untotal := groupNum + len(giftNum)    //未完成的奖励
	receive := r1 + r2                    //已领取奖励

	// 可领取的奖励 = 奖励总数 -未完成的奖励 - 已领取奖励
	count := total - untotal - receive

	log.Info("checkRewardReceive mid(%d)|奖励总数(%d)|未完成奖励总数(%d)|已领取奖励总数(%d)|可领取奖励总数(%d)", mid, total, untotal, receive, count)
	if count > 0 {
		is = true
	}
	return
}

// 该消息每周最多发送 1 条，发送时间为每周六的20:00，用户为上周周六18:00 - 本周周六17:59所有达到领取奖励且 未领取 的用户。
// 通知仅限用户有未领取的奖励时发送：若在该时间段，用户已领取全部可领取的奖励，
// 则不发送通知，如果用户已领取部分可领取的奖励，仍有部分奖励未领取，则仍然发送通知
func (s *Service) rewardReceiveNotify() {
	for i := 0; i < s.c.Task.RewardTableJobNum; i++ {
		go func(i int) {
			s.dispatchRewardNotify(fmt.Sprintf("%02d", i))
		}(i)
	}
}

func (s *Service) dispatchRewardNotify(index string) {
	var id int64
	week := s.c.Task.RewardWeek      //星期几
	ld := s.c.Task.RewardLastDay     //从过去多少天开始查询
	lh := s.c.Task.RewardLastHour    //几点开始查询
	lm := s.c.Task.RewardLastMiniute //几分开始查询
	ls := s.c.Task.RewardLastSecond  //几秒开始查询

	nh := s.c.Task.RewardNowHour    //从当前时间几点开始
	nm := s.c.Task.RewardNowMiniute //从当前时间几分开始
	ns := s.c.Task.RewardNowSecond  //从当前时间几秒开始

	limit := s.c.Task.RewardRowLimitNum
	batchSize := s.c.Task.RewardBatchMidNum //每次发送mid数量
	for {
		now := time.Now()
		if int(now.Weekday()) != week || now.Hour() != nh || now.Minute() != nm || now.Second() != ns {
			// log.Info("dispatchRewardNotify Weekday(%d) Hour(%d) Minute(%d) Second(%d)", now.Weekday(), now.Hour(), now.Minute(), now.Second())
			time.Sleep(1 * time.Second)
			continue
		}

		last := now.AddDate(0, 0, ld).Add(time.Hour * time.Duration(lh)).Add(time.Minute * time.Duration(lm)).Add(time.Second * time.Duration(ls))
		log.Info("dispatchRewardNotify last(%s) now(%s)\n", last.Format("2006-01-02 15:04:05"), now.Format("2006-01-02 15:04:05"))
		midMap := make(map[int64]*model.UserTask)
		for {
			res, err := s.newc.CheckTasksForRewardNotify(context.Background(), index, id, last, now, limit)
			if err != nil {
				log.Error("s.newc.CheckTasksForRewardNotify table index(%s)|id(%d)|limit(%d)|err(%v)", index, id, limit, err)
				return
			}

			if len(res) == 0 {
				id = 0
				break
			}
			for _, v := range res {
				midMap[v.MID] = v
			}

			id = res[len(res)-1].ID //next limit
			time.Sleep(1 * time.Second)
		}

		if len(midMap) == 0 {
			continue
		}
		mids := make([]int64, 0, len(midMap))
		for mid := range midMap {
			if s.checkRewardReceive(context.Background(), mid) {
				mids = append(mids, mid)
			}
		}

		var tmids []int64
		count := len(mids)/batchSize + 1
		for i := 0; i < count; i++ {
			if i == count-1 {
				tmids = mids[i*batchSize:]
			} else {
				tmids = mids[i*batchSize : (i+1)*batchSize]
			}
			if len(tmids) > 0 {
				s.rewardNotifyQueue[s.shardingQueueIndex(index, s.c.Task.RewardTableConsumeNum)] <- tmids
			}
		}
	}
}

func (s *Service) initRewardNotifyQueue() {
	for i := 0; i < s.c.Task.RewardTableConsumeNum; i++ {
		ut := make(chan []int64, s.chanSize)
		s.rewardNotifyQueue[i] = ut
		go func(ch chan []int64) {
			s.sendRewardNotify(ch)
		}(ut)
	}
}

func (s *Service) sendRewardNotify(c chan []int64) {
	for mids := range c {
		if len(mids) == 0 {
			time.Sleep(time.Second * 1)
			continue
		}

		for i := 1; i < 3; i++ {
			if err := s.newc.SendNotify(context.Background(), mids, s.c.Task.RewardMsgCode, s.c.Task.RewardTitle, s.c.Task.RewardContent); err != nil {
				log.Error("sendRewardNotify s.newc.SendNotify mids(%+v) error(%v)", mids, err)
				time.Sleep(time.Millisecond * 100)
				continue
			} else {
				log.Info("sendRewardNotify s.newc.SendNotify mids(%+v)", mids)
				break
			}
		}
		time.Sleep(time.Millisecond * 10)
	}
}