package updownloadser

import (
	"context"
	"errors"
	"mime"
	"net/http"
	"path/filepath"
	"runtime/debug"
	"strconv"
	"strings"
	"time"

	"91porn-server/common"
	"91porn-server/common/constant"
	"91porn-server/common/elastic"
	"91porn-server/common/httputil"
	"91porn-server/common/log"
	"91porn-server/common/stderr"
	"91porn-server/common/timeutil"
	v10 "91porn-server/common/v10"
	"91porn-server/models"
	"91porn-server/models/commod"
	"91porn-server/models/l/pullgmod"
	"91porn-server/models/v/fsuidmod"
	"91porn-server/models/v/idmod"
	"91porn-server/models/v/locmod"
	"91porn-server/models/v/tagmod"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/vidmod"
	"91porn-server/web/webg"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

var cities = []string{"上海", "北京", "深圳", "成都", "杭州", "重庆", "广州", "西安", "武汉"}

// 从server-file 查找用户信息
func SearchUserFromFS(id string) (respBody vidmod.PublishResport, err error) {
	var params = map[string]string{
		"uid": id,
	}
	code, err := httputil.DefaultClientGetWithResp(&respBody, webg.Conf.URL.SearchUserUrl, nil, params)
	log.Info("http method SearchUserFromFS response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("search user info  wrong ", log.E(err))
	}
	return
}

// SendVidCover2FS 传送图片
func SendVidCover2FS(id string, ext string, fileData string) (respBody commod.Resp, err error) {
	var params = map[string]string{
		"fileData": fileData,
		"ext":      ext,
	}
	code, err := httputil.DefaultClientPostJsonWithResp(&respBody, common.BindUrl(webg.Conf.URL.UploadImgUrl, id), nil, params)
	log.Info("http method SendVidCover2FS response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("file upload  wrong ", log.E(err))
	}
	return
}

// SendFile2FS 传送视频文件到FS
func SendFile2FS(fileID string, fileData string, pos int64, total int64) (respBody vidmod.AwsResport, err error) {
	var header = map[string]string{
		"Content-Type": "application/json",
	}
	var params = map[string]interface{}{
		"taskId":   fileID,
		"fileData": fileData,
		"pos":      pos,
		"totalPos": total,
		"type":     "sp",
	}
	c, cancle := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancle()
	code, err := httputil.DefaultClientPostJsonWithRespWithCtx(c, &respBody, webg.Conf.URL.UploadUrl, header, params)
	log.Info("http method SendFile2FS response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("file upload  wrong ", log.E(err))
		return
	}
	return
}

// SendImageToFS 传送图片
func SendImageToFS(fileName, fileData string) (respBody vidmod.FsSendSingleResp, err error) {
	var params = map[string]interface{}{
		"fileData": fileData,
		"fileName": fileName,
	}
	code, err := httputil.DefaultClientPostJsonWithResp(&respBody, webg.Conf.URL.SendSingleFile, nil, params)
	log.Info("http method SendImageToFS response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("file upload  wrong ", log.E(err))
	}
	return
}

type FileInfo struct {
	FileName *string `json:"fileName"` // 文件名称
	FileData *string `json:"fileData"` // 文件存储在那台服务器
	Resize   bool    `json:"resize"`
}

type InfoBatch struct {
	Batch []*FileInfo `json:"batch"` //Info array
}

// SendImageToFSBatch 传送图片
func SendImageToFSBatch(batch InfoBatch) (respBody vidmod.FsSendBatchResp, err error) {
	if len(batch.Batch) == 0 {
		err = errors.New("no file")
		return
	}
	c, cancle := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancle()
	code, err := httputil.DefaultClientPostJsonWithRespWithCtx(c, &respBody, webg.Conf.URL.SendBatchFile, nil, batch)
	log.Info("http method SendImageToFSBatch response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("SendImageToFSBatch file upload  wrong ", log.E(err))
	}
	return
}

// FsIO 获取io.ready
func FsIO(source, mds string) (data []byte, err error) {
	_, data, err = httputil.DefaultClientGetBytes(common.BindUrl(getOriginUrl(mds), source), nil)
	return data, err
}

func getOriginUrl(mds string) string {
	switch mds {
	case constant.MediaSourcePMS:
		return webg.Conf.URL.CdnUrl
	case constant.MediaSourceSP:
		return webg.Conf.URL.OriginUrl
	case constant.MediaSourceJH1B:
		return webg.Conf.URL.OriginUrl
	case constant.MediaSourceLaoSiJi:
		return webg.Conf.URL.LaoSiJiOriginUrl

	default:
		return webg.Conf.URL.OriginUrl
	}
}

// 获取马甲账号电话号码
func genMobileAndDevID(uid uint64) (string, string) {
	//马甲账号电话号码， 2的字符串拼接uid
	orgin := "12222222222"
	struid := strconv.FormatUint(uid, 10)
	l := 11 - len(struid)
	mobile := orgin[:l] + struid
	devID := usermod.SystemDevIDPrex + struid
	return mobile, devID
}

// 随机获取生日
func getBirthDate() string {
	var initBirthday = "1993-01-20"
	initTime, _ := time.Parse("2006-01-02", initBirthday)
	randomTime := common.RandInt(7*24*60*60, 7*365*24*60*60)
	return time.Unix(initTime.UTC().Unix()+int64(randomTime), 0).Format("2006-01-02")
}

// 游客注册
func register(fsid string) (uid uint64, city string, err error) {
	var portrait, summary, name string
	uid, err = idmod.GetNextUID()
	if err != nil {
		return
	}
	mobile, devID := genMobileAndDevID(uid)
	createdAt := time.Now()
	if len(webg.Static.Portrait) > 0 {
		portrait = webg.Static.Portrait[common.RandInt(0, len(webg.Static.Portrait))]
	}
	if len(webg.Static.Cities) > 0 {
		city = webg.Static.Cities[common.RandInt(0, len(webg.Static.Cities))]
	} else {
		city = cities[common.RandInt(0, len(cities))]
	}
	if len(webg.Static.Names) > 0 {
		name = webg.Static.Names[common.RandInt(0, len(webg.Static.Names))]
	} else {
		name = "游客" + strconv.FormatInt(time.Now().Unix(), 10)
	}
	publisher, err := SearchUserFromFS(fsid)
	if err != nil {
		return
	}
	if publisher.Code == http.StatusOK && publisher.Data.UserName != "" {
		createdAt = publisher.Data.CreatedAt
		portrait = publisher.Data.Portrait
		name = publisher.Data.UserName
		summary = publisher.Data.Summary
	}
	u := usermod.User{
		UID:            uid,
		DevID:          devID,
		Name:           name,
		Portrait:       portrait,
		Gender:         "female",
		Summary:        summary,
		Birthday:       getBirthDate(),
		Region:         city,
		RegisterIP:     "",
		WatchCount:     10, //初始化观看次数  默认为10
		PromCode:       "",
		DevToken:       "",
		VideoDeduction: 3, //默认视频扣量 30%
		VipExpireDate:  time.Unix(0, 0),
		DevType:        "xxxx",
		SysType:        constant.SysTypeIOS,
		Mobile:         mobile,
		MobileBindAt:   &createdAt,
		Ver:            "3.0.1",
	}
	err = usermod.InsertUser(&u)
	return
}

// getUIDByFsid 获取文件服发布者id映射的uid
func getUIDByFsid(fsid string) (uint64, string, error) {
	uid, err := fsuidmod.FindFsid2UID(fsid)
	if err != nil {
		return uid, "", err
	}
	user, err := usermod.FindUserByUID(uid)
	if user != nil && err == nil {
		return user.UID, user.Region, nil
	}
	var city string
	if uid == 0 {
		//生成用户 从fs 获取用户信息
		uid, city, err = register(fsid)
		if err != nil {
			return 0, "", err
		}
		//插入映射关系
		_ = fsuidmod.InsertFsid2UID(fsid, uid)
	}
	return uid, city, nil
}

// PullFile 同步文件
func PullFile(pullParam vidmod.PullReq) (code stderr.Code, data map[string]interface{}) {
	var pullResp []vidmod.AwsPullResp
	var failIds []string
	var count int
	var failCount int
	var lastID string
	var page = 1
	awsPullReq := pullParam.AwsPullReq
	awsPullReq.Status = "Completed"
	rStatus, err := strconv.Atoi(pullParam.RStatus)
	if err != nil {
		return stderr.Failure, nil
	}
	coins, err := strconv.ParseInt(pullParam.Coins, 10, 64)
	if err != nil {
		return stderr.Failure, nil
	}
	defer func() {
		if lastID != "" {
			pullLog := pullgmod.PullLog{
				LastID:       lastID,
				Count:        count,
				FailCount:    failCount,
				FailIDs:      failIds,
				CreatedAt:    time.Now(),
				VidType:      awsPullReq.Type,
				NewUpdatedAt: awsPullReq.NewUpdateAt,
			}
			_ = pullgmod.InsertPullLog(pullLog)
		}
		if r := recover(); r != nil {
			code = stderr.Failure
			log.Warn("pull file info occour error", log.Any("Detail", r), log.Any("stack", string(debug.Stack())))
		}
	}()
	pl, err := pullgmod.FindPullRecord(awsPullReq.Type, awsPullReq.NewUpdateAt)
	if err != nil {
		return stderr.Failure, nil
	}
	if pl != nil && !pullParam.Retry {
		awsPullReq.ID = pl.LastID
	}
	for {
		awsPullReq.Page = page
		param := common.StructToMap(awsPullReq)
		resp, err := PullFileInfoFromFS(param)
		if err != nil || len(resp.Data) == 0 || resp.Code != http.StatusOK {
			break
		}
		pullResp = resp.Data
		city := pullParam.Cityes[common.RandInt(0, len(pullParam.Cityes))]
		for _, pr := range pullResp {
			if len(pr.Tags) == 0 {
				continue
			}
			tags := make([]primitive.ObjectID, 0, len(pr.Tags))
			for _, t := range pr.Tags {
				tid, suc := HandleTag(t, pr.FieldNameFs+"-1.jpg")
				if !suc {
					continue
				}
				tags = append(tags, tid)
			}
			var userId uint64
			randomUid := pullParam.UID[common.RandInt(0, len(pullParam.UID))]
			if pr.PublishID != "" {
				uid, regcity, err := getUIDByFsid(pr.PublishID)
				city = regcity
				userId = uid
				if err != nil {
					userId = randomUid
					user, err := usermod.FindUserByUID(userId)
					if user != nil && err == nil {
						city = user.Region
					}
				}
			} else {
				userId = randomUid
				user, err := usermod.FindUserByUID(userId)
				if user != nil && err == nil {
					city = user.Region
				}
			}
			resCode := HandleFileBase(userId, city, tags, awsPullReq.NewUpdateAt, pr, rStatus, coins)
			if resCode != stderr.Success {
				failIds = append(failIds, pr.ID)
				failCount++
			}
			lastID = pr.ID
			count++
		}
		page++
	}
	data = make(map[string]interface{})
	data["pullCount"] = count
	data["failCount"] = failCount
	data["lastID"] = lastID
	return stderr.Success, data
}

func PullSeriesFile(pullParam vidmod.PullReq) (code stderr.Code, data map[string]interface{}) {
	var pullResp []vidmod.AwsPullSeriesResp
	var failIds []string
	var count int
	var failCount int
	var lastID string
	var page = 1
	awsPullReq := pullParam.AwsPullReq
	awsPullReq.Type = "SP"
	awsPullReq.Status = "Completed"
	rStatus, err := strconv.Atoi(pullParam.RStatus)
	if err != nil {
		return stderr.Failure, nil
	}
	coins, err := strconv.ParseInt(pullParam.Coins, 10, 64)
	if err != nil {
		return stderr.Failure, nil
	}
	defer func() {
		if lastID != "" {
			pullLog := pullgmod.PullLog{
				LastID:       lastID,
				Count:        count,
				FailCount:    failCount,
				FailIDs:      failIds,
				CreatedAt:    time.Now(),
				VidType:      pullParam.SyncType,
				NewUpdatedAt: awsPullReq.NewUpdateAt,
			}
			_ = pullgmod.InsertPullLog(pullLog)
		}
		if r := recover(); r != nil {
			code = stderr.Failure
			log.Warn("pull file info occour error", log.Any("Detail", r), log.Any("stack", string(debug.Stack())))
		}
	}()
	pl, err := pullgmod.FindPullRecord(pullParam.SyncType, awsPullReq.NewUpdateAt)
	if err != nil {
		return stderr.Failure, nil
	}
	if pl != nil && !pullParam.Retry {
		awsPullReq.ID = pl.LastID
	}
	for {
		awsPullReq.Page = page
		param := common.StructToMap(awsPullReq)
		resp, err := PullSeriesFromFS(param)
		if err != nil || len(resp.Data) == 0 || resp.Code != http.StatusOK {
			break
		}
		pullResp = resp.Data
		city := pullParam.Cityes[common.RandInt(0, len(pullParam.Cityes))]
		for _, pr := range pullResp {
			tags := make([]primitive.ObjectID, 0, len(pr.Tags))
			for _, t := range pr.Tags {
				tid, suc := HandleTag(t, pr.CoverImg)
				if !suc {
					continue
				}
				tags = append(tags, tid)
			}
			var userId uint64
			randomUid := pullParam.UID[common.RandInt(0, len(pullParam.UID))]
			userId = randomUid
			user, err := usermod.FindUserByUID(userId)
			if user != nil && err == nil {
				city = user.Region
			}
			resCode := HandleSeriesBase(userId, city, tags, awsPullReq.NewUpdateAt, pr, rStatus, coins)
			if resCode != stderr.Success {
				failIds = append(failIds, pr.ID)
				failCount++
			}
			lastID = pr.ID
			count++
		}
		page++
	}
	data = make(map[string]interface{})
	data["pullCount"] = count
	data["failCount"] = failCount
	data["lastID"] = lastID
	return stderr.Success, data
}

// HandleFileBase 处理文件基础信息
func HandleFileBase(uid uint64, city string, tags []primitive.ObjectID, newUpdatedAt string, req vidmod.AwsPullResp, status int, coins int64) (code stderr.Code) {
	defer func() {
		if err := recover(); err != nil {
			code = stderr.Failure
			return
		}
	}()
	if len(tags) == 0 {
		return stderr.Failure
	}
	//过滤调重复的视频 如果重复则跳过此视频
	if vidmod.IsExist(req.CheckSum, req.Size) {
		return stderr.Failure
	}
	l := locmod.Location{
		City: city,
	}
	if err := locmod.InsertLocationInfo(l); err != nil {
		return stderr.ErrDbInsertError
	}
	lid, err := locmod.GetLocationIDByCity(city)
	if err != nil {
		return stderr.ErrDbQueryError
	}
	if vidmod.IsExistBySocID(req.ID) {
		return stderr.ErrDbInputExist
	}
	code = insertBase(uid, tags, lid, newUpdatedAt, req, status, coins)
	for _, t := range tags {
		if err := tagmod.IncreaseTagVidCount(t, 1); err != nil {
			log.Warn("UpdateTag tag video count err %+v\n", log.E(err))
			continue
		}
	}
	return code
}

// HandleSeriesBase 处理套图基础信息
func HandleSeriesBase(uid uint64, city string, tags []primitive.ObjectID, newUpdatedAt string, req vidmod.AwsPullSeriesResp, status int, coins int64) (code stderr.Code) {
	defer func() {
		if err := recover(); err != nil {
			code = stderr.Failure
			return
		}
	}()
	l := locmod.Location{
		City: city,
	}
	if err := locmod.InsertLocationInfo(l); err != nil {
		return stderr.ErrDbInsertError
	}
	lid, err := locmod.GetLocationIDByCity(city)
	if err != nil {
		return stderr.ErrDbQueryError
	}
	if vidmod.IsExistBySocID(req.ID) {
		return stderr.ErrDbInputExist
	}
	code = insertSeriesBase(uid, tags, lid, newUpdatedAt, req, status, coins)
	for _, t := range tags {
		err := tagmod.IncreaseTagVidCount(t, 1)
		if err != nil {
			log.Warn("UpdateTag tag video count err %+v\n", log.E(err))
			continue
		}
	}
	return code
}

func insertBase(uid uint64, tags []primitive.ObjectID, lid primitive.ObjectID, newUpdatedAt string, req vidmod.AwsPullResp, status int, coins int64) (code stderr.Code) {
	oid, _ := primitive.ObjectIDFromHex(req.ID)
	flagTime := timeutil.RandReduceTime(time.Now(), 30*24*time.Hour)
	v := vidmod.VideoModel{
		ID:            oid,
		PublisherID:   uid,
		NewsType:      vidmod.SP,
		Title:         strings.TrimSpace(req.Title),
		Tags:          tags,
		SourceID:      req.ID,
		Cover:         req.FieldNameFs + "-1.jpg",
		CoverThumb:    req.FieldNameFs + "-2.jpg",
		SourceURL:     req.FieldNameFs + ".m3u8",
		Filename:      req.Filename,
		PlayTime:      req.PlayTime,
		SeriesCover:   req.CoverImg,
		Activity:      []primitive.ObjectID{},
		MimeType:      mime.TypeByExtension(strings.ToLower(filepath.Ext(req.Filename))),
		Resolution:    strconv.FormatInt(int64(req.Width), 10) + "*" + strconv.FormatInt(int64(req.Height), 10),
		Width:         req.Width,
		Height:        req.Height,
		Ratio:         req.Ratio,
		Via:           req.Via,
		Rating:        0,
		PlayCount:     0,
		LikeCount:     0,
		FakeLikeCount: common.RandInt(50, 500),
		CommentCount:  0,
		FakePlayCount: common.RandInt(200, 3000),
		ShareCount:    common.RandInt(500, 10000),
		Status:        status,
		Location:      lid,
		FreeTime:      vidmod.MinFreeTime,
		Coins:         coins,
		Size:          req.Size,
		MD5:           req.CheckSum,
		Actor:         strings.Join(req.Actors, ","),
		NewUpdatedAt:  newUpdatedAt,
		CreatedAt:     flagTime,
		UpdatedAt:     flagTime,
	}
	if _, err := vidmod.InsertBase(v); err != nil {
		return stderr.ErrDbInsertError
	}
	return stderr.Success
}

func insertSeriesBase(uid uint64, tags []primitive.ObjectID, lid primitive.ObjectID, newUpdatedAt string, req vidmod.AwsPullSeriesResp, status int, coins int64) (code stderr.Code) {
	oid, _ := primitive.ObjectIDFromHex(req.ID)
	flagTime := timeutil.RandAddTime(time.Now(), 3*24*time.Hour)
	v := vidmod.VideoModel{
		ID:            oid,
		PublisherID:   uid,
		NewsType:      vidmod.COVER,
		Title:         strings.TrimSpace(req.Title),
		Tags:          tags,
		SourceID:      req.ID,
		Cover:         req.CoverImg,
		SeriesCover:   req.SeriesCover,
		SeriesNum:     int(req.Number),
		Activity:      []primitive.ObjectID{},
		MimeType:      req.MimeType,
		Via:           req.Via,
		Rating:        0,
		PlayCount:     0,
		LikeCount:     0,
		FakeLikeCount: common.RandInt(50, 500),
		CommentCount:  0,
		FakePlayCount: common.RandInt(200, 3000),
		ShareCount:    common.RandInt(300, 10000),
		Status:        status,
		Location:      lid,
		FreeTime:      vidmod.MinFreeTime,
		Coins:         coins,
		NewUpdatedAt:  newUpdatedAt,
		CreatedAt:     flagTime,
		UpdatedAt:     flagTime,
	}
	if _, err := vidmod.InsertBase(v); err != nil {
		return stderr.ErrDbInsertError
	}
	return stderr.Success
}

// HandleTag 处理标签
func HandleTag(tagname, img string) (tagID primitive.ObjectID, suc bool) {
	tMod := tagmod.Tag{}
	tagInfo, err := tagmod.FindOneTagByName(strings.TrimSpace(tagname))
	if err == nil && !tagInfo.ID.IsZero() {
		return tagInfo.ID, true
	}
	tMod.TagName = v10.ExtractPureChar(tagname)
	tMod.CoverImg = img
	tMod.SortCode = 999
	tMod.IsActive = true
	tMod.CreatedAt = time.Now()
	tMod.UpdatedAt = time.Now()
	id, err := tagmod.InsertOne(&tMod)
	if err != nil {
		return primitive.NilObjectID, false
	}
	return id, true
}

// PullFileInfoFromFS PullFileInfoFromFS
func PullFileInfoFromFS(params map[string]interface{}) (respBody vidmod.Resport, err error) {
	code, err := httputil.DefaultClientPostJsonWithResp(&respBody, webg.Conf.URL.PullFileUrl, nil, params)
	log.Info("http method PullFileInfoFromFS response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("Pull FileInfo From Aws ", log.E(err))
		return
	}
	return
}

// PullSeriesFromFS PullSeriesFromFS
func PullSeriesFromFS(params map[string]interface{}) (respBody vidmod.SeriesResport, err error) {
	code, err := httputil.DefaultClientPostJsonWithResp(&respBody, webg.Conf.URL.PullSeriesUrl, nil, params)
	log.Info("http method PullSeriesFromFS response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("Pull Series From Aws ", log.E(err))
		return
	}
	return
}

// PullFileInfo 获取文件转码情况及详情
func PullFileInfo(id string) (respBody vidmod.PuFinfoResp, err error) {
	code, err := httputil.DefaultClientPostJsonWithResp(&respBody, common.BindUrl(webg.Conf.URL.PullFileInfo, id), nil, nil)
	log.Info("http method PullFileInfo response code ==>", log.Any("statusCode", code), log.Any("respCode", respBody.Code))
	if err != nil {
		log.Error("Pull FileInfo From Aws ", log.E(err))
		respBody.Code = stderr.ErrConnectToFs
		return
	}
	switch respBody.Data.Status {
	case vidmod.Merging, vidmod.MergeCompleted:
		respBody.Code = stderr.FileMerging
	case vidmod.MergeError:
		respBody.Code = stderr.ErrMergeFile
	case vidmod.Converting:
		respBody.Code = stderr.FileConverting
	case vidmod.ConvertError:
		respBody.Code = stderr.ErrConvertFile
	case vidmod.UploadLoadingToFs:
		respBody.Code = stderr.UploadLoadingToFs
	case vidmod.FileUploadError:
		respBody.Code = stderr.ErrUploadError
	case vidmod.ConvertCompleted, vidmod.Completed:
		respBody.Code = stderr.UpLoadFileComplete
	}
	return
}

// 新导入的视频数据同步到ES
func SyncNewImportVideoToElastic(newUpdatedAt string, start, end time.Time) {
	var page, pageSize int64 = 1, 50
	for {
		nVideos, err := vidmod.GetNewImportVideo(newUpdatedAt, start, end, page, pageSize)
		if err != nil || len(nVideos) == 0 {
			return
		}
		// 获取标签名字
		var tagsID []primitive.ObjectID
		for _, v := range nVideos {
			tagsID = append(tagsID, v.Tags...)
		}
		tags, err := tagmod.FindTagsByIDS(tagsID)
		if err != nil {
			return
		}
		var tagsNameMap = make(map[primitive.ObjectID]string)
		for _, v := range tags {
			tagsNameMap[v.ID] = v.TagName
		}
		var source = elastic.M{}
		for _, v := range nVideos {
			var tagsName []string
			for _, v1 := range v.Tags {
				tagsName = append(tagsName, tagsNameMap[v1])
			}
			var tmp = vidmod.ESVideo{
				ID:             v.ID,
				PublisherID:    v.PublisherID,
				Title:          v.Title,
				Tags:           v.Tags,
				TagsName:       tagsName,
				Filename:       v.Filename,
				PlayCount:      v.PlayCount,
				PurchaseCount:  v.PurchaseCount,
				LikeCount:      v.LikeCount,
				CommentCount:   v.CommentCount,
				ShareCount:     v.ShareCount,
				FakeLikeCount:  v.FakeLikeCount,
				FakeShareCount: v.FakeShareCount,
				FakePlayCount:  v.FakePlayCount,
				Status:         v.Status,
				Location:       v.Location,
				CreatedAt:      v.CreatedAt,
				UpdatedAt:      v.UpdatedAt,
			}
			source[v.ID.Hex()] = tmp
		}
		if err = webg.VideoES.Bulk(models.ESInfoVideoTable, source); err != nil {
			continue
		}
		log.Info("sync video info to elastic successfully running at page", log.Any("page", page))
		page++
	}
}