package service

import (
	"context"
	"fmt"
	"time"

	"go-common/app/interface/main/dm/model"
	"go-common/app/interface/main/dm2/model/oplog"
	arcMdl "go-common/app/service/main/archive/model/archive"
	"go-common/library/ecode"
	"go-common/library/log"
)

const (
	_reportLock    = 1800
	_reportLimit   = 10
	_rptAutoDelCnt = 3
)

// AddReport add dm report.
func (s *Service) AddReport(c context.Context, cid, dmid, uid int64, reason int8, content string) (id int64, err error) {
	var (
		needDelete, needHide bool
		state                int8
		score                int32
	)
	t, err := s.dao.RptBrigTime(c, uid)
	if err != nil {
		return
	}
	if time.Now().Unix()-t < _reportLock {
		err = ecode.DMReportLimit
		return
	}
	cnt, err := s.dao.RptCnt(c, uid)
	if err != nil {
		return
	}

	if cnt >= _reportLimit {
		if err = s.dao.AddRptBrig(c, uid); err != nil {
			log.Error("s.dao.AddRptBrig(%d) error(%v)", uid, err)
		}
		err = ecode.DMReportLimit
		return
	}
	dms, err := s.dms(c, model.SubTypeVideo, cid, []int64{dmid})
	if err != nil {
		return
	}
	if len(dms) == 0 || !dms[0].NeedDisplay() {
		err = ecode.DMReportNotExist
		return
	}
	if _, err = s.dao.UptRptCnt(c, uid); err != nil {
		log.Error("s.dao.UptRptCnt(%d) error(%v)", uid, err)
		err = nil
	}
	rpt, err := s.dao.Report(c, cid, dmid)
	if err != nil {
		log.Error("s.dao.Report(cid:%d,dmid:%d) error(%v)", cid, dmid, err)
		return
	}
	// score
	if score, err = s.dao.FigureInfo(c, uid); err != nil {
		log.Error("s.dao.FigureInfo(uid: %d) error(%v)", uid, err)
		return
	}
	if score < 0 || score > 100 {
		log.Error("s.AddReport.score illegal(uid: %d) score(%v)", uid, score)
		score = 0
	} else {
		score = 100 - score
	}
	if rpt != nil {
		state, err = s.checkReasonType(c, reason, cid, dmid, rpt)
		if err != nil {
			log.Error("s.checkReasonType(reason: %d) error(%v)", reason, err)
			return
		}
		/*
			以下弹幕不能自动删除与隐藏
			1. mode7、mode8、mode9弹幕
			2. 字幕弹幕
			3. 保护弹幕
			4. up主在自己的视频下发送的弹幕
		*/
		if state == model.StatSecondInit &&
			dms[0].Content.Mode != 7 &&
			dms[0].Content.Mode != 8 &&
			dms[0].Content.Mode != 9 &&
			dms[0].AttrVal(model.AttrProtect) != model.AttrYes &&
			dms[0].Pool == 0 &&
			!s.isUpper(c, cid, dms[0].Mid) {
			if (reason == model.ReportReasonAd && rpt.Reason == model.ReportReasonAd) || rpt.Count >= _rptAutoDelCnt-1 || rpt.Score+score >= 160 {
				needDelete = true
			} else {
				needHide = true
			}
		}
	} else {
		state = s.reasonType(reason)
		if state == model.StatSecondInit &&
			dms[0].Content.Mode != 7 &&
			dms[0].Content.Mode != 8 &&
			dms[0].Content.Mode != 9 &&
			dms[0].AttrVal(model.AttrProtect) != model.AttrYes &&
			dms[0].Pool == 0 &&
			!s.isUpper(c, cid, dms[0].Mid) {
			needHide = true
		}
	}
	nowTime := time.Now()
	r := &model.Report{
		Cid:     cid,
		Did:     dmid,
		UID:     uid,
		Reason:  reason,
		Content: content,
		Count:   1,
		State:   state,
		UpOP:    model.StatUpperInit,
		Score:   score,
		RpTime:  nowTime,
		Ctime:   nowTime,
		Mtime:   nowTime,
	}
	u := &model.User{
		Did:     dmid,
		UID:     uid,
		State:   model.NoticeUnsend,
		Reason:  reason,
		Content: content,
		Ctime:   nowTime,
		Mtime:   nowTime,
	}
	lastID, err := s.dao.AddReportUser(c, u)
	if err != nil {
		log.Error("s.dao.AddReportUser(%v) error(%v)", u, err)
		return
	}
	if lastID < 1 {
		err = ecode.DMReportExist
		return
	}
	if id, err = s.dao.AddReport(c, r); err != nil {
		log.Error("s.dao.AddReport(%v) error(%v)", r, err)
		return
	}
	if needDelete {
		select {
		case s.delDMReportChan <- rpt:
		default:
			log.Error("s.delDMReportChan.full(%v)", rpt)
		}
	}
	if needHide && !needDelete {
		select {
		case s.hideDMReportChan <- r:
		default:
			log.Error("s.hideDMReportChan.full(%v)", r)
		}
	}
	return
}

// EditReport edit report dm.
func (s *Service) EditReport(c context.Context, tp int32, cid, mid, dmid int64, op int8) (affect int64, err error) {
	r, err := s.dao.Report(c, cid, dmid)
	if err != nil {
		log.Error("s.dao.Report(cid:%d, dmid:%d), error(%v)", cid, dmid, err)
		return
	}
	if r == nil {
		err = ecode.DMReportNotExist
		return
	}
	if !s.isUpper(c, cid, mid) {
		err = ecode.ArchiveOwnerErr
		return
	}
	if affect, err = s.dao.UpdateReportUPOp(c, cid, dmid, op); err != nil {
		log.Error("s.dao.UpdateReportUPOp(cid:%d, dmid:%d, op:%d) error(%v)", cid, dmid, op, err)
	}
	if op == model.StatUpperDelete {
		if err = s.EditDMState(c, tp, cid, mid, model.StateDelete, oplog.SourceUp, oplog.OperatorUp, dmid); err != nil {
			log.Error("s.EditDMStat(cid:%d,dmid:%d) error(%v)", cid, dmid, err)
			return
		}
	}
	v := &model.UptSearchReport{
		DMid:  dmid,
		Upop:  op,
		Ctime: r.Ctime.Format("2006-01-02 15:04:05"),
		Mtime: time.Now().Format("2006-01-02 15:04:05"),
	}
	err = s.dao.UpdateSearchReport(c, []*model.UptSearchReport{v})
	return
}

// ReportList 获取一个用户的所有被举报的弹幕
func (s *Service) ReportList(c context.Context, mid, aid, page, size int64, upOp int8, states []int64) (res *model.RptSearchs, err error) {
	res = &model.RptSearchs{}
	var (
		aidsMap  = make(map[int64]struct{})
		aids     = []int64{}
		cidDMids = make(map[int64][]int64)
		stateMap = make(map[int64]int64)
	)
	rptSearch, err := s.dao.SearchReport(c, mid, aid, page, size, upOp, states)
	if err != nil || rptSearch == nil {
		return
	}
	for _, v := range rptSearch.Result {
		if _, ok := aidsMap[v.Aid]; !ok {
			aidsMap[v.Aid] = struct{}{}
			aids = append(aids, v.Aid)
		}
		cidDMids[v.Cid] = append(cidDMids[v.Cid], v.Did)
	}
	archives := s.archiveInfos(c, aids)
	if stateMap, err = s.dmState(c, cidDMids); err != nil {
		return
	}
	for _, v := range rptSearch.Result {
		if arc, ok := archives[v.Aid]; ok {
			v.Title = arc.Title
			v.Cover = arc.Pic
		}
		if state, ok := stateMap[v.Did]; ok {
			v.Deleted = state
		}
	}
	res = &model.RptSearchs{
		Page:      rptSearch.Page.Num,
		PageSize:  rptSearch.Page.Size,
		PageCount: (rptSearch.Page.Total-1)/rptSearch.Page.Size + 1,
		Total:     rptSearch.Page.Total,
		Result:    rptSearch.Result,
	}
	return
}

func (s *Service) isUpper(c context.Context, cid, mid int64) bool {
	sub, err := s.subject(c, 1, cid)
	if err != nil {
		return false
	}
	return sub.Mid == mid
}

// checkReasonType get state by report reason
func (s *Service) checkReasonType(c context.Context, reason int8, cid, dmid int64, rpt *model.Report) (state int8, err error) {
	reportLog, err := s.dao.ReportLog(c, dmid)
	if err != nil {
		log.Error("s.dao.ReportLog(dmid:%d) error(%v)", dmid, err)
		return
	}
	if len(reportLog) > 0 { // 如果这个举报已经在后台被处理了,那就根据举报当前的状态返回对应的一二审状态
		if rpt.State == model.StatFirstInit ||
			rpt.State == model.StatFirstDelete ||
			rpt.State == model.StatFirstIgnore {
			state = model.StatFirstInit
		} else {
			state = model.StatSecondInit
		}
	} else { // 否则就根据举报理由来返回状态
		state = s.reasonType(reason)
	}
	return
}

// ReportArchives 获取一个用户的所有被举报的稿件
func (s *Service) ReportArchives(c context.Context, mid int64, upOp int8, states []int8, pn, ps int64) (res *model.Archives, err error) {
	res = &model.Archives{}
	aids, err := s.dao.SearchReportAid(c, mid, upOp, states, pn, ps)
	if err != nil || len(aids) == 0 {
		return
	}
	archiveInfos := s.archiveInfos(c, aids)
	for aid, info := range archiveInfos {
		res.Result = append(res.Result, &struct {
			Aid   int64  `json:"aid"`
			Title string `json:"title"`
		}{Aid: aid, Title: info.Title})
	}
	return
}

func (s *Service) reasonType(reason int8) (state int8) {
	if reason == model.ReportReasonProhibited ||
		reason == model.ReportReasonPorn ||
		reason == model.ReportReasonFraud ||
		reason == model.ReportReasonAttack ||
		reason == model.ReportReasonPrivate ||
		reason == model.ReportReasonTeenagers {
		state = model.StatFirstInit
	} else {
		state = model.StatSecondInit
	}
	return
}

// deleteDMReport delete dm report.
func (s *Service) deleteDMReport(c context.Context, rpt *model.Report) (err error) {
	sub, err := s.subject(c, 1, rpt.Cid)
	if err != nil {
		return
	}
	rpt.State = model.StatSecondAutoDelete
	if err = s.EditDMState(c, 1, rpt.Cid, sub.Mid, model.StateScriptDelete, oplog.SourceUp, oplog.OperatorUp, rpt.Did); err != nil {
		log.Error("s.EditDMStat(cid:%d, state:%d, dmid:%d ) error(%v)", rpt.Cid, rpt.State, rpt.Did, err)
		return
	}
	if _, err = s.dao.UpdateReportStat(c, rpt.Cid, rpt.Did, rpt.State); err != nil {
		log.Error("s.dao.UpdateReportStat(cid:%d, state:%d, dmid:%d ) error(%v)", rpt.Cid, rpt.State, rpt.Did, err)
		return
	}
	lg := &model.RptLog{
		Did:     rpt.Did,
		AdminID: 0,
		Reason:  rpt.Reason,
		Result:  rpt.State,
		Remark:  "自动删除",
		Elapsed: int64(time.Since(rpt.Mtime).Seconds()),
		Ctime:   time.Now(),
		Mtime:   time.Now(),
	}
	if err = s.dao.AddReportLog(c, lg); err != nil {
		log.Error("s.dao.AddReportLog(log:%v) error(%v)", lg, err)
		return
	}
	users, err := s.dao.ReportUser(c, rpt.Did)
	if err != nil {
		log.Error("s.dao.ReportUser(dmid:%d) error(%v)", rpt.Did, err)
		return
	}
	if err = s.dao.SetReportUserFinished(c, rpt.Did); err != nil {
		log.Error("s.dao.SetReportUserFinished(dmid:%d) error(%v)", rpt.Did, err)
		return
	}
	ct, err := s.dao.Content(c, rpt.Cid, rpt.Did)
	if err != nil || ct == nil {
		return
	}
	arc, err := s.acvSvc.Archive3(c, &arcMdl.ArgAid2{Aid: sub.Pid})
	if err != nil {
		log.Error("s.acvSvc.Archive3(%d) error(%v)", sub.Pid, err)
		return
	}
	for _, u := range users {
		content := fmt.Sprintf(model.RptMsgTemplate, arc.Title, arc.Aid, ct.Msg, model.ReportReason[rpt.Reason])
		s.dao.SendNotify(c, model.RptMsgTitle, content, []int64{u.UID})
	}
	return
}

//hideDMReport hide reported dm
func (s *Service) hideDMReport(c context.Context, rpt *model.Report) (err error) {
	dmids := []int64{rpt.Did}
	//change dm state to hide
	_, err = s.dao.UpdateDMStat(c, 1, rpt.Cid, model.StateHide, dmids)
	if err != nil {
		log.Error("s.dao.UpdateDMStat(oid:%d state:%d dmids:%v) error(%v)", rpt.Cid, model.StateHide, rpt.Did, err)
		return
	}
	// send hideTime to databus
	time := time.Now().Unix() + 72000
	act := &model.ReportAction{
		Cid:      rpt.Cid,
		Did:      rpt.Did,
		HideTime: time,
	}
	// make sure all the hided dms are in one partition
	if err = s.dao.SendAction(context.TODO(), "1", act); err != nil {
		log.Error("databus.Send(%+v) error(%v)", act, err)
	}
	return
}

func (s *Service) dmReportProc() {
	for {
		select {
		case rpt := <-s.delDMReportChan:
			if err := s.deleteDMReport(context.TODO(), rpt); err != nil {
				log.Error("s.deleteDMReport(rpt:%v) error(%v)", rpt, err)
			}
		case rpt := <-s.hideDMReportChan:
			if err := s.hideDMReport(context.TODO(), rpt); err != nil {
				log.Error("s.hideDMReport(rpt:%v) error(%v)", rpt, err)
			}
		}
	}
}

func (s *Service) dmState(c context.Context, cidDmids map[int64][]int64) (stateMap map[int64]int64, err error) {
	var (
		idxMap map[int64]*model.DM
		tp     = int32(1)
	)
	stateMap = make(map[int64]int64)
	for oid, dmids := range cidDmids {
		if idxMap, _, err = s.dao.IndexsByID(c, tp, oid, dmids); err != nil {
			return
		}
		for dmid, dm := range idxMap {
			stateMap[dmid] = int64(dm.State)
		}
	}
	return
}