package service

import (
	"context"
	"go-common/app/interface/main/creative/model/tag"
	"go-common/app/interface/main/videoup/model/archive"
	"go-common/app/interface/main/videoup/model/mission"
	"go-common/app/interface/main/videoup/model/porder"
	accapi "go-common/app/service/main/account/api"
	"go-common/library/ecode"
	"go-common/library/log"
	xtime "go-common/library/time"
	"go-common/library/xstr"
	"net/url"
	"regexp"
	"strings"
	"time"
	"unicode/utf8"
)

var (
	_emptyUnicodeRegForTitle = []*regexp.Regexp{
		regexp.MustCompile(`[\x{202e}]+`),  // right-to-left override
		regexp.MustCompile(`[\x{200b}]+`),  // zeroWithChar
		regexp.MustCompile(`[\x{1f6ab}]+`), // no_entry_sign
		regexp.MustCompile(`[\n]+`),        // newline
		regexp.MustCompile(`[\r]+`),        // newline
	}
	_emptyUnicodeReg = []*regexp.Regexp{
		regexp.MustCompile(`[\x{202e}]+`),  // right-to-left override
		regexp.MustCompile(`[\x{200b}]+`),  // zeroWithChar
		regexp.MustCompile(`[\x{1f6ab}]+`), // no_entry_sign
	}
	_nocharReg = []*regexp.Regexp{
		regexp.MustCompile(`[\p{Hangul}]+`),  // kr
		regexp.MustCompile(`[\p{Tibetan}]+`), // tibe
		regexp.MustCompile(`[\p{Arabic}]+`),  // arabic
	}
	_filenameReg  = regexp.MustCompile(`^[A-Z0-9a-z]+$`)              // only letter digital.
	_staffNameReg = regexp.MustCompile("^[\u4e00-\u9fa5a-zA-Z0-9]+$") //职能：数字、字母、中文
)

func (s *Service) checkMission(c context.Context, ap *archive.ArcParam) (err error) {
	if ap.MissionID <= 0 {
		log.Warn("MissionID(%d) error", ap.MissionID)
		ap.MissionID = 0
		return
	}
	missionID := ap.MissionID
	tid := ap.TypeID
	m, ok := s.missCache[missionID]
	if !ok || m.ID == 0 {
		err = ecode.VideoupMissionErr
		return
	}
	if m.ETime.Before(time.Now()) {
		log.Error("VideoupMissionEtimeInvalid err, tid(%d)|etime(%+v)", tid, m.ETime)
		err = ecode.VideoupMissionEtimeInvalid
		return
	}
	var missionTys map[int]*mission.Mission
	if missionTys, err = s.miss.MissionOnlineByTid(c, tid); err != nil {
		log.Error("MissionOnlineByTid err, s.tid(%+v)|err(%+v)", tid, err)
		err = nil
		return
	}
	// case: 这是活动全下架，还想参加活动
	if len(missionTys) == 0 {
		log.Error("missionTys already empty, tid(%d)|missionTys(%+v)", tid, missionTys)
		err = ecode.VideoupMissionNoMatch
		return
	}
	// 包含对分区无限制的活动
	if _, ok := missionTys[missionID]; !ok {
		log.Error("VideoupMissionNoMatch err, tid(%d)|missionID(%d)", tid, missionID)
		err = ecode.VideoupMissionNoMatch
		return
	}
	if ap.Copyright == archive.CopyrightCopy {
		log.Error("VideoupCopyForbidJoinMission err, copyright(%d)|missionID(%d)", ap.Copyright, ap.MissionID)
		err = ecode.VideoupCopyForbidJoinMission
		return
	}
	return
}

func (s *Service) checkMissionTag(srcTag string, missionID int) (dstTag string, err error) {
	var ctags = strings.Split(srcTag, ",")
	dstTag = srcTag
	// 交叉对比剔除掉当前活动已经使用的tag内容
	if len(s.missTagsCache) != 0 {
		var tags = make([]string, 0, len(ctags))
		for _, t := range ctags {
			if _, ok := s.missTagsCache[t]; !ok {
				tags = append(tags, t)
			}
		}
		dstTag = strings.Join(tags, ",")
	}
	// 校验
	// 两种情况报错提示用户: 1. 未参加活动,只提交一个tag，且是活动tag, 2. 参加活动，只提交了一个tag，且是其他活动的活动tag
	if dstTag == "" && missionID == 0 {
		log.Error("forbidMissionTagWithoutJoinMission srcTag(%s), MissionID(%d),s.missCache(%+v),s.missTagsCache(%+v)", srcTag, missionID, s.missCache, s.missTagsCache)
		err = ecode.VideoupTagForbidNotJoinMission
		return
	}
	// 未参加活动，就直接返回校验后的tag内容
	m, ok := s.missCache[missionID]
	if !ok {
		return
	}
	// 如果参加了当前有效的活动，就会把对应的活动第一个tag拼接在头部, 对于活动id和tag不匹配的会做校验
	var singleMissionTag string
	if m.Tags != "" {
		singleMissionTag = strings.Split(m.Tags, ",")[0]
	} else {
		singleMissionTag = m.Name
	}
	if len(dstTag) > 0 {
		dstTag = singleMissionTag + "," + dstTag
	} else {
		dstTag = singleMissionTag
	}
	return
}

func (s *Service) checkVideo(ap *archive.ArcParam) (err error) {
	vds := make([]*archive.VideoParam, 0)
	fnMap := make(map[string]int)
	var ok bool
	for i, v := range ap.Videos {
		if v == nil {
			continue
		}
		if v.Title, ok = s.checkTitle(v.Title); !ok {
			newErr := ecode.VideoupVideoTitleErr
			err = ecode.Errorf(newErr, newErr.Message(), i+1)
			log.Error("ap.Videos checkTitle err(%+v)|Title(%s)", err, v.Title)
			return
		}
		if v.Desc, ok = s.checkDesc(v.Desc); !ok {
			newErr := ecode.VideoupVideoDescErr
			err = ecode.Errorf(newErr, newErr.Message(), i+1)
			log.Error("ap.Videos checkDesc err(%+v)|Desc(%s)", err, v.Desc)
			return
		}
		if ok = _filenameReg.MatchString(v.Filename); !ok {
			newErr := ecode.VideoupVideoFilenameErr
			err = ecode.Errorf(newErr, newErr.Message(), i+1)
			log.Error("ap.Videos _filenameReg err(%+v)|filename(%s)", err, v.Filename)
			return
		}
		if v.Cid == 0 && v.Filename == "" { // NOTE: cid>0 means code mode
			newErr := ecode.VideoupVideoFilenameErr
			err = ecode.Errorf(newErr, newErr.Message(), i+1)
			log.Error("ap.Videos err(%+v)|Filename(%s)|Cid(%d)", err, v.Filename, v.Cid)
			return
		}
		if _, ok := fnMap[v.Filename]; ok {
			err = ecode.VideoupFilenameCanotRepeat
			log.Error("ecode.VideoupFilenameCanotRepeat err(%+v)|Filename(%s)|index(%d)", err, v.Filename, i)
			return
		}
		vds = append(vds, v)
		fnMap[v.Filename] = 1
	}
	ap.Videos = vds
	return
}

func (s *Service) checkCover(cover string) (cv string, ok bool) {
	if cover == "" {
		ok = true
		return
	}
	uri, err := url.Parse(cover)
	if err != nil {
		return
	}
	if strings.Contains(uri.Host, "hdslb.com") {
		cv = uri.Path
		ok = true
		return
	} else if strings.Contains(uri.Host, "acgvideo.com") {
		cv = cover
		ok = true
		return
	}
	return
}

func (s *Service) checkDynamicLen233(dynamic string) (dyn string, ok bool) {
	dyn = strings.TrimSpace(dynamic)
	var _emptyDynUnicodeReg = []*regexp.Regexp{
		regexp.MustCompile(`[\x{FFFC}]+`), // obj
	}
	for _, reg := range _emptyDynUnicodeReg {
		dyn = reg.ReplaceAllString(dyn, "")
	}
	if utf8.RuneCountInString(dyn) > 233 {
		return
	}
	ok = true
	return
}

func (s *Service) checkTitle(title string) (ct string, ok bool) {
	ct = strings.TrimSpace(title)
	if utf8.RuneCountInString(ct) > 80 {
		return
	}
	for _, reg := range _nocharReg {
		if reg.MatchString(ct) {
			return
		}
	}
	for _, reg := range _emptyUnicodeRegForTitle {
		ct = reg.ReplaceAllString(ct, "")
	}
	ok = true
	return
}

func (s *Service) checkDesc(desc string) (cd string, ok bool) {
	cd = strings.TrimSpace(desc)
	for _, reg := range _emptyUnicodeReg {
		cd = reg.ReplaceAllString(cd, "")
	}
	if utf8.RuneCountInString(cd) > 2000 {
		return
	}
	ok = true
	return
}

func (s *Service) checkAccount(c context.Context, mid int64, ip string) (p *accapi.Profile, err error) {
	if p, err = s.acc.Profile(c, mid, ip); err != nil {
		return
	}
	if p.Silence == 1 {
		err = ecode.UserDisabled
	} else if p.Level < 1 {
		err = ecode.UserLevelLow
	}
	if _, ok := s.exemptZeroLevelAndAnswerUps[mid]; ok && err == ecode.UserLevelLow {
		log.Info("s.exemptZeroLevelAndAnswerUps, (%s),(%d),(%+v)", ip, mid, err)
		err = nil
	}
	return
}

func (s *Service) checkOrderID(c context.Context, mid, orderID int64, ip string) (err error) {
	orderIDs, err := s.order.ExecuteOrders(c, mid, ip)
	if err != nil {
		log.Error("s.order.ExecuteOrders mid(%d) ip(%s) error(%v)", mid, err)
		err = ecode.VideoupOrderAPIErr
		return
	}
	if _, ok := orderIDs[orderID]; !ok {
		err = ecode.VideoupOrderIDNotAllow
	}
	return
}

func (s *Service) checkIdentify(c context.Context, mid int64, ip string) (err error) {
	if _, ok := s.exemptIDCheckUps[mid]; ok {
		log.Info("s.exemptIDCheckUps, (%s),(%d),(%+v)", ip, mid, err)
		return
	}
	// fault-tolerant for service interruption
	if err = s.acc.IdentifyInfo(c, ip, mid); err != nil {
		if err != ecode.UserCheckNoPhone && err != ecode.UserCheckInvalidPhone {
			log.Warn("s.accIdentifyInfo, account service maybe in interruption,(%s),(%d),(%+v)", ip, mid, err)
			return nil
		}
		log.Error("s.accIdentifyInfo, (%s),(%d),(%+v)", ip, mid, err)
		return
	}
	return
}

// checkPorderForAdd
func (s *Service) checkPorderForAdd(c context.Context, ap *archive.ArcParam, mid int64) (err error) {
	// 防止脏数据, 强制计算和校验Porder的数据
	ap.Porder.FlowID = 1
	log.Info("ap.Porder (%+v)", ap.Porder)
	// showType check
	if len(ap.Porder.ShowType) > 0 {
		var showTypes []int64
		if showTypes, err = xstr.SplitInts(ap.Porder.ShowType); err != nil {
			log.Error("SplitInts ShowType err, (%s),(%+v)", ap.Porder.ShowType, err)
			return
		}
		//广告的展现形式太多或者太少
		if len(showTypes) == 0 {
			err = ecode.VideoupAdShowTypeErr
			log.Error("check showTypes (%+v)|err(%+v)", ap.Porder, err)
			return
		}
		for _, showType := range showTypes {
			if showType > 0 {
				if _, ok := s.PorderCfgs[showType]; !ok {
					err = ecode.VideoupAdShowTypeErr
					log.Error("VideoupAdShowTypeErr Porder(%+v)|err(%+v)", ap.Porder.ShowType, err)
					return
				}
			}
		}
	}
	// Official check
	if ap.Porder.Official == 1 {
		if _, ok := porder.OfficialIndustryMaps[ap.Porder.IndustryID]; !ok {
			err = ecode.VideoupAdOfficialIndustryIDErr
			log.Error("VideoupAdOfficialIndustryIDErr Porder(%+v)|err(%+v)", ap.Porder, err)
			return
		}
		if ap.Porder.BrandID < 0 {
			err = ecode.VideoupAdBrandIDErr
			log.Error("VideoupAdBrandIDErr Porder(%+v)|err(%+v)", ap.Porder, err)
			return
		}
		// logic map to OfficialIndustryMaps waiting for add other official industry
		if _, ok := s.PorderGames[ap.Porder.BrandID]; !ok {
			err = ecode.VideoupAdBrandIDErr
			log.Error("VideoupAdBrandIDErr Porder(%+v)|err(%+v)", ap.Porder, err)
			return
		}
	}
	// Industry check
	if ap.Porder.IndustryID > 0 {
		if _, ok := s.PorderCfgs[ap.Porder.IndustryID]; !ok {
			err = ecode.VideoupAdIndustryIDErr
			log.Error("VideoupAdIndustryIDErr Porder(%+v)|err(%+v)", ap.Porder, err)
			return
		}
	}
	return
}

// checkDescForLength fn
func (s *Service) checkDescForLength(desc string, descFormatID int, typeID int16, copyright int8) (err error) {
	if descFormatID == 0 {
		if utf8.RuneCountInString(desc) > 250 {
			err = ecode.VideoupFmDesLenOverLimit
			log.Error("ecode.VideoupFmDesLenOverLimit, desc(%s),formatID(%d)", desc, descFormatID)
			return
		}
		return
	}
	if utf8.RuneCountInString(desc) > 2000 {
		err = ecode.VideoupFmDesLenOverLimit
		log.Error("ecode.VideoupFmDesLenOverLimit, desc(%s),formatID(%d)", desc, descFormatID)
		return
	}
	return
}

// checkVideos, 1: check len(video) == ? 0 , 2: check typeID in (145,146,147,83) and with multi Videos
func (s *Service) checkVideos(c context.Context, ap *archive.ArcParam) (err error) {
	if len(ap.Videos) == 0 {
		log.Error("checkVideos vds length 0")
		err = ecode.VideoupZeroVideos
		return
	}
	if len(ap.Videos) > 1 && ap.ForbidMultiVideoType() {
		log.Error("checkVideos vds ForbidMultiVideoType, len(%d), type(%d) ", len(ap.Videos), ap.TypeID)
		err = ecode.VideoupForbidMultiVideoForTypes
		return
	}
	return
}

// tagsCheck fn
func (s *Service) tagsCheck(c context.Context, mid int64, tagName, ip string) (err error) {
	var t *tag.Tag
	tags := strings.Split(tagName, ",")
	for i, tagStr := range tags {
		if t, err = s.tag.TagCheck(c, mid, tagStr); err != nil {
			log.Error("s.tag.TagCheck(%d, %+v, %s) error(%+v)", mid, t, ip, err)
			err = nil
			return
		}
		if t != nil && (t.State == tag.TagStateDel || t.State == tag.TagStateHide || t.Type == tag.OfficailActiveTag) {
			newErr := ecode.VideoupTagForbid
			err = ecode.Errorf(newErr, newErr.Message(), i+1)
			log.Error("s.tag.VideoupTagForbid (%d, %+v, %s) error(%+v)", mid, t, ip, err)
			return
		}
	}
	return
}

// checkVideosMaxLimitForEdit fn
func (s *Service) checkVideosMaxLimitForEdit(vs []*archive.Video, pvideos []*archive.VideoParam) (addCnt int) {
	fnMaps := make(map[string]string)
	for _, v := range vs {
		fnMaps[v.Filename] = v.Filename
	}
	for _, v := range pvideos {
		if _, exist := fnMaps[v.Filename]; len(v.Filename) > 0 && !exist {
			addCnt++
		}
	}
	return
}

// checkPay fn
func (s *Service) checkAddPay(c context.Context, ap *archive.ArcParam, ip string) (err error) {
	if err = s.checkPayProtocol(c, ap.Pay, ap.Mid); err != nil {
		log.Error("s.checkAddPayProtocol (ap %+v) error(%+v)", ap, err)
		return
	}
	if err = s.checkPayLimit(c, ap); err != nil {
		log.Error("s.checkAddPayLimit (ap %+v) error(%+v)", ap, err)
		return
	}
	if err = s.checkPayWithOrder(c, ap.Porder, ap.Pay, ap.OrderID, ap.Mid); err != nil {
		log.Error("s.checkAddPayWithOrder (ap %+v) error(%+v)", ap, err)
		return
	}
	return
}

// checkEditPay fn
// 关于RefuseUpdate
// 1.当ctime==ptime的时候，也就是尚未稿件一审，都是可以update付费模块的
// 2.开放过的，打回的稿件可以在任何时间点进行付费修改
// 3.开放过的，非打回的稿件想要修改只能等60天时间过了之后(时间锁是为了保护普通用户的收看权利)，否则自己申诉付费审核人员，要求强制打回
func (s *Service) checkEditPay(c context.Context, ap *archive.ArcParam, a *archive.Archive, ip string) (err error) {
	_, registed, _ := s.pay.Ass(c, a.Aid, ip)
	// 只要注册过付费信息都允许自主修改付费模块
	if registed {
		if err = s.checkPayProtocol(c, ap.Pay, ap.Mid); err != nil {
			log.Error("s.checkAddPayProtocol (ap %+v) error(%+v)", ap, err)
			return
		}
		if err = s.checkPayLimit(c, ap); err != nil {
			log.Error("s.checkAddPayLimit (ap %+v) error(%+v)", ap, err)
			return
		}
		if err = s.checkPayWithOrder(c, ap.Porder, ap.Pay, ap.OrderID, ap.Mid); err != nil {
			log.Error("s.checkAddPayWithOrder (ap %+v) error(%+v)", ap, err)
			return
		}
		//如果其他端都不传付费信息，那么就用现在有的来进行最后覆盖
		if ap.Pay == nil {
			ap.UgcPay = a.UgcPay
			return
		}
		updateDeadLine := xtime.Time(a.PTime.Time().AddDate(0, 0, s.c.UgcPayAllowEditDays).Unix())
		if ap.Pay != nil &&
			a.CTime != a.PTime &&
			a.State != archive.StateForbidRecicle &&
			xtime.Time(time.Now().Unix()) < updateDeadLine {
			log.Warn("checkEditPay ap.Pay.RefuseUpdate updateDeadLine (%+v)|(%+v)|(%+v)", a.Aid, a.CTime, a.PTime)
			ap.Pay.RefuseUpdate = true
		}
	}
	return
}