package service

import (
	"context"
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"time"

	creditMDL "go-common/app/admin/main/credit/model"
	"go-common/app/admin/main/credit/model/blocked"
	account "go-common/app/service/main/account/api"
	relationmdl "go-common/app/service/main/relation/model"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/net/metadata"
	"go-common/library/sync/errgroup"
	xtime "go-common/library/time"
	"go-common/library/xstr"
)

// AddJury add jury to admin
func (s *Service) AddJury(c context.Context, arg *blocked.ArgAddJurys) (err error) {
	arg.MIDs = creditMDL.ArrayUnique(arg.MIDs)
	if len(arg.MIDs) == 0 {
		return
	}
	items := []*blocked.Jury{}
	if err = s.blockedDao.ReadDB.Where("mid IN (?)", arg.MIDs).Find(&items).Error; err != nil {
		log.Error("s.blockedDao.juryByMIDs(%s) error(%v)", xstr.JoinInts(arg.MIDs), err)
		err = nil
	}
	mids := make(map[int64]*blocked.Jury, len(arg.MIDs))
	for _, v := range items {
		mids[v.UID] = v
	}
	day, _ := time.ParseDuration("24h")
	users := make([]*blocked.Jury, 0, len(arg.MIDs))
	tx := s.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	now := time.Now()
	var multiple []interface{}
	for _, mid := range arg.MIDs {
		user := &blocked.Jury{
			UID:     mid,
			Status:  blocked.JuryStatusOn,
			OPID:    arg.OPID,
			Remark:  blocked.AddJuryRemark,
			Expired: xtime.Time(now.Add(day * time.Duration(arg.Day)).Unix()),
		}
		if jury, ok := mids[mid]; ok {
			user.ID = jury.ID
			switch {
			case jury.Black == blocked.JuryBlack:
				continue
			case jury.Black == blocked.JuryWhite:
				user.Black = blocked.JuryWhite
			}
			user.CTime = jury.CTime
			user.VoteTotal = jury.VoteTotal
			user.VoteRight = jury.VoteRight
			user.Total = jury.Total
			single := map[string]interface{}{
				"id":      jury.ID,
				"oper_id": arg.OPID,
				"status":  blocked.JuryStatusOn,
				"black":   user.Black,
				"expired": now.Add(day * time.Duration(arg.Day)).Format(creditMDL.TimeFormatSec),
			}
			multiple = append(multiple, single)
		}
		if err = tx.Save(&user).Error; err != nil {
			log.Error("s.DB.Create error(%v)", err)
			return
		}
		s.AddNotify(func() {
			s.Search.SearchUpdate(context.TODO(), blocked.BusinessBlockedJury, blocked.TableBlockedJury, multiple)
		})
		users = append(users, user)
	}
	if arg.Send == blocked.NeedSendMsg {
		for _, u := range users {
			msg := &blocked.SysMsg{
				Type:     blocked.MsgTypeGetJuryer,
				MID:      u.UID,
				Day:      arg.Day,
				RemoteIP: metadata.String(c, metadata.RemoteIP),
			}
			s.MsgCh <- msg
		}
	}
	return
}

// Cases  deal case data.
func (s *Service) Cases(c context.Context, arg *blocked.ArgCaseSearch) (list []*blocked.Case, pager *blocked.Pager, err error) {
	var ids []int64
	ids, pager, err = s.searchDao.Case(c, arg)
	if err != nil {
		log.Error(" s.searchDao.Case  error(%v)", err)
		return
	}
	if len(ids) == 0 {
		return
	}
	var (
		accInfoMap   map[int64]*account.Info
		relationsMap map[int64]*relationmdl.Stat
		uids         = make([]int64, 0)
	)
	ids = creditMDL.ArrayUnique(ids)
	if err = s.blockedDao.ReadDB.Where("id IN (?)", ids).Order(fmt.Sprintf("%s %s", arg.Order, arg.Sort)).Find(&list).Error; err != nil {
		if err != ecode.NothingFound {
			log.Error("s.blockedDao(%s) error(%v)", xstr.JoinInts(ids), err)
			return
		}
		log.Warn("search ids(%s) not in db", xstr.JoinInts(ids))
		err = nil
	}
	for _, v := range list {
		if v.MID > 0 {
			uids = append(uids, v.MID)
		}
	}
	if accInfoMap, err = s.accDao.RPCInfos(c, uids); err != nil {
		log.Error("s.accDao.RPCInfos(%s) error(%v)", xstr.JoinInts(uids), err)
		err = nil
	}
	if relationsMap, err = s.RelationDao.RPCStats(c, uids); err != nil {
		log.Error("s.RelationDao.RPCStats(%s) error(%v)", xstr.JoinInts(uids), err)
		err = nil
	}
	for _, v := range list {
		if accInfo, ok := accInfoMap[v.MID]; ok {
			v.Uname = accInfo.Name
		}
		if relationInfo, ok := relationsMap[v.MID]; ok {
			v.Fans = relationInfo.Follower
		}
		v.OPName = s.Managers[v.OPID]
		v.StatusDesc = blocked.StatusDesc[v.Status]
		v.OriginTypeDesc = blocked.OriginTypeDesc[v.OriginType]
		v.ReasonTypeDesc = blocked.ReasonTypeDesc(v.ReasonType)
		v.PunishDesc = blocked.PunishDesc[v.PunishResult]
		v.CaseTypeDesc = blocked.CaseTypeDesc[v.CaseType]
		v.VoteTotal = blocked.VoteTotal(v.VoteRule, v.VoteBreak, v.VoteDelete)
		if v.VoteRule > 0 || v.VoteBreak > 0 || v.VoteDelete > 0 {
			v.BlockedPercent = blocked.BreakPercent(v.VoteRule, v.VoteBreak, v.VoteDelete)
			v.DeletePercent = blocked.DeletePercent(v.VoteRule, v.VoteBreak, v.VoteDelete)
			v.RulePercent = blocked.RulePercent(v.VoteRule, v.VoteBreak, v.VoteDelete)
		}
	}
	return
}

// Opinions is block opinions
func (s *Service) Opinions(c context.Context, arg *blocked.ArgOpinionSearch) (list []*blocked.Opinion, pager *blocked.Pager, err error) {
	var ids []int64
	ids, pager, err = s.searchDao.Opinion(c, arg)
	if err != nil {
		log.Error("s.blockedDao.Search appid(%s) error(%v)", "", err)
		return
	}
	if len(ids) == 0 {
		return
	}
	var (
		accInfoMap   map[int64]*account.Info
		relationsMap map[int64]*relationmdl.Stat
		uids         = make([]int64, 0)
	)
	ids = creditMDL.ArrayUnique(ids)
	if err = s.blockedDao.ReadDB.Where("id IN (?)", ids).Order(fmt.Sprintf("%s %s", arg.Order, arg.Sort)).Find(&list).Error; err != nil {
		if err != ecode.NothingFound {
			log.Error("s.blockedDao(%s) error(%v)", xstr.JoinInts(ids), err)
			return
		}
		log.Warn("search ids(%s) not in db", xstr.JoinInts(ids))
		err = nil
	}
	for _, v := range list {
		if v.MID > 0 {
			uids = append(uids, v.MID)

		}
	}
	accInfoMap, err = s.accDao.RPCInfos(c, uids)
	if err != nil {
		log.Error("s.accDao.RPCInfos error(%v)", err)
		err = nil
	}
	if relationsMap, err = s.RelationDao.RPCStats(c, uids); err != nil {
		log.Error("s.RelationDao.RPCStats(%s) error(%v)", xstr.JoinInts(uids), err)
		err = nil
	}
	for _, v := range list {
		if opinion, ok := accInfoMap[v.MID]; ok {
			v.UName = opinion.Name
		}
		if relationInfo, ok := relationsMap[v.MID]; ok {
			v.Fans = relationInfo.Follower
		}
		v.OPName = s.Managers[v.OperID]
		v.AttrDesc = blocked.AttrDesc[v.Attr]
		v.VoteDesc = blocked.VoteDesc[v.Vote]
		v.VoteStateDesc = blocked.VoteStateDesc[v.State]
	}
	return
}

// Jurys select jury lists.
func (s *Service) Jurys(c context.Context, arg *blocked.ArgJurySearch) (list []*blocked.Jury, pager *blocked.Pager, err error) {
	var ids []int64
	ids, pager, err = s.searchDao.Jury(c, arg)
	if err != nil {
		log.Error("s.searchDao.Jury error(%v)", err)
		return
	}
	if len(ids) == 0 {
		return
	}
	var (
		accInfoMap map[int64]*account.Info
		uids       = make([]int64, len(ids))
	)
	ids = creditMDL.ArrayUnique(ids)
	if err = s.blockedDao.ReadDB.Where("id IN (?)", ids).Order(fmt.Sprintf("%s %s", arg.Order, arg.Sort)).Find(&list).Error; err != nil {
		if err != ecode.NothingFound {
			log.Error("s.blockedDao(%s) error(%v)", xstr.JoinInts(ids), err)
			return
		}
		log.Warn("search ids(%s) not in db", xstr.JoinInts(ids))
		err = nil
	}
	for _, v := range list {
		uids = append(uids, v.UID)
	}
	accInfoMap, err = s.accDao.RPCInfos(c, uids)
	if err != nil {
		log.Error("s.accDao.RPCInfos error(%v)", err)
		err = nil
	}
	for _, v := range list {
		if jury, ok := accInfoMap[v.UID]; ok {
			v.UName = jury.Name
		}
		v.OPName = s.Managers[v.OPID]
		v.EffectDay = xtime.Time(v.Expired.Time().AddDate(0, 0, -blocked.JuryDay).Unix())
		if v.EffectDay < v.CTime {
			v.EffectDay = v.CTime
		}
		if v.VoteTotal > 0 {
			v.VoteRadio = strconv.FormatFloat(float64(v.VoteRight)/float64(v.VoteTotal)*100, 'f', 2, 64)
		} else {
			v.VoteRadio = "-1"
		}
		v.StatusDesc = blocked.JuryerStatus[v.Status]
		v.BlackDesc = blocked.JuryerStyle[v.Black]
	}
	return
}

// JurysEx export jury list.
func (s *Service) JurysEx(c context.Context, arg *blocked.ArgJurySearch) (list []*blocked.Jury, err error) {
	var (
		ps    = 500
		count int
		pager *blocked.Pager
		g     errgroup.Group
	)
	if list, pager, err = s.Jurys(c, arg); err != nil {
		log.Error("s.Infos(%+v) error(%v)", arg, err)
		return
	}
	if pager == nil {
		log.Warn("arg(%+v) jury search data empty!", arg)
		return
	}
	count = pager.Total / ps
	if pager.Total%ps != 0 {
		count++
	}
	lCh := make(chan []*blocked.Jury, count)
	for pn := 1; pn <= count; pn++ {
		tmpPn := pn
		g.Go(func() (err error) {
			var gJury []*blocked.Jury
			gArg := &blocked.ArgJurySearch{
				UID:         arg.UID,
				Status:      arg.Status,
				Black:       arg.Black,
				ExpiredFrom: arg.ExpiredFrom,
				ExpiredTo:   arg.ExpiredTo,
				Order:       arg.Order,
				Sort:        arg.Sort,
				PN:          tmpPn,
				PS:          ps,
			}
			gJury, _, err = s.Jurys(c, gArg)
			if err != nil {
				log.Error("s.Jurys(%+v) error(%v)", gJury, err)
				err = nil
				return
			}
			lCh <- gJury
			return
		})
	}
	g.Wait()
	close(lCh)
	for jInfo := range lCh {
		list = append(list, jInfo...)
	}
	sort.Slice(list, func(i int, j int) bool {
		return list[i].ID < list[j].ID
	})
	return
}

// UpCaseStatus update case status.
func (s *Service) UpCaseStatus(c context.Context, arg *blocked.ArgUpStatus) (err error) {
	items := []blocked.Case{}
	if err = s.blockedDao.ReadDB.Where("id IN(?)", arg.IDS).Find(&items).Error; err != nil {
		log.Error("s.blockedDao.caseByIDs(%s) error(%v)", xstr.JoinInts(arg.IDS), err)
		return
	}
	var multiple []interface{}
	if arg.Status == blocked.CaseStatusGranting {
		hour := s.CaseConfig(blocked.ConfigCaseGiveHours)
		now := time.Now()
		if err = s.DB.Model(blocked.Case{}).Where("id IN(?)", arg.IDS).Updates(
			&blocked.Case{
				Status:    arg.Status,
				OPID:      arg.OID,
				StartTime: xtime.Time(now.Unix()),
				EndTime:   xtime.Time(now.Add(time.Duration(hour) * time.Hour).Unix()),
			}).Error; err != nil {
			return
		}
		for _, item := range items {
			single := map[string]interface{}{
				"id":         item.ID,
				"oper_id":    arg.OID,
				"start_time": now.Format(creditMDL.TimeFormatSec),
				"status":     arg.Status,
				"case_type":  item.CaseType,
			}
			multiple = append(multiple, single)
		}
	} else {
		if err = s.DB.Model(blocked.Case{}).Where("id IN(?)", arg.IDS).Updates(
			&blocked.Case{
				Status: arg.Status,
				OPID:   arg.OID,
			}).Error; err != nil {
			return
		}
		for _, item := range items {
			single := map[string]interface{}{
				"id":        item.ID,
				"oper_id":   arg.OID,
				"status":    arg.Status,
				"case_type": item.CaseType,
			}
			multiple = append(multiple, single)
		}
	}
	s.AddNotify(func() {
		s.Search.SearchUpdate(context.TODO(), blocked.BusinessBlockedCase, blocked.TableBlockedCase, multiple)
	})
	return
}

// CaseReason reason info.
func (s *Service) CaseReason(c context.Context) (cr map[int]string, err error) {
	var reason []*blocked.Reason
	cr = make(map[int]string)
	if err = s.ReadDB.Select([]string{"id", "reason"}).Where("status = 0").Find(&reason).Error; err != nil {
		if err == ecode.NothingFound {
			err = nil
			return
		}
		return
	}
	for _, v := range reason {
		cr[v.ID] = v.Reason
	}
	return
}

// CaseConf caseconfig list.
func (s *Service) CaseConf(c context.Context) (cc map[string]string, err error) {
	var configs []*blocked.Config
	cc = make(map[string]string)
	err = s.ReadDB.Select([]string{"config_key", "content"}).Find(&configs).Error
	if err != nil || configs == nil {
		return
	}
	for _, v := range configs {
		cc[v.ConfigKey] = v.Content
	}
	return
}

// SetCaseConf update case config.
func (s *Service) SetCaseConf(c context.Context, cc *blocked.ArgCaseConf) (err error) {
	v := reflect.ValueOf(cc).Elem()
	tx := s.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	for i := 0; i < v.NumField(); i++ {
		fieldValue := strconv.Itoa(v.Field(i).Interface().(int))
		tag := v.Type().Field(i).Tag.Get("form")
		if err = tx.Model(&blocked.Config{}).Where("config_key = ?", tag).Updates(map[string]interface{}{"content": fieldValue, "oper_id": cc.OID}).Error; err != nil {
			log.Error("caseConfig(%s,%d) update error(%v)", v.Field(i).Type().Name(), v.Field(i).Interface().(int64), err)
			return
		}
	}
	return
}

// CaseConfig get config by key.
func (s *Service) CaseConfig(ck string) (cv int64) {
	if v, ok := s.caseConfCache[ck]; ok {
		cv, _ = strconv.ParseInt(v, 10, 64)
	}
	return
}

// KPIPoint get kpi_point data
func (s *Service) KPIPoint(c context.Context, arg *blocked.ArgKpiPointSearch) (list []*blocked.KPIPoint, pager *blocked.Pager, err error) {
	var ids []int64
	ids, pager, err = s.searchDao.KPIPoint(c, arg)
	if err != nil {
		log.Error("s.searchDao.KPIPoint error (%v)", err)
		return
	}
	if len(ids) == 0 {
		return
	}
	ids = creditMDL.ArrayUnique(ids)
	if err = s.blockedDao.ReadDB.Where("id IN (?)", ids).Order(fmt.Sprintf("%s %s", arg.Order, arg.Sort)).Find(&list).Error; err != nil {
		if err != ecode.NothingFound {
			log.Error("s.blockedDao(%s) error(%v)", xstr.JoinInts(ids), err)
			return
		}
		log.Warn("search ids(%s) not in db", xstr.JoinInts(ids))
		err = nil
	}
	return
}

// VotenumConf votenumConf list.
func (s *Service) VotenumConf(c context.Context) (cc string, err error) {
	var bc = &blocked.Config{}
	err = s.ReadDB.Select("content").Where("config_key = 'vote_num'").Find(&bc).Error
	if err != nil || bc.Content == "" {
		log.Error("s.VotenumConf(%s) error(%v)", cc, err)
		return
	}
	cc = bc.Content
	return
}

// SetVotenumConf .
func (s *Service) SetVotenumConf(c context.Context, vn *blocked.ArgVoteNum) (err error) {
	v := blocked.VoteNum{}
	v.RateS = vn.RateS
	v.RateA = vn.RateA
	v.RateB = vn.RateB
	v.RateC = vn.RateC
	v.RateD = vn.RateD
	vnb, err := json.Marshal(v)
	if err != nil {
		log.Error("json.Marshal(%+v) error(%v)", v, err)
	}
	config := &blocked.Config{}
	s.ReadDB.Where("config_key = 'vote_num'").Find(config)
	var vconfig *blocked.Config
	if config != nil && config.ID != 0 {
		vconfig = &blocked.Config{
			ID:        config.ID,
			ConfigKey: "vote_num",
			Content:   string(vnb),
			OperID:    vn.OID,
		}
	} else {
		vconfig = &blocked.Config{
			ConfigKey: "vote_num",
			Content:   string(vnb),
			OperID:    vn.OID,
		}
	}
	if err = s.DB.Save(&vconfig).Error; err != nil {
		log.Error("http.setAutoCaseConfig error(%v)", err)
		return
	}
	return
}

// WebHook a webhook from work flow.
func (s *Service) WebHook(c context.Context, data []byte) (err error) {
	wh := &blocked.WebHook{}
	if err = json.Unmarshal(data, &wh); err != nil {
		err = ecode.RequestErr
		log.Error("webhook json rawmessage(%s) error(%v)", string(data), err)
		return
	}
	if wh.Verb == "chall.SetResult" || wh.Verb == "chall.BatchSetResult" {
		if wh.Target == nil || wh.Object == nil {
			log.Warn("wh.Target or wh.Object is nil %v,%v", wh.Target, wh.Object)
			return
		}
		// appeal state not changed .
		if wh.Target.State == wh.Object.State {
			log.Warn("appeal state not changed target=%d object=%d", wh.Target.State, wh.Object.State)
			return
		}
		switch wh.Object.State {
		case blocked.AppealStateSucc:
			if err = s.blockedDao.DB.Model(&blocked.Info{}).Where("case_id =?", wh.Target.OID).Update("status", blocked.BlockStateClose).Error; err != nil {
				log.Error("s.blockedDao.DB error(%v)", err)
				return
			}
			s.MsgCh <- &blocked.SysMsg{Type: blocked.MsgTypeAppealSucc, MID: wh.Target.Mid, CID: wh.Target.OID, RemoteIP: metadata.String(c, metadata.RemoteIP)}
		case blocked.AppealStateFail:
			s.MsgCh <- &blocked.SysMsg{Type: blocked.MsgTypeAppealFail, MID: wh.Target.Mid, CID: wh.Target.OID, RemoteIP: metadata.String(c, metadata.RemoteIP)}
		default:
			log.Warn("unknown webhook state(%d) ", wh.Object.State)
		}
	}
	return
}