package service

import (
	"context"
	"github.com/pkg/errors"
	"go-common/app/admin/main/videoup/model/archive"
	"go-common/app/admin/main/videoup/model/manager"
	"go-common/app/admin/main/videoup/model/search"
	accApi "go-common/app/service/main/account/api"
	"go-common/library/database/elastic"
	"go-common/library/ecode"
	"go-common/library/log"
	bm "go-common/library/net/http/blademaster"
	"go-common/library/xstr"
	"strconv"
	"strings"
	"sync"
)

// SearchVideo search video
func (s *Service) SearchVideo(c context.Context, p *search.VideoParams) (result *search.VideoResultData, err error) {
	var (
		aids, cids,
		vids, mids,
		tids, tagIds,
		xcodes []int64
		fNames           []string
		ps               = 30
		sort             string
		order            string
		isMonitor        bool          //是否查看监控列表
		moniTotal        int           //监控列表的总数量
		moniMap          map[int64]int //监控列表的视频id map。键：vid；值：time（进入监控的时间）
		tags             map[int64]string
		aStates, vStates map[int64]int
		members          map[int64]*accApi.Info
		eReq             *elastic.Request
		wg               sync.WaitGroup
	)
	es := elastic.NewElastic(nil)
	//Page
	if p.Ps != 0 {
		ps = p.Ps
	}
	if p.Pn == 0 {
		p.Pn = 1
	}
	if p.OrderType == "1" {
		eReq = es.NewRequest("archive_video_score")
	} else {
		eReq = es.NewRequest("archive_video")
	}
	eReq.Index("archive_video")

	if p.Keywords != "" {
		eReq.WhereLike([]string{"arc_title", "arc_author"}, []string{p.Keywords}, true, elastic.LikeLevelLow)
	}
	if p.ArcTitle != "" {
		eReq.WhereLike([]string{"arc_title"}, []string{p.ArcTitle}, false, elastic.LikeLevelLow)
	}
	if p.Aids != "" {
		p.Aids = strings.Join(Slice2String(SliceUnique(Slice2Interface(strings.Split(p.Aids, ",")))), ",")
		if aids, err = s.SplitInts(p.Aids); err != nil {
			err = ecode.RequestErr
			return
		}
		if len(aids) > ps {
			ps = len(aids)
		}
		eReq.WhereIn("aid", aids)
	}

	//监控结果列表逻辑
	if p.MonitorList != "" {
		isMonitor = true
		var (
			rid int
		)
		moniP := strings.Split(p.MonitorList, "_")
		if len(moniP) != 3 {
			err = errors.New("监控列表标识字段格式错误")
			return
		}
		if rid, err = strconv.Atoi(moniP[2]); err != nil {
			return
		}
		if moniMap, err = s.MonitorStayOids(c, int64(rid)); err != nil {
			return
		}
		moniTotal = len(moniMap)
		for vid := range moniMap {
			vids = append(vids, vid)
		}
		if len(vids) == 0 {
			result = &search.VideoResultData{
				Result: []*search.Video{},
			}
			return
		}
		if len(vids) > ps {
			ps = len(vids)
		}
		eReq.WhereIn("vid", vids)
	}
	if p.Cids != "" {
		p.Cids = strings.Join(Slice2String(SliceUnique(Slice2Interface(strings.Split(p.Cids, ",")))), ",")
		if cids, err = s.SplitInts(p.Cids); err != nil {
			err = ecode.RequestErr
			return
		}
		if len(cids) > ps {
			ps = len(cids)
		}
		eReq.WhereIn("cid", cids)
	}
	if p.Vids != "" {
		if vids, err = s.SplitInts(p.Vids); err != nil {
			err = ecode.RequestErr
			return
		}
		if len(vids) > ps {
			ps = len(vids)
		}
		eReq.WhereIn("vid", vids)
	}
	if p.ArcMids != "" {
		if mids, err = s.SplitInts(p.ArcMids); err != nil {
			err = ecode.RequestErr
			return
		}
		if len(mids) > ps {
			ps = len(mids)
		}
		eReq.WhereIn("arc_mid", mids)
	}
	if p.Xcode != "" {
		if xcodes, err = s.SplitInts(p.Xcode); err != nil {
			err = ecode.RequestErr
			return
		}
		eReq.WhereIn("xcode_state", xcodes)
	}

	if p.TypeID != "" {
		if tids, err = s.SplitInts(p.TypeID); err != nil {
			err = ecode.RequestErr
			return
		}
		for _, tid := range tids {
			if ids, ok := s.typeCache2[int16(tid)]; ok {
				tids = append(tids, ids...)
			}
		}
		eReq.WhereIn("arc_typeid", tids)
	}
	if p.Filename != "" {
		if fNames = strings.Split(p.Filename, ","); err != nil {
			err = ecode.RequestErr
			return
		}
		eReq.WhereIn("filename", fNames)
	}
	if p.TagID != "" {
		eReq.WhereEq("tag_id", p.TagID)
	}

	if p.Status != "" {
		if p.Status == "-100" {
			eReq.WhereEq("relation_state", "-100")
			p.Status = ""
		} else {
			eReq.WhereEq("relation_state", "0")
			eReq.WhereEq("status", p.Status)
		}
	}
	if p.UserType != "" {
		eReq.WhereEq("user_type", p.UserType)
	}
	if p.DurationFrom != "" && p.DurationTo != "" {
		eReq.WhereRange("duration", p.DurationFrom, p.DurationTo, elastic.RangeScopeLcRc)
	} else if p.DurationFrom != "" && p.DurationTo == "" {
		eReq.WhereRange("duration", p.DurationFrom, "", elastic.RangeScopeLcRc)
	} else if p.DurationFrom == "" && p.DurationTo != "" {
		eReq.WhereRange("duration", "", p.DurationTo, elastic.RangeScopeLcRc)
	}

	//Order by
	if p.Order != "" {
		order = p.Order
	} else if p.Action == "trash" {
		order = "v_mtime"
	} else {
		order = "arc_senddate"
	}
	if p.Sort == 1 {
		sort = "asc"
	} else {
		sort = "desc"
	}
	eReq.Order(order, sort)

	//Page
	eReq.Ps(ps)
	eReq.Pn(p.Pn)

	//Execute
	log.Info("s.SearchVideo(%+v) SearchVideoQuery(%s)", p, eReq.Params())
	if err = eReq.Scan(c, &result); err != nil {
		log.Error("SearchVideoScan() error(%v)", err)
		return
	}
	if result == nil {
		log.Error("s.SearchVideo(%+v) search return nil result", p)
		result = &search.VideoResultData{
			Result: []*search.Video{},
		}
		return
	}
	if result.Result == nil {
		log.Error("s.SearchVideo(%+v) search return nil video", p)
		result.Result = []*search.Video{}
		return
	}
	if len(result.Result) == 0 {
		return
	}
	if isMonitor {
		result.Page.Total = moniTotal
	}
	aids = []int64{}
	vids = []int64{}
	mids = []int64{}
	for _, v := range result.Result {
		if v.TagID != 0 {
			tagIds = append(tagIds, v.TagID)
		}
		aids = append(aids, v.Aid)
		vids = append(vids, v.Vid)
		if v.ArcMid != 0 {
			mids = append(mids, v.ArcMid)
		}
	}
	//获取Tag名称
	wg.Add(1)
	go func(tags *map[int64]string) {
		defer wg.Done()
		if *tags, err = s.arc.TagNameMap(c, tagIds); err != nil {
			log.Error("s.arc.TagNameMap(%v) error(%v)", tagIds, err)
			err = nil
		}
		log.Info("s.arc.TagNameMap(%v) result(%v)", tagIds, tags)
	}(&tags)
	//获取数据库中的稿件状态
	wg.Add(1)
	go func(aStates *map[int64]int) {
		defer wg.Done()
		if *aStates, err = s.arc.ArcStateMap(c, aids); err != nil {
			log.Error("s.arc.ArcStateMap(%v) error(%v)", aids, err)
			err = nil
		}
	}(&aStates)
	//获取数据库中视频的状态
	wg.Add(1)
	go func(vStates *map[int64]int) {
		defer wg.Done()
		if *vStates, err = s.arc.VideoStateMap(c, vids); err != nil {
			log.Error("s.arc.VideoStateMap(%v) error(%v)", vids, err)
			err = nil
		}
	}(&vStates)
	//获取UP主信息
	wg.Add(1)
	go func(members *map[int64]*accApi.Info) {
		defer wg.Done()
		var infosReply *accApi.InfosReply
		if infosReply, err = s.accRPC.Infos3(c, &accApi.MidsReq{Mids: mids}); err != nil {
			log.Error("s.accRPC.Infos3(%v) error(%v)", mids, err)
			err = nil
			return
		}
		*members = infosReply.Infos
	}(&members)

	wg.Wait()
	sInt, _ := strconv.Atoi(p.Status)
	for i := 0; i < len(result.Result); i++ {
		v := result.Result[i]
		result.Result[i].ID = v.Vid
		if vs, ok := vStates[v.Vid]; ok {
			result.Result[i].Status = vs
		}
		//需要将status与查询条件中status不一致的视频剔除
		if p.Status != "" && v.Status != sInt {
			result.Result = append(result.Result[:i], result.Result[i+1:]...)
			i--
			continue
		}
		if tn, ok := tags[v.TagID]; ok {
			result.Result[i].TagName = tn
		}
		if as, ok := aStates[v.Aid]; ok {
			result.Result[i].ArcState = as
		}
		if m, ok := members[v.ArcMid]; ok {
			result.Result[i].ArcAuthor = m.Name
		}
		if v.UserType == nil {
			v.UserType = []int64{}
		}
		if v.UserGroup == nil {
			v.UserGroup = []*manager.UpGroup{}
		}
		for _, tp := range v.UserType {
			if up, ok := s.allUpGroupCache[tp]; ok {
				result.Result[i].UserGroup = append(result.Result[i].UserGroup, up)
			}
		}
	}
	return
}

// SearchCopyright search video copyright
func (s *Service) SearchCopyright(c context.Context, kw string) (result *search.CopyrightResultData, err error) {
	return s.search.SearchCopyright(c, kw)
}

// SearchArchive 稿件搜索列表
func (s *Service) SearchArchive(c *bm.Context, p *search.ArchiveParams) (result *search.ArchiveResultData, err error) {
	var (
		round                                 int
		aids                                  []int64
		froms                                 []int8
		forbid                                string
		tids                                  []int64
		pn                                    = 1
		ps                                    = 30
		isMonitor                             bool          //是否查看监控列表
		moniMap                               map[int64]int //监控列表的视频id map。键：vid；值：time（进入监控的时间）
		nPGCAids, sPGCAids, cPGCAids, misAids []int64
		additMap                              map[int64]*archive.Addit
		tips                                  string
		orders                                = map[string]string{
			"mtime":     "",
			"pubtime":   "",
			"ctime":     "",
			"dm_count":  "",
			"fav_count": "",
		}
		eReq *elastic.Request
	)
	es := elastic.NewElastic(nil)
	if p.OrderType != "" {
		eReq = es.NewRequest("archive_score")
	} else {
		eReq = es.NewRequest("archive")
	}
	eReq.Index("archive")
	if p.Ps != 0 {
		ps = p.Ps
	}
	if ps > 1000 {
		ps = 1000
	}
	//分区 逻辑
	if p.TypeID != "" {
		if tids, err = s.SplitInts(p.TypeID); err != nil {
			return
		}
		for _, tid := range tids {
			if ids, ok := s.typeCache2[int16(tid)]; ok {
				tids = append(tids, ids...)
			}
		}
	}
	//特殊分区逻辑
	if p.SpecialType != "" {
		for i := 0; i < len(tids); i++ { //剔除特殊/普通分区id
			_, ok := s.adtTpsCache[int16(tids[i])]
			if (ok && p.SpecialType == "0") || (!ok && p.SpecialType == "1") {
				tids = append(tids, tids...)
				i--
				continue
			}
		}
	}
	if len(tids) > 0 {
		eReq.WhereIn("typeid", tids)
		if len(tids) > ps {
			ps = len(tids)
		}
	}

	if p.UserType != "" && p.UserType != "0" {
		eReq.WhereEq("user_type", p.UserType)
	}
	//up_from 逻辑
	if p.UpFroms != "" {
		var upFroms []int64
		if upFroms, err = s.SplitInts(p.UpFroms); err != nil {
			return
		}
		eReq.WhereIn("up_from", upFroms)
	} else { //默认去除PGC稿件
		eReq.WhereIn("up_from", []int8{archive.UpFromPGC, archive.UpFromSecretPGC, archive.UpFromCoopera})
		eReq.WhereNot(elastic.NotTypeIn, "up_from")
	}
	//Round 逻辑
	if p.Round != "" {
		if round, err = strconv.Atoi(p.Round); err != nil {
			log.Warn("http.searchArchive() http.PGCListLogic() err(%v)", err)
			return
		}
		if round == 1 {
			eReq.WhereIn("round", []int8{1, archive.RoundReviewSecond})
		} else if round == 2 {
			eReq.WhereIn("round", []int8{2, archive.RoundEnd})
		} else {
			eReq.WhereIn("round", []int{round})
		}
	}
	//Aid 逻辑
	if p.Aids != "" {
		p.Aids = strings.Replace(p.Aids, "\n", ",", -1)
		p.Aids = strings.Join(Slice2String(SliceUnique(Slice2Interface(strings.Split(p.Aids, ",")))), ",")
		if aids, err = s.SplitInts(p.Aids); err != nil {
			return
		}
		eReq.WhereIn("id", aids)
	}
	//Mid 逻辑
	if p.Mids != "" {
		var mids []int64
		p.Mids = strings.Replace(p.Mids, "\n", ",", -1)
		if mids, err = s.SplitInts(p.Mids); err != nil {
			return
		}
		eReq.WhereIn("mid", mids)
		if len(mids) > ps {
			ps = len(mids)
		}
	}
	if p.State != "" {
		states := strings.Split(p.State, ",")
		eReq.WhereIn("state", states)
	}
	if p.Access != "" {
		eReq.WhereEq("access", p.Access)
	}
	if p.Copyright != "" {
		eReq.WhereEq("copyright", p.Copyright)
	}
	if p.IsFirst != "" {
		eReq.WhereEq("is_first", p.IsFirst)
	}

	//PGC 列表逻辑
	if p.PGCList != "" {
		if err = s.PGCListLogic(c, p.PGCList, p.State, froms, eReq); err != nil {
			return
		}
		if c.IsAborted() { //检查鉴权
			return
		}
	}

	//搜索关键字逻辑
	if p.Keywords != "" {
		fields := []string{"title", "content", "tag"}
		if p.KwFields != "" {
			fields = strings.Split(p.KwFields, ",")
			for i := 0; i < len(fields); i++ {
				if fields[i] == "channel" {
					fields[i] = "tid_names"
					break
				}
			}
		}
		eReq.WhereLike(fields, []string{p.Keywords}, true, elastic.LikeLevelLow)
	}
	if p.NoMission == "" { //默认去掉活动稿件
		p.NoMission = "1"
	}
	//禁止项逻辑
	if p.Attr == strconv.Itoa(archive.ForbidAttrChannel) {
		forbid = "channel"
		eReq.WhereEq("channel_group_id", archive.FlowGroupNoChannel)
		eReq.WhereEq("channel_pool", archive.PoolArcForbid)
		eReq.WhereEq("channel_state", archive.FlowOpen)
	} else if p.Attr == strconv.Itoa(archive.ForbidAttrHot) {
		forbid = "hot"
		eReq.WhereEq("hot_group_id", archive.FlowGroupNoHot)
		eReq.WhereEq("hot_pool", archive.PoolArcForbid)
		eReq.WhereEq("hot_state", archive.FlowOpen)
	} else if p.Attr != "" {
		attr := 0
		attr, err = strconv.Atoi(p.Attr)
		if err != nil {
			return
		}
		if (uint(attr-1) == archive.AttrBitIsPorder) && int8(round) != archive.RoundReviewFlow {
			s.auth.Permit("PRIVATE_ORDER_ALL")(c) //鉴权
			if c.IsAborted() {
				return
			}
			p.NoMission = "" //不做活动稿件剔除
		}
		eReq.WhereEq("attribute", attr)
	}

	//回查列表逻辑
	if p.Review != "" {
		if p.ReviewState == "" {
			p.ReviewState = strconv.Itoa(archive.RecheckStateWait)
		}
		switch p.Review {
		case strconv.Itoa(archive.TypeChannelRecheck):
			s.auth.Permit("CHANNEL_REVIEW")(c)
			eReq.WhereEq("recheck_ch_type", p.Review)
			eReq.WhereEq("recheck_ch_staten", p.ReviewState)
		case strconv.Itoa(archive.TypeHotRecheck):
			p.NoMission = ""
			s.auth.Permit("ARC_HOT_REVIEW")(c)
			eReq.WhereEq("recheck_hot_type", p.Review)
			eReq.WhereEq("recheck_hot_staten", p.ReviewState)

		case strconv.Itoa(archive.TypeInspireRecheck):
			p.NoMission = ""
			s.auth.Permit("ARC_INSPIRE_REVIEW")(c)
			eReq.WhereEq("recheck_inspire_type", p.Review)
			eReq.WhereEq("recheck_inspire_staten", p.ReviewState)
		}
		if c.IsAborted() {
			return
		}
		p.IsOrder = 0
	} else if p.Round == strconv.Itoa(int(archive.RoundAuditUGCPayFlow)) { //付费列表需要展示活动稿件
		p.NoMission = ""
	}
	//活动逻辑
	if p.MissionID != "" {
		eReq.WhereEq("mission_id", p.MissionID)
	}
	if p.MissionID != "" || p.NoMission == "0" { //需要活动稿件
		eReq.WhereRange("mission_id", 1, nil, elastic.RangeScopeLcRo)
	} else if p.NoMission == "1" { //不需要活动稿件
		eReq.WhereRange("mission_id", 0, nil, elastic.RangeScopeLoRo)
		eReq.WhereNot(elastic.NotTypeRange, "mission_id")
	}
	//商单逻辑
	if p.IsOrder == 1 { //商单 order_id 大于0
		eReq.WhereRange("order_id", 0, nil, elastic.RangeScopeLoRo)
		if p.OrderId != "" {
			eReq.WhereEq("order_id", p.OrderId)
		}
	} else if forbid == "" && p.Review == "" { //除了禁止列表和回查列表，都要去除商单order_id <= 0
		eReq.WhereRange("order_id", 0, nil, elastic.RangeScopeLoRo)
		eReq.WhereNot(elastic.NotTypeRange, "order_id")
	}

	//监控结果列表逻辑
	if p.MonitorList != "" {
		eReq = es.NewRequest("archive_score") //去掉其它条件
		eReq.Index("archive")
		isMonitor = true
		var (
			rid int
		)
		moniP := strings.Split(p.MonitorList, "_")
		if len(moniP) != 3 {
			err = errors.New("监控列表标识字段格式错误")
			return
		}
		if rid, err = strconv.Atoi(moniP[2]); err != nil {
			return
		}
		if moniMap, err = s.MonitorStayOids(c, int64(rid)); err != nil {
			return
		}
		for aid := range moniMap {
			aids = append(aids, aid)
		}
		if len(aids) == 0 {
			result = &search.ArchiveResultData{
				Result: []*search.Archive{},
			}
			return
		}
		/*if len(aids) > ps {
			ps = len(aids)
		}*/
		eReq.WhereIn("id", aids)
	}
	//分页、排序
	if p.Pn > 0 {
		pn = p.Pn
	}
	if _, ok := orders[p.Order]; !ok {
		p.Order = "ctime"
	}
	if p.Order == "" {
		p.Order = "ctime"
	}
	eReq.OrderScoreFirst(p.ScoreFirst != "0")

	if p.Sort == "" {
		p.Sort = "desc"
	}
	eReq.Order(p.Order, p.Sort)
	eReq.Pn(pn)
	eReq.Ps(ps)
	log.Info("SearchArchiveQuery(%s)", eReq.Params())
	if err = eReq.Scan(c, &result); err != nil {
		log.Error("SearchArchiveQuery() error(%v)", err)
		return
	}
	if isMonitor {
		result.MoniAids = moniMap
	}
	if len(aids) > 0 && !isMonitor {
		//获取稿件addit
		if additMap, err = s.arc.AdditBatch(c, aids); err != nil {
			log.Error("s.arc.AdditBatch(%v) error(%v) additMap(%v)", aids, err, additMap)
			err = nil
		}
		for _, v := range aids {
			if _, ok := additMap[v]; ok {
				switch additMap[v].UpFrom {
				case archive.UpFromPGC:
					nPGCAids = append(nPGCAids, v)
				case archive.UpFromSecretPGC:
					sPGCAids = append(sPGCAids, v)
				case archive.UpFromCoopera:
					cPGCAids = append(cPGCAids, v)
				}
				if additMap[v].MissionID > 0 {
					misAids = append(misAids, v)
				}
			}
		}

		if len(nPGCAids) > 0 {
			tips += "PGC稿件：" + xstr.JoinInts(nPGCAids)
		}
		if len(sPGCAids) > 0 {
			tips += "PGC机密：" + xstr.JoinInts(sPGCAids)
		}
		if len(cPGCAids) > 0 {
			tips += "PGC嵌套：" + xstr.JoinInts(cPGCAids)
		}
		if len(misAids) > 0 {
			tips += "活动稿件：" + xstr.JoinInts(misAids)
		}

		result.Tips = tips
	}
	if err = s.KneadArchiveResult(c, result, p, additMap); err != nil {
		return
	}
	return
}

// PGCListLogic PGC列表查询相关逻辑
func (s *Service) PGCListLogic(c *bm.Context, lnStr string, pState string, froms []int8, eReq *elastic.Request) (err error) {
	var (
		state     int ////临时存储PGC列表中查询的state状态，需要和pState字符串配合使用！
		lni       int
		ln        int8
		pgcConfig map[int8]*search.ArcPGCConfig
	)

	if lni, err = strconv.Atoi(lnStr); err != nil {
		log.Warn("s.PGCListLogic() err(%v)", err)
		return
	}
	ln = int8(lni)
	if state, err = strconv.Atoi(pState); err != nil {
		err = errors.New("PGC列表中的state参数错误")
		return
	}
	if len(froms) != 0 {
		for _, v := range froms {
			if v != archive.UpFromPGC && v != archive.UpFromSecretPGC && v != archive.UpFromCoopera {
				err = errors.New("PGC列表中的from参数错误")
				break
			}
		}
	}
	pgcConfig = make(map[int8]*search.ArcPGCConfig)

	//PGC常规二审列表   round=10 state=-1,-30,-40,-6 upfrom=1
	pgcConfig[1] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromPGC},
		Rounds: []int8{
			archive.RoundBegin,
			archive.RoundAuditSecond,
		},
		States: []int8{
			archive.RecheckStateWait,
			archive.StateForbidSubmit,
			archive.StateForbidUserDelay,
			archive.StateForbidFixed,
		},
		InState: pState != "" && state < 0,
		Auth:    "PGC_NORMAL_2",
	}
	//PGC常规三审列表   round=20 state=-1,-30,-40,-6 upfrom=1
	pgcConfig[2] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromPGC},
		Rounds: []int8{archive.RoundAuditThird},
		States: []int8{
			archive.RecheckStateWait,
			archive.StateForbidSubmit,
			archive.StateForbidUserDelay,
			archive.StateForbidFixed,
		},
		InState: pState != "" && state < 0,
		Auth:    "PGC_NORMAL_3",
	}
	//PGC机密待审列表   state=-1,-30,-40,-6 upfrom=5
	pgcConfig[3] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromSecretPGC},
		Rounds: []int8{},
		States: []int8{
			archive.RecheckStateWait,
			archive.StateForbidSubmit,
			archive.StateForbidUserDelay,
			archive.StateForbidFixed,
		},
		InState: pState != "" && state < 0,
		Auth:    "PGC_SECRET_WAIT",
	}
	//PGC机密回查列表   round=90 state≥0 upfrom=5
	pgcConfig[4] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromSecretPGC},
		Rounds: []int8{archive.RoundTriggerClick},
		States: []int8{
			archive.StateOpen,
			archive.StateOrange,
		},
		InState: pState != "" && state >= 0,
		Auth:    "PGC_SECRET_RECHECK",
	}

	//PGC全部已过审 round=99 state≥0 upfrom=1,5,6
	pgcConfig[5] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromPGC, archive.UpFromSecretPGC, archive.UpFromCoopera},
		Rounds: []int8{archive.RoundEnd},
		States: []int8{
			archive.StateOpen,
			archive.StateOrange,
		},
		InState: pState != "" && state >= 0,
		Auth:    "PGC_OPEN",
	}

	//全部打回列表    state=-2,-3,-4,-7,-11,-16,-100 up_from=1,5,6
	pgcConfig[6] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromPGC, archive.UpFromSecretPGC, archive.UpFromCoopera},
		Rounds: []int8{},
		States: []int8{
			archive.StateForbidRecycle,
			archive.StateForbidPolice,
			archive.StateForbidLock,
			archive.StateForbidLater,
			archive.StateForbidFixing,
			archive.StateForbidXcodeFail,
			archive.StateForbidUpDelete,
		},
		InState: pState != "" && state < 0,
		Auth:    "PGC_RECICLE",
	}

	//合作方嵌套列表   state=-1,-30,-6,-40  up_from=6
	pgcConfig[7] = &search.ArcPGCConfig{
		UPFrom: []int8{archive.UpFromCoopera},
		Rounds: []int8{},
		States: []int8{
			archive.StateForbidWait,
			archive.StateForbidSubmit,
			archive.StateForbidFixed,
			archive.StateForbidUserDelay,
		},
		InState: pState != "" && state < 0,
		Auth:    "PGC_PARTNER",
	}
	if _, ok := pgcConfig[ln]; !ok || pgcConfig[ln] == nil {
		err = errors.New("PGC列表不存在")
		return
	}
	if !pgcConfig[ln].InState { //如果前端传了合法的state，则加上state条件
		pgcConfig[ln].States = []int8{int8(state)}
	}
	if len(froms) != 0 { //如果前端传了up_from，则加上up_from条件
		pgcConfig[ln].UPFrom = froms
	}
	if len(pgcConfig[ln].UPFrom) == 0 {
		err = errors.New("PGC列表中的UPFrom不能设置为空")
		return
	}
	s.auth.Permit(pgcConfig[ln].Auth)(c) //鉴权
	eReq.WhereIn("up_from", pgcConfig[ln].UPFrom)
	eReq.WhereIn("state", pgcConfig[ln].States)
	eReq.WhereIn("round", pgcConfig[ln].Rounds)
	return
}

// KneadArchiveResult 拼接稿件数据
func (s *Service) KneadArchiveResult(c *bm.Context, result *search.ArchiveResultData, p *search.ArchiveParams, additMap map[int64]*archive.Addit) (err error) {
	var (
		mids, aids []int64
		ups        map[int64]*accApi.Card
		rStates    map[int64]int8
		chNames    map[int64][]string
		archives   = result.Result
		dbArchives map[int64]*archive.Archive
		wg         sync.WaitGroup
	)
	for _, v := range archives {
		if v.Mid != 0 {
			mids = append(mids, v.Mid)
		}
		aids = append(aids, v.ID)
	}

	//获取频道信息
	wg.Add(1)
	go func(chNames *map[int64][]string) {
		defer wg.Done()
		*chNames = s.ChannelNamesByAids(c, aids)
	}(&chNames)

	wg.Add(1)
	go func(dbArchives *map[int64]*archive.Archive) {
		defer wg.Done()
		if *dbArchives, err = s.arc.Archives(c, aids); err != nil || dbArchives == nil {
			log.Error("s.arc.Archives(%v) error(%v) archives(%v)", mids, err, dbArchives)
			err = nil
		}
	}(&dbArchives)

	//获取UP主信息
	wg.Add(1)
	go func(ups *map[int64]*accApi.Card) {
		defer wg.Done()
		if *ups, err = s.upCards(c, mids); err != nil || ups == nil {
			log.Error("s.upCards(%v) error(%v) ups(%v)", mids, err, ups)
			err = nil
			*ups = make(map[int64]*accApi.Card)
		}
	}(&ups)
	//获取回查稿件实时状态
	if p.Review != "" && p.ReviewState != "" {
		wg.Add(1)
		go func(rStates *map[int64]int8) {
			defer wg.Done()
			tp, _ := strconv.Atoi(p.Review)
			if *rStates, err = s.arc.RecheckStateMap(c, tp, aids); err != nil || rStates == nil {
				log.Error("s.arc.RecheckStateMap(%v,%v) error(%v) rStates(%v)", tp, aids, err, rStates)
				err = nil
			}
		}(&rStates)
	}

	wg.Wait()
	for i := 0; i < len(archives); i++ {
		v := archives[i]
		if a, ok := dbArchives[v.ID]; ok && a.Cover != "" {
			archives[i].Cover = coverURL(a.Cover)
		}
		if m, ok := ups[v.Mid]; ok {
			archives[i].Official = m.Official
			archives[i].Author = m.Name
		}
		if p.Review != "" && p.ReviewState != "" {
			if state, ok := rStates[v.ID]; ok { //将与查询条件中回查状态不一致的稿件剔除
				rState, err := strconv.Atoi(p.ReviewState)
				if err != nil {
					log.Error("s.KneadArchive() error(%v) reviewState(%v)", err, p.ReviewState)
					err = nil
					continue
				}
				if state != int8(rState) {
					archives = append(archives[:i], archives[i+1:]...)
					i--
					continue
				}
			}
		}
		if _, ok := additMap[v.ID]; ok {
			archives[i].UpFrom = additMap[v.ID].UpFrom
			if additMap[v.ID].MissionID > 0 {
				archives[i].MissionID = additMap[v.ID].MissionID
			}
		}
		if names, ok := chNames[v.ID]; ok {
			archives[i].TagNames = names
		}
		if archives[i].TagNames == nil {
			archives[i].TagNames = []string{}
		}
		if archives[i].UserType == nil {
			archives[i].UserType = []int64{}
		}
		if v.UserGroup == nil {
			v.UserGroup = []*manager.UpGroup2{}
		}
		if v.Attribute == nil {
			v.Attribute = []int{}
		}
		v.Attrs = v.Attribute
		for _, tp := range v.UserType {
			if up, ok := s.allUpGroupCache[tp]; ok {
				//因为前端希望稿件列表返回的up_group与任务质检结构一致，所以在这做一次转换
				gp := &manager.UpGroup2{
					GroupID:   up.ID,
					GroupName: up.Name,
					GroupTag:  up.ShortTag,
				}
				result.Result[i].UserGroup = append(result.Result[i].UserGroup, gp)
			}
		}
	}
	result.Result = archives
	return
}