package service

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"91porn-server/common"
	"91porn-server/common/constant/redisconst"
	"91porn-server/common/log"
	"91porn-server/common/redis"
	"91porn-server/common/usertruth"
	"91porn-server/models/l/registermod"
	"91porn-server/models/v/usermod"
	"91porn-server/skd/skdg"
)

const (
	RestartSignal   string = "RESTART"
	NotifyKeyPrefix string = "notify:user:new:register:"
	TrimPrefix      string = "notify:"
)

var MessageCh = make(chan *redis.Message, 100)
var ChStatus = make(chan string)

// DoRegister
func DoRegister() {
	common.Go(func() { Sub(redisconst.Db0ExpiredChannel) })
	common.Go(func() {
		for {
			select {
			case v, ok := <-MessageCh:
				if !ok {
					log.Warn("MessChan is nil waiting some second")
				}
				if v != nil {
					LoadNewRegister(v.Payload)
				}
			case v, ok := <-ChStatus:
				if !ok {
					log.Warn("Restart signal is not receive")
				}
				if v == RestartSignal {
					Sub(redisconst.Db0ExpiredChannel)
				}
			}
		}
	})
}

// 接收过期的键 将信息存入到数据库中 只处理指定的过期键  notify:user:new:register
func LoadNewRegister(expiredKey interface{}) {
	if v, ok := expiredKey.(string); ok {
		if strings.HasPrefix(v, NotifyKeyPrefix) {
			common.Go(func() {
				key := strings.TrimPrefix(v, TrimPrefix)
				uidstr := strings.TrimPrefix(v, NotifyKeyPrefix)
				uid, _ := strconv.ParseUint(uidstr, 10, 64)
				log.Info("Expired Key And Handle Data", log.Any("expiredKey", expiredKey), log.Any("needHandleKey", key), log.Any("uid", uid))
				handleRegisterData(key, uid)
			})
		}
	}
}

func handleRegisterData(key string, uid uint64) {
	fileds := skdg.Redis.Hkeys(key)
	//获取IP
	ip, _ := skdg.Redis.Hget(key, "ip")
	if len(fileds) > 0 {
		values, err := skdg.Redis.HMget(key, fileds)
		if err != nil {
			log.Warn("[Method] HandleRegisterData HMget Data from redis error", log.Any("key", key), log.E(err))
		}
		qCountMap := make(map[string]int64)
		var qsArray []registermod.QueryStat
		rgister := &registermod.NewRegisterLog{}
		for i := 0; i < len(fileds); i++ {
			if v, ok := values[i].(string); ok {
				cnt, err := strconv.ParseInt(v, 10, 64)
				if err != nil {
					continue
				}
				qCountMap[fileds[i]] = cnt
				qs := registermod.QueryStat{QueryUrl: fileds[i], Count: cnt}
				qsArray = append(qsArray, qs)
			}
		}
		_, _ = skdg.Redis.Del(key)
		rgister.CreatedAt = time.Now()
		rgister.UID = uid
		rgister.Query = qsArray
		rgister.IP = ip
		_ = registermod.InsertRegisterLog(rgister)
		score := usertruth.Score(qCountMap)
		//为区别默认值0 将计算出来的得分为0的情况 设置为-1
		if score == 0 {
			score = -1
		}
		_, _ = usermod.Update(uid, usermod.UserSelector{TrueScore: &score})
		log.Info("[Method] HandleRegisterData success", log.Any("key", key), log.Any("trueScore", score), log.Any("uid", uid))
	}
}

// 订阅
func Sub(channel string) {
	subpush, err := skdg.Redis.Subscribe(channel)
	if err != nil {
		ChStatus <- RestartSignal
		log.Warn(fmt.Sprintf("skd sever sub channel %s err", channel), log.E(err))
	}
	ch := subpush.Channel()
	for msg := range ch {
		message := &redis.Message{Channel: msg.Channel, Payload: msg.Payload}
		MessageCh <- message
	}
}