package archive

import (
	"context"
	"encoding/json"
	"fmt"
	"go-common/app/interface/main/creative/model/activity"
	"go-common/app/interface/main/creative/model/appeal"
	"go-common/app/interface/main/creative/model/archive"
	"go-common/app/interface/main/creative/model/search"
	"go-common/app/interface/main/creative/model/tag"
	pubSvc "go-common/app/interface/main/creative/service"
	"go-common/app/service/main/archive/api"
	mdlarc "go-common/app/service/main/archive/model/archive"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/sync/errgroup"
	xtime "go-common/library/time"
	"strings"
	"time"
)

// SimpleArchiveVideos fn
func (s *Service) SimpleArchiveVideos(c context.Context, mid, aid int64, ak, ck, ip string) (ap *archive.SimpleArchiveVideos, err error) {
	var (
		sa  *archive.SpArchive
		svs []*archive.SpVideo
	)
	// User identity && permission check, logic from project 'member'
	card, err := s.acc.Card(c, mid, ip)
	if err != nil {
		log.Error("s.acc.Profile(%d,%s) error(%v)", mid, ck, err)
		return
	}
	if sa, err = s.arc.SimpleArchive(c, aid, ip); err != nil {
		log.Error("s.arc.SimpleArchive(%d) error(%v)", aid, err)
		return
	}
	if sa == nil {
		log.Error("s.arc.SimpleArchive(%d) not found", aid)
		err = ecode.NothingFound
		return
	}
	if sa.Mid != mid {
		err = ecode.NothingFound
		return
	}
	if svs, err = s.arc.SimpleVideos(c, aid, ip); err != nil {
		log.Error("s.arc.SimpleVideos(%d) error(%v)", aid, err)
		return
	}
	for index, sv := range svs {
		if sv.Status == -100 {
			sv.DmActive = 0
		} else {
			sv.DmActive = 1
		}
		svs[index] = sv
	}
	acceptAss := card.Rank > 15000 || card.Rank == 20000
	ap = &archive.SimpleArchiveVideos{Archive: sa, SpVideos: svs, AcceptAss: acceptAss}
	return
}

// View get archive.
func (s *Service) View(c context.Context, mid, aid int64, ip, platform string) (av *archive.ArcVideo, err error) {
	if av, err = s.arc.View(c, mid, aid, ip, archive.NeedPoi(platform), archive.NeedVote(platform)); err != nil {
		log.Error("s.arc.View(%d,%d) error(%v)", mid, aid, err)
		return
	}
	if av == nil || av.Archive == nil {
		log.Error("s.arc.View(%d) not found", mid)
		err = ecode.NothingFound
		return
	}
	av.Archive.NilPoiObj(platform)
	av.Archive.NilVote()
	// check white
	isWhite := false
	for _, m := range s.c.Whitelist.ArcMids {
		if m == mid {
			isWhite = true
			break
		}
	}
	if !isWhite {
		if av.Archive.Mid != mid {
			err = ecode.AccessDenied
			return
		}
	}
	var (
		a  = av.Archive
		vs = av.Videos
	)
	// add reject reason
	if (a.State == mdlarc.StateForbidRecicle || a.State == mdlarc.StateForbidLock) && a.RejectReason == "" {
		var c = 0
		for _, v := range vs {
			if v.Status == mdlarc.StateForbidRecicle ||
				v.Status == mdlarc.StateForbidLock ||
				v.Status == mdlarc.StateForbidXcodeFail {
				c++
			}
		}
		a.RejectReason = fmt.Sprintf("稿件中发现%d个问题。", c)
	}
	a.Cover = pubSvc.CoverURL(a.Cover)
	if a.OrderID != 0 {
		if a.OrderID, a.OrderName, _, err = s.order.OrderByAid(c, aid); err != nil {
			log.Error("s.order.OrderByAid(%d,%d) error(%v)", mid, aid, err)
			err = nil
		}
	}
	if a.MissionID > 0 {
		var act *activity.Activity
		if act, err = s.act.Subject(c, a.MissionID); err != nil {
			log.Error("s.act.Subject a.MissionID(%d) error(%v)", a.MissionID, err)
			err = nil
			return
		}
		a.MissionName = act.Name
	}
	if a.Porder != nil && a.Porder.Official == 1 && a.Porder.IndustryID == 1 {
		if v, ok := s.gameMap[a.Porder.BrandID]; ok {
			a.Porder.BrandName = v.GameName
		}
	}
	if a.UgcPay == 1 {
		a.UgcPayInfo = s.p.FillPayInfo(c, a, s.c.UgcPay, ip)
	}
	return
}

// Del fn
// 1,unbind act;2,decrease coin;3,unbind order;4,clean memcache
func (s *Service) Del(c context.Context, mid, aid int64, ip string) (err error) {
	av, err := s.View(c, mid, aid, ip, archive.PlatformWeb)
	if err != nil {
		return
	}
	if av == nil || av.Archive == nil {
		log.Error("s.arc.Del NothingFound (%d,%d,%d) error(%v)", mid, av.Archive.Mid, aid, err)
		err = ecode.NothingFound
		return
	}
	if av.Archive.Mid != mid {
		log.Error("s.arc.Del AccessDenied (%d,%d,%d) error(%v)", mid, av.Archive.Mid, aid, err)
		err = ecode.AccessDenied
		return
	}
	if av.Archive.UgcPay == 1 {
		canDelTime := xtime.Time(av.Archive.PTime.Time().AddDate(0, 0, s.c.UgcPay.AllowDeleteDays).Unix())
		if av.Archive.CTime != av.Archive.PTime && xtime.Time(time.Now().Unix()) < canDelTime {
			log.Error("checkEditPay CreativePayForbidDeleteAfterOpen aid(%d) ctime(%v) ptime(%v)", av.Archive.Aid, av.Archive.CTime, av.Archive.PTime)
			err = ecode.CreativePayForbidDeleteAfterOpen
			return
		}
	}
	if err = s.arc.Del(c, mid, aid, ip); err != nil {
		log.Error("s.arc.Del(%d,%d) error(%v)", mid, aid, err)
		return
	}
	var (
		a   = av.Archive
		g   = &errgroup.Group{}
		ctx = context.TODO()
	)
	g.Go(func() error {
		if e := s.act.Unbind(ctx, aid, a.MissionID, ip); e != nil {
			log.Error("s.act.UpdateByAid(%d,%d) error(%v)", aid, a.MissionID, e)
		}
		return nil
	})
	g.Go(func() error {
		var coins float64
		if a.State >= 0 {
			coins = -2
		} else {
			coins = -1
		}
		if e := s.coin.AddCoin(ctx, mid, aid, coins, ip); e != nil {
			log.Error("s.coin.AddCoin(%d,%d,%f,%s) error(%v)", mid, aid, coins, ip, e)
		}
		return nil
	})
	g.Go(func() error {
		if e := s.order.Unbind(ctx, mid, aid, ip); e != nil {
			log.Error("s.order.Unbind(%d,%d,%s) error(%v)", mid, aid, ip, e)
		}
		return nil
	})
	g.Go(func() error {
		if e := s.arc.DelSubmitCache(ctx, mid, a.Title); e != nil {
			log.Error("s.arc.DelSubmitCache (%d,%s,%s) error(%v)", mid, a.Title, ip, e)
		}
		return nil
	})
	g.Wait()
	s.prom.Incr("archive_del")
	return
}

// Archives for app all achives.
func (s *Service) Archives(c context.Context, mid int64, tid int16, kw, order, class, ip string, pn, ps, coop int) (res *search.Result, err error) {
	if res, err = s.Search(c, mid, tid, kw, order, class, ip, pn, ps, coop); err != nil {
		log.Error("s.Search err(%v)", err)
		return
	}
	if res == nil || res.Archives == nil || len(res.Archives) == 0 {
		return
	}
	for _, av := range res.Archives {
		a := &api.Arc{
			Aid:       av.Archive.Aid,
			TypeID:    int32(av.Archive.TypeID),
			TypeName:  av.TypeName,
			Copyright: int32(av.Archive.Copyright),
			Title:     av.Archive.Title,
			Desc:      av.Archive.Desc,
			Attribute: av.Archive.Attribute,
			Videos:    int64(len(av.Videos)),
			Pic:       pubSvc.CoverURL(av.Archive.Cover),
			State:     int32(av.Archive.State),
			Access:    int32(av.Archive.Access),
			Tags:      strings.Split(av.Archive.Tag, ","),
			Duration:  av.Archive.Duration,
			MissionID: av.Archive.MissionID,
			OrderID:   av.Archive.OrderID,
			PubDate:   av.Archive.PTime,
			Ctime:     av.Archive.CTime,
		}
		a.Author = api.Author{
			Mid:  av.Archive.Mid,
			Name: av.Archive.Author,
		}
		a.Stat = api.Stat{
			Aid:     av.Stat.Aid,
			View:    int32(av.Stat.View),
			Danmaku: int32(av.Stat.Danmaku),
			Reply:   int32(av.Stat.Reply),
			Fav:     int32(av.Stat.Fav),
			Coin:    int32(av.Stat.Coin),
			Share:   int32(av.Stat.Share),
			NowRank: int32(av.Stat.NowRank),
			HisRank: int32(av.Stat.HisRank),
		}
		ava := &archive.OldArchiveVideoAudit{
			Arc:         a,
			StatePanel:  av.StatePanel,
			ParentTName: av.ParentTName,
			Dtime:       av.Archive.DTime,
			StateDesc:   av.Archive.StateDesc,
			RejectReson: av.Archive.RejectReason,
			UgcPay:      av.Archive.UgcPay,
			Attrs:       av.Archive.Attrs,
		}
		if len(av.ArcVideo.Videos) > 0 {
			var vas = make([]*archive.OldVideoAudit, 0, len(av.ArcVideo.Videos))
			for _, vd := range av.ArcVideo.Videos {
				va := &archive.OldVideoAudit{
					IndexOrder: vd.Index,
					Eptitle:    vd.Title,
					Reason:     vd.RejectReason,
				}
				ava.VideoAudits = append(vas, va)
			}
		}
		res.OldArchives = append(res.OldArchives, ava)
	}
	return
}

// Search all achive.
func (s *Service) Search(c context.Context, mid int64, tid int16, keyword, order, class, ip string, pn, ps, coop int) (res *search.Result, err error) {
	defer func() {
		if res != nil {
			// get pending apply num
			if coop > 0 {
				count, _ := s.arc.CountByMID(c, mid)
				res.Applies = &search.ApplyStateCount{
					Pending: count,
				}
			}
		}
	}()
	if res, err = s.sear.ArchivesES(c, mid, tid, keyword, order, class, ip, pn, ps, coop); err != nil {
		// search err, use archive-service
		log.Error("s.arc.Search(%d) error(%v)", mid, err)
		res, err = s.ArchivesFromService(c, mid, class, ip, pn, ps)
		if err != nil {
			return
		}
	}
	// add arctype  *must return
	res.ArrType = []*search.TypeCount{}
	for _, v := range s.p.TopTypesCache {
		t := &search.TypeCount{
			Tid:  v.ID,
			Name: v.Name,
		}
		if _, ok := res.Type[v.ID]; ok {
			t.Count = res.Type[v.ID].Count
		}
		res.ArrType = append(res.ArrType, t)
	}
	if res == nil || len(res.Aids) == 0 {
		return
	}
	avm, err := s.arc.Views(c, mid, res.Aids, ip)
	if err != nil {
		log.Error("s.arc.Views res.Aids(%v), ip(%s) err(%v)", res.Aids, ip, err)
		return
	}
	// get arc stats
	as, _ := s.arc.Stats(c, res.Aids, ip)
	// archives
	for _, aid := range res.Aids {
		av := avm[aid]
		if av == nil {
			continue
		}
		a := av.Archive
		a.Cover = pubSvc.CoverURL(a.Cover)
		ava := &archive.ArcVideoAudit{ArcVideo: av}
		// arc stat info
		if _, ok := as[aid]; ok {
			ava.Stat = as[aid]
		} else {
			ava.Stat = &api.Stat{}
		}
		// typename
		if _, ok := s.p.TypeMapCache[a.TypeID]; ok {
			ava.TypeName = s.p.TypeMapCache[a.TypeID].Name
		}
		// parent typename
		if _, ok := s.p.TypeMapCache[a.TypeID]; ok {
			if _, ok := s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent]; ok {
				ava.ParentTName = s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent].Name
			}
		}
		// state panel
		ava.StatePanel = archive.StatePanel(a.State)
		// state desc
		ava.Archive.StateDesc = s.c.StatDesc(int(a.State))
		// not pubbed videos for reason
		unpubedVideos := make([]*archive.Video, 0, len(ava.Videos))
		for _, v := range ava.Videos {
			if v.Status == -2 || v.Status == -4 || v.Status == -16 {
				unpubedVideos = append(unpubedVideos, v)
			}
		}
		c := len(unpubedVideos)
		if c > 0 {
			a.RejectReason = fmt.Sprintf("稿件中发现%d个问题。", c)
		}
		// set attrs
		attrs := &archive.Attrs{
			IsCoop:  int8(ava.AttrVal(archive.AttrBitIsCoop)),
			IsOwner: ava.IsOwner(mid),
		}
		ava.Archive.Attrs = attrs
		ava.Videos = unpubedVideos
		res.Archives = append(res.Archives, ava)
	}
	return
}

// ApplySearch all achive.
func (s *Service) ApplySearch(c context.Context, mid int64, tid int16, keyword, state string, pn, ps int) (res *search.StaffApplyResult, err error) {
	var mids []int64
	if res, err = s.sear.ArchivesStaffES(c, mid, tid, keyword, state, pn, ps); err != nil {
		log.Error("s.arc.ArchivesStaffES(%d) error(%v)", mid, err)
		return
	}
	// add arctype  *must return
	res.ArrType = []*search.TypeCount{}
	for _, v := range s.p.TopTypesCache {
		t := &search.TypeCount{
			Tid:  v.ID,
			Name: v.Name,
		}
		if _, ok := res.Type[v.ID]; ok {
			t.Count = res.Type[v.ID].Count
		}
		res.ArrType = append(res.ArrType, t)
	}
	if res == nil || len(res.Aids) == 0 {
		return
	}
	// get archives
	avm, err := s.arc.Views(c, mid, res.Aids, "")
	if err != nil {
		log.Error("s.arc.Views res.Aids(%v), ip(%s) err(%v)", res.Aids, err)
		return
	}
	// get applies
	apm := make(map[int64]*archive.StaffApply)
	applies, err := s.arc.StaffApplies(c, mid, res.Aids)
	for _, ap := range applies {
		apm[ap.ApplyAID] = ap
	}
	// combine
	for _, aid := range res.Aids {
		av := avm[aid]
		if av == nil {
			continue
		}
		a := av.Archive
		a.Cover = pubSvc.CoverURL(a.Cover)
		ava := &archive.ArcVideoAudit{ArcVideo: av}
		// typename
		if _, ok := s.p.TypeMapCache[a.TypeID]; ok {
			ava.TypeName = s.p.TypeMapCache[a.TypeID].Name
		}
		// parent typename
		if _, ok := s.p.TypeMapCache[a.TypeID]; ok {
			if _, ok := s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent]; ok {
				ava.ParentTName = s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent].Name
			}
		}
		// state panel
		ava.StatePanel = archive.StatePanel(a.State)
		// state desc
		ava.Archive.StateDesc = s.c.StatDesc(int(a.State))
		// not pubbed videos for reason
		unpubedVideos := make([]*archive.Video, 0, len(ava.Videos))
		for _, v := range ava.Videos {
			if v.Status == -2 || v.Status == -4 || v.Status == -16 {
				unpubedVideos = append(unpubedVideos, v)
			}
		}
		c := len(unpubedVideos)
		if c > 0 {
			a.RejectReason = fmt.Sprintf("稿件中发现%d个问题。", c)
		}
		ava.Videos = unpubedVideos
		// get apply
		apply := &search.StaffApply{}
		if v, ok := apm[aid]; ok {
			apply.ID = v.ID
			apply.Type = v.Type
			apply.Mid = v.ApplyUpMID
			apply.State = v.StaffState
			apply.ApplyState = v.State
			apply.ApplyTitle = v.ApplyTitle
		}
		// set archive
		apply.Archive = ava
		mids = append(mids, apply.Mid)
		res.Applies = append(res.Applies, apply)
	}
	// get name
	users, _ := s.acc.Infos(c, mids, "")
	for _, v := range res.Applies {
		if u, ok := users[v.Mid]; ok {
			v.Uname = u.Name
		}
	}
	return
}

// Types get typelist.
func (s *Service) Types(c context.Context, lang string) (tps []*archive.Type) {
	if _, ok := s.p.TypesCache[lang]; !ok {
		lang = "ch"
	}
	tps = s.p.TypesCache[lang]
	return
}

// StaffTitles get staff titles.
func (s *Service) StaffTitles(c context.Context) (titles []*tag.StaffTitle) {
	return s.p.StaffTitlesCache
}

// AppTypes fn
func (s *Service) AppTypes(c context.Context, lang string) (tps []*archive.Type) {
	if _, ok := s.p.CTypesCache[lang]; !ok {
		lang = "ch"
	}
	tps = s.p.CTypesCache[lang]
	for _, val := range tps {
		for _, child := range val.Children {
			child.Notice = child.AppNotice
		}
	}
	return
}

// Activities get activity list.
func (s *Service) Activities(c context.Context) (acts []*activity.Activity) {
	acts = s.p.ActVideoAllCache
	return
}

// WebArchives achive list with appeal.
func (s *Service) WebArchives(c context.Context, mid int64, tid int16, keyword, order, class, ip string, pn, ps, coop int) (res *search.Result, err error) {
	if res, err = s.Search(c, mid, tid, keyword, order, class, ip, pn, ps, coop); err != nil {
		log.Error("s.Search err(%v)", err)
		return
	}
	if res == nil || len(res.Aids) == 0 {
		return
	}
	//做降级
	aps, err := s.ap.AppealList(c, mid, appeal.Business, ip)
	if err != nil {
		log.Error("s.ap.AppealList error(%v)", err)
		err = nil
	}
	if len(aps) == 0 {
		return
	}
	aaMap := make(map[int64]int64, len(aps))
	for _, v := range aps {
		if appeal.IsOpen(v.BusinessState) {
			aaMap[v.Oid] = v.ID
		}
	}
	for _, v := range res.Archives {
		v.OpenAppeal = aaMap[v.Archive.Aid]
	}
	return
}

// Videos get Simple Archive and Videos Info.
func (s *Service) Videos(c context.Context, mid, aid int64, ip string) (sa archive.SimpleArchive, svs []*archive.SimpleVideo, err error) {
	var av *archive.ArcVideo
	if av, err = s.arc.View(c, mid, aid, ip, 0, 0); err != nil {
		log.Error("s.arc.View(%d,%d) error(%v)", mid, aid, err)
		return
	}
	if av == nil {
		log.Error("s.arc.View(%d) not found", mid)
		err = ecode.RequestErr
		return
	}
	// white list check
	isWhite := false
	for _, m := range s.c.Whitelist.DataMids {
		if m == mid {
			isWhite = true
			break
		}
	}
	var (
		a  = av.Archive
		vs = av.Videos
	)
	if !isWhite {
		if a.Mid != mid {
			err = ecode.AccessDenied
			return
		}
	}
	sa.Aid = a.Aid
	sa.Title = a.Title
	for _, v := range vs {
		svs = append(svs, &archive.SimpleVideo{
			Cid:   v.Cid,
			Title: v.Title,
			Index: v.Index,
		})
	}
	return
}

// ArchivesFromService get archives from service
func (s *Service) ArchivesFromService(c context.Context, mid int64, class, ip string, pn, ps int) (sres *search.Result, err error) {
	aids, count, err := s.arc.UpArchives(c, mid, int64(pn), int64(ps), 0, ip)
	if err != nil {
		return
	}
	sres = &search.Result{}
	sres.Aids = aids
	sres.Page.Pn = pn
	sres.Page.Ps = ps
	sres.Page.Count = int(count)
	return
}

// DescFormat get desc format
func (s *Service) DescFormat(c context.Context, typeid, copyright int64, langStr, ip string) (desc *archive.DescFormat, err error) {
	lang := archive.ToLang(langStr)
	desc, ok := s.p.DescFmtsCache[typeid][int8(copyright)][lang]
	if !ok {
		err = nil
	}
	if desc != nil {
		var Components []*struct {
			Name interface{}
		}
		if err = json.Unmarshal([]byte(desc.Components), &Components); err != nil || len(Components) == 0 {
			desc = nil
			err = nil
		}
	}
	return
}

// AppFormats for app portal list.
func (s *Service) AppFormats(c context.Context) (af []*archive.AppFormat, err error) {
	for _, f := range s.p.DescFmtsArrCache {
		format := &archive.AppFormat{ID: f.ID, Copyright: f.Copyright, TypeID: f.TypeID}
		af = append(af, format)
	}
	return
}

// Video get video by aid and cid
func (s *Service) Video(c context.Context, mid, aid, cid int64, ip string) (video *api.Page, err error) {
	if video, err = s.arc.Video(c, aid, cid, ip); err != nil {
		log.Error("s.arc.Video %d,%d,%s | err(%v)", aid, cid, ip, err)
	}
	return
}

// VideoJam get video traffic jam level from service
// level为0的时候，可以忽略错误处理，映射表里已经做了前端容错
func (s *Service) VideoJam(c context.Context, ip string) (j *archive.VideoJam, err error) {
	level, _ := s.arc.VideoJam(c, ip)
	if jam, ok := archive.VjInfo[level]; ok {
		j = jam
	} else {
		j = archive.VjInfo[0]
	}
	return
}

// DescFormatForApp get desc format length
func (s *Service) DescFormatForApp(c context.Context, typeid, copyright int64, langStr, ip string) (desc *archive.DescFormat, length int, err error) {
	var (
		descLengthMax = 2000
		descLengthMin = 250
		ok            bool
	)
	lang := archive.ToLang("")
	if desc, ok = s.p.DescFmtsCache[typeid][int8(copyright)][lang]; !ok {
		err = nil
	}
	if typeid == 0 {
		length = descLengthMin
	} else if desc != nil {
		length = descLengthMax
	} else {
		length = descLengthMin
	}
	return
}

// Dpub for app view.
func (s *Service) Dpub() (dpub *archive.Dpub) {
	now := time.Now()
	dpub = &archive.Dpub{
		Deftime:    xtime.Time(now.Add(time.Duration(14400) * time.Second).Unix()),
		DeftimeEnd: xtime.Time(now.Add(time.Duration(15*24) * time.Hour).Unix()),
		DeftimeMsg: ecode.String(ecode.VideoupDelayTimeErr.Error()).Message(),
	}
	return
}

// SimpleArcVideos fn
func (s *Service) SimpleArcVideos(c context.Context, mid int64, tid int16, kw, order, class, ip string, pn, ps, coop int) (res *search.SimpleResult, err error) {
	var sres *search.Result
	res = &search.SimpleResult{}
	if sres, err = s.sear.ArchivesES(c, mid, tid, kw, order, class, ip, pn, ps, coop); err != nil {
		log.Error("s.arc.Search mid(%d)|error(%v)", mid, err)
		sres, err = s.ArchivesFromService(c, mid, class, ip, pn, ps) // search err, use archive-service
		if err != nil {
			log.Error("s.ArchivesFromService mid(%d)|error(%v)", mid, err)
			return
		}
	}
	if sres == nil || len(sres.Aids) == 0 {
		return
	}
	res.Class = sres.Class
	res.Page = sres.Page
	avm, err := s.arc.Views(c, mid, sres.Aids, ip)
	if err != nil {
		log.Error("s.arc.Views mid(%d)|aids(%v)|ip(%s)|err(%v)", mid, sres.Aids, ip, err)
		return
	}
	savs := make([]*search.SimpleArcVideos, 0, len(avm))
	for _, aid := range sres.Aids {
		av, ok := avm[aid]
		if !ok || av == nil || av.Archive == nil {
			continue
		}
		vds := make([]*archive.SimpleVideo, 0, len(av.Videos))
		for _, v := range av.Videos {
			if v == nil {
				continue
			}
			vd := &archive.SimpleVideo{
				Cid:   v.Cid,
				Title: v.Title,
				Index: v.Index,
			}
			vds = append(vds, vd)
		}
		sav := &search.SimpleArcVideos{}
		sav.Archive = &archive.SimpleArchive{
			Aid:   av.Archive.Aid,
			Title: av.Archive.Title,
		}
		sav.Videos = vds
		savs = append(savs, sav)
	}
	res.ArchivesVideos = savs
	return
}