package vidser

import (
	"91porn-server/app/service/modulevideoser"
	"91porn-server/models/v/modulevidmod"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/vidtimeonlinemod"
	"context"
	"fmt"
	"math/rand"
	"net/url"
	"strconv"
	"strings"
	"time"

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

	"91porn-server/common"
	"91porn-server/common/constant"
	"91porn-server/common/log"
	"91porn-server/common/mdrsdb"
	"91porn-server/models/v/vidmod"

	"github.com/shopspring/decimal"
)

func getMediaPathFromUrl(rawUrl string) string {
	url, err := url.Parse(rawUrl)
	if err != nil || url.Path == "" {
		return ""
	}
	return url.Path
}

func getMediaFileInfoFromUrl(rawUrl string) (sourceID, fileName string) {
	url, err := url.Parse(rawUrl)
	if err != nil {
		return
	}
	path := url.Path
	sliX := strings.Split(path, "/")
	if len(sliX) > 0 {
		fileName = sliX[len(sliX)-1]
	}
	sliP := strings.Split(fileName, ".")
	if len(sliP) > 0 {
		sourceID = sliP[0]
	}
	return
}

func getIMGPathFromUrl(rawUrl string) string {
	//新桶，无需加ims，可直接回源
	if strings.Contains(rawUrl, "cf230705") || strings.Contains(rawUrl, "bf211222") {
		return rawUrl
	}
	if rawUrl == "" {
		return ""
	}
	url, err := url.Parse(rawUrl)
	if err != nil {
		return ""
	}
	return common.BindUrl(constant.ImageSourceIMS, url.Path)
}

func GetMediaList(ctx context.Context, page, size, vloggerUserId int64, title, tagText, hashId string, vMia, videoType int, syncType, terminalCdo string, startTime, endTime time.Time, sortType, maxTotal int) (data []mdrsdb.MediaResource, count int64, err error) {
	data, count, err = mdrsdb.FindMediaList(ctx, page, size, vloggerUserId, title, tagText, hashId, vMia, videoType, syncType, terminalCdo, startTime, endTime, sortType, maxTotal)
	for i := range data {
		data[i].CoverImage = getIMGPathFromUrl(data[i].CoverImage)
		data[i].VerticalCover = getIMGPathFromUrl(data[i].VerticalCover)
		data[i].Src1080 = getMediaPathFromUrl(data[i].Src1080)
		data[i].Src720 = getMediaPathFromUrl(data[i].Src720)
		data[i].Src480 = getMediaPathFromUrl(data[i].Src480)
		data[i].VerticalCover = getIMGPathFromUrl(data[i].VerticalCover)
		tags := strings.Split(data[i].TagsText, ",")
		if len(tags) > 5 {
			tags = tags[:5]
		}
		data[i].TagList = tags
	}
	return
}

func UseMedias(ctx context.Context, ids []int64, authorID uint64, sectionID primitive.ObjectID, inTags []string, videoType int, manager string, coins *int64, onlineTime time.Time) ([]SensitiveHit, error) {
	mbs, err := mdrsdb.FindMediaListWithIDs(ctx, ids, videoType)
	if err != nil {
		return nil, err
	}
	terms := LoadEnabledSensitiveTerms()
	hits := make([]SensitiveHit, 0)
	useIds := make([]int64, 0, len(mbs))
	for i, v := range mbs {
		log.Info(fmt.Sprintf("Synchronize media library video information:video_id:%d  up_id:%d  authorId:%d", v.Id, v.VloggerUserId, authorID))
		mbs[i].CoverImage = getIMGPathFromUrl(mbs[i].CoverImage)
		mbs[i].VerticalCover = getIMGPathFromUrl(mbs[i].VerticalCover)
		mbs[i].Src1080 = getMediaPathFromUrl(mbs[i].Src1080)
		mbs[i].Src720 = getMediaPathFromUrl(mbs[i].Src720)
		mbs[i].Src480 = getMediaPathFromUrl(mbs[i].Src480)
		mbs[i].VerticalCover = getIMGPathFromUrl(mbs[i].VerticalCover)
		var m3u8 string
		var m3u8Size int64
		if strings.Contains(mbs[i].Src720, "/") {
			m3u8 = mbs[i].Src720
			m3u8Size = mbs[i].FileSize720
		}
		if m3u8 == "" {
			m3u8 = mbs[i].Src480
			m3u8Size = mbs[i].FileSize480
		}
		if m3u8 == "" {
			m3u8 = mbs[i].Src1080
			m3u8Size = mbs[i].FileSize1080
		}
		tagsList := strings.Split(mbs[i].TagsText, ",")
		tags := []string{}
		for _, tag := range tagsList {
			tag = strings.TrimSpace(tag)
			if tag != "" {
				tags = append(tags, tag)
			}
		}
		if len(tags) > 5 {
			tags = tags[:5]
		}
		tags = append(tags, inTags...)
		if authorID == 0 && v.VloggerUserId != 0 {
			authorID = v.VloggerUserId
		} else if authorID == 0 {
			authorID = 100001
		}
		author, _ := usermod.FindUserByUID(authorID)
		if author == nil {
			authorID = uint64(rand.Int63n(50000) + 100001)
		}
		var pics []string
		if len(v.Pics) > 0 {
			pics = strings.Split(v.Pics, ",")
			for i, p := range pics {
				pics[i] = getIMGPathFromUrl(p)
			}
		}
		//  videoType : 0 长视频 1短视频 2图文
		//  v.MediaType: 0视频 1 图文
		vt := vidmod.SP
		if videoType == 1 {
			vt = vidmod.SHORT
		} else if videoType == 2 && v.MediaType == 1 {
			vt = vidmod.COVER
		}

		var ratio float64 = 0
		if v.Height > 0 && v.Width > 0 {
			ratio = float64(decimal.NewFromInt(int64(v.Width)).Div(decimal.NewFromInt(int64(v.Height))).Shift(2).IntPart()) / 100
		}
		temp := vidmod.WebSubmitReq{
			UID:           authorID,
			NewsType:      vt,
			Title:         v.Title,
			Content:       v.Content,
			Tags:          tags,
			PlayTime:      v.Length,
			Cover:         mbs[i].CoverImage,
			VerticalCover: mbs[i].VerticalCover,
			SeriesCover:   pics,
			Via:           mbs[i].TerminalCdo,
			Coins:         mbs[i].SaleCoin,
			Size:          int(m3u8Size),
			Resolution:    strconv.Itoa(v.Width) + "*" + strconv.Itoa(v.Height),
			Ratio:         ratio,
			Width:         v.Width,
			Height:        v.Height,
			MimeType:      "",
			Actor:         "",
			SourceURL:     m3u8,
			MD5:           v.HashId,
			SourceID:      strconv.FormatInt(v.Id, 10),
			MDSID:         v.HashId,
			Account:       manager,
			RichText:      v.RichText,
			PreviewStart:  v.PreviewStart,
		}
		if coins != nil {
			temp.Coins = *coins
		}
		if len(tags) > 0 {
			if tags[0] != "" {
				temp.Status = 1
			}

		}
		if m3u8 != "" {
			temp.SourceID, temp.Filename = getMediaFileInfoFromUrl(m3u8)
			if temp.PlayTime > 60 {
				temp.FreeTime = 15
			} else {
				temp.FreeTime = int(temp.PlayTime / 4)
			}
		}
		if authorID > 0 {
			temp.UID = authorID
		}
		if !onlineTime.IsZero() {
			temp.Status = 0
		}
		if temp.NewsType == vidmod.COVER {
			temp.Status = 0
		}
		if !onlineTime.IsZero() {
			temp.Status = vidmod.OnlinePass
		}
		// 敏感词命中：强制为待审核，且不进入自动上架/专题上架链路
		hit := CheckTextHits(terms, temp.SourceID, temp.Title, temp.Content, temp.RichText)
		if hit != nil {
			temp.Status = vidmod.WaitingCheck
			log.Warn("vidser.UseMedias sensitive hit, forced offline & skip auto-online",
				log.Any("sourceId", hit.SourceID),
				log.Any("title", hit.Title),
				log.Any("detail", hit.Detail))
			hits = append(hits, *hit)
		}
		code, vid := SubmitBase(temp)
		if code != 200 {
			log.ErrorX(ctx, "vidser UseMedias is fail", log.Any("code", code), log.Any("vid", vid))
			continue
		}
		if !onlineTime.IsZero() && hit == nil {
			// 加入批量自动上架（命中过的资源不进入此路径）
			BatchAuditVidTimeOnlineInfo(vidtimeonlinemod.BatchAuditReq{
				Vids:       []primitive.ObjectID{vid},
				SectionID:  sectionID,
				OnlineTime: onlineTime,
			}, int(temp.Coins), manager)

		} else if !sectionID.IsZero() && temp.Status == 1 {
			// 加入专题
			sv := modulevidmod.SectionVideo{
				SectionID:       sectionID,
				VideoID:         vid,
				VideoReviewedAt: time.Now(),
				SortCode:        50,
				CreatedAt:       time.Now(),
				UpdatedAt:       time.Now(),
			}

			_ = modulevideoser.AddVideo(&sv)
		}
		useIds = append(useIds, v.Id)
	}
	if len(useIds) > 0 {
		if err = mdrsdb.UseMedia(ctx, useIds, videoType); err != nil {
			return hits, err
		}
	}
	return hits, nil
}

func IgnoreMedias(ctx context.Context, ids []int64, videoType int) (err error) {
	return mdrsdb.IgnoreMedia(ctx, ids, videoType)
}