package officialwebsiteser

import (
	"91porn-server/models/v/tagmod"
	"91porn-server/models/v/vidmod"
	"math/rand/v2"
	"time"

	"91porn-server/common/stderr"
	officialwebsitemod "91porn-server/models/v/officialWebsitemod"

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

// ─────────────────────────────────────────
// Service functions
// ─────────────────────────────────────────

func CheckVideoExistByVid(vid []primitive.ObjectID) ([]officialwebsitemod.Video, error) {
	filter := bson.M{"_id": bson.M{"$in": vid}}
	mod := &officialwebsitemod.Video{}
	videos, err := mod.FindMany(filter)
	return videos, err
}

func ListVideo(req *VideoListReq) (int64, []officialwebsitemod.Video, error) {
	filter, err := req.Query()
	if err != nil {
		return 0, nil, err
	}
	mod := &officialwebsitemod.Video{}
	total, err := mod.Count(filter)
	if err != nil {
		return 0, nil, err
	}
	list, err := mod.FindMany(filter, req.FindOptions())
	if err != nil {
		return 0, nil, err
	}
	return total, list, nil
}

// resolveVideoSeoSlug 处理 seoSlug：手填则校验格式并查重(冲突报错)；为空则由标题生成雏形并追加后缀去重。
func resolveVideoSeoSlug(provided, title string, excludeID primitive.ObjectID) (string, error) {
	exists := func(slug string) (bool, error) {
		filter := officialwebsitemod.M{"seoSlug": slug}
		if !excludeID.IsZero() {
			filter["_id"] = officialwebsitemod.M{"$ne": excludeID}
		}
		n, err := (&officialwebsitemod.Video{}).Count(filter)
		return n > 0, err
	}
	if provided != "" {
		if !ValidateSeoSlug(provided) {
			return "", stderr.ErrParamError
		}
		used, err := exists(provided)
		if err != nil {
			return "", err
		}
		if used {
			return "", stderr.ErrParamError
		}
		return provided, nil
	}
	return UniqueSeoSlug(GenerateSeoSlug(title), exists)
}

func CreateVideo(req *ModifyVideoReq) (officialwebsitemod.Video, error) {
	data, err := req.toMod()
	if err != nil {
		return officialwebsitemod.Video{}, err
	}
	// SEO slug：手填优先(校验唯一)，为空则由标题生成雏形并去重
	if data.SeoSlug, err = resolveVideoSeoSlug(data.SeoSlug, data.Title, primitive.NilObjectID); err != nil {
		return officialwebsitemod.Video{}, err
	}
	if err := data.Create(); err != nil {
		return officialwebsitemod.Video{}, err
	}
	return data, nil
}

func UpdateVideo(req *ModifyVideoReq) (resp CountResp, err error) {
	if req == nil || req.ID == "" {
		return
	}
	id, parseErr := primitive.ObjectIDFromHex(req.ID)
	if parseErr != nil || isNilObjectID(id) {
		err = stderr.ErrParamError
		return
	}
	mod := &officialwebsitemod.Video{}
	if err = mod.FindOne(officialwebsitemod.M{"_id": id}); err != nil {
		return
	}
	// 若提交了 seoSlug，先校验/去重(排除自身)，回写后由 toM 落库
	if req.SeoSlug != nil {
		var slug string
		if slug, err = resolveVideoSeoSlug(*req.SeoSlug, mod.Title, id); err != nil {
			return
		}
		*req.SeoSlug = slug
	}
	var update officialwebsitemod.M
	if update, err = req.toM(); err != nil || update == nil {
		return
	}
	resp.Count, err = mod.Update(officialwebsitemod.M{"_id": id}, update)
	return
}

func DeleteVideo(req *DeleteVideoReq) (data DeleteVideoResp, err error) {
	if req == nil {
		err = stderr.CodeEmptyData
		return
	}
	var id primitive.ObjectID
	if id, err = primitive.ObjectIDFromHex(req.ID); err != nil {
		return
	}
	if isNilObjectID(id) {
		err = stderr.ErrParamError
		return
	}
	mod := &officialwebsitemod.Video{}
	data.Count, err = mod.Delete(officialwebsitemod.M{"_id": id})
	return
}

func BatchUpdateVideoOwner(req *BatchUpdateVideoOwnerReq) (data BatchUpdateVideoOwnerResp, err error) {
	if req == nil {
		err = stderr.ErrParamError
		return
	}

	// Check owner is exist
	var ownerID primitive.ObjectID
	ownerID, err = primitive.ObjectIDFromHex(req.OwnerID)
	if err != nil {
		return
	}
	var heroMod = &officialwebsitemod.Hero{}
	err = heroMod.FindOne(officialwebsitemod.M{"_id": ownerID})
	if err != nil {
		return
	}
	if isNilObjectID(heroMod.ID) {
		err = stderr.OfficialWebsiteHeroExist
		return
	}

	var update = bson.M{"$set": bson.M{"heroId": ownerID}}
	// Check album is exist, if exist then add into update
	if req.AlbumID != "" {
		var albumID primitive.ObjectID
		albumID, err = primitive.ObjectIDFromHex(req.AlbumID)
		if err != nil {
			return
		}
		var album = &officialwebsitemod.Album{}
		err = album.FindOne(officialwebsitemod.M{"_id": albumID})
		if err != nil {
			return
		}
		update = bson.M{"$set": bson.M{"heroId": ownerID, "albumId": albumID}}
	}

	var videoIDs []primitive.ObjectID
	for i := range req.VideoIDs {
		videoID, parseErr := primitive.ObjectIDFromHex(req.VideoIDs[i])
		err = parseErr
		if err != nil {
			return
		}
		videoIDs = append(videoIDs, videoID)
	}
	var videoMod = &officialwebsitemod.Video{}
	filter := bson.M{"_id": bson.M{"$in": videoIDs}}
	data.Count, err = videoMod.UpdateMany(filter, update)
	return
}

// ─────────────────────────────────────────
// Batch (Modify) types
// ─────────────────────────────────────────

type BatchUpdateVideoOwnerReq struct {
	VideoIDs []string `json:"video_ids"`
	OwnerID  string   `json:"owner_id"`
	AlbumID  string   `json:"album_id"`
}

type BatchUpdateVideoOwnerResp struct {
	Count int64 `json:"count"`
}

// ─────────────────────────────────────────
// Mutation (Modify) types
// ─────────────────────────────────────────

type ModifyVideoReq struct {
	ID           string                    `json:"id" form:"id"`
	AlbumID      *string                   `json:"albumId" form:"albumId"`
	HeroID       *string                   `json:"heroId" form:"heroId"`
	Title        *string                   `json:"title"`
	Description  *string                   `json:"description"`
	Cover        *string                   `json:"cover"`
	Url          *string                   `json:"url"`
	SeoSlug      *string                   `json:"seoSlug"`
	Tags         *[]officialwebsitemod.Tag `json:"tags"`
	IsHot        *bool                     `json:"isHot"`
	Sort         *int64                    `json:"sort"`
	IsActive     *bool                     `json:"isActive"`
	WatchCount   *int64                    `json:"watchCount"`
	LikeCount    *int64                    `json:"likeCount"`
	CommentCount *int64                    `json:"commentCount"`
	CollectCount *int64                    `json:"collectCount"`
}

// ─────────────────────────────────────────
// Delete types
// ─────────────────────────────────────────

type DeleteVideoReq struct {
	ID string `json:"id" form:"id"`
}

type DeleteVideoResp struct {
	Count int64 `json:"count"`
}

// ─────────────────────────────────────────
// toMod — ModifyVideoReq → model struct
// ─────────────────────────────────────────

func (req *ModifyVideoReq) toMod() (officialwebsitemod.Video, error) {
	if req == nil {
		return officialwebsitemod.Video{}, nil
	}
	data := officialwebsitemod.Video{
		Title:       stringOrZero(req.Title),
		Description: stringOrZero(req.Description),
		Cover:       stringOrZero(req.Cover),
		Url:         stringOrZero(req.Url),
		IsHot:       boolOrZero(req.IsHot),
		SortModel: officialwebsitemod.SortModel{
			Sort:     int64OrZero(req.Sort),
			IsActive: boolOrZero(req.IsActive),
		},
		WatchCount:   int64OrZero(req.WatchCount),
		LikeCount:    int64OrZero(req.LikeCount),
		CommentCount: int64OrZero(req.CommentCount),
		CollectCount: int64OrZero(req.CollectCount),
	}
	if req.AlbumID != nil {
		if *req.AlbumID != "" {
			albumID, err := primitive.ObjectIDFromHex(*req.AlbumID)
			if err != nil || isNilObjectID(albumID) {
				return officialwebsitemod.Video{}, stderr.ErrParamError
			}
			data.AlbumID = albumID
		}
	}
	if req.HeroID != nil {
		if *req.HeroID != "" {
			heroID, err := primitive.ObjectIDFromHex(*req.HeroID)
			if err != nil || isNilObjectID(heroID) {
				return officialwebsitemod.Video{}, stderr.ErrParamError
			}
			data.HeroID = heroID
		}
	}
	if req.Tags != nil {
		data.Tags = *req.Tags
	}
	if req.SeoSlug != nil {
		data.SeoSlug = *req.SeoSlug
	}
	return data, nil
}

// ─────────────────────────────────────────
// toM — ModifyVideoReq → officialwebsitemod.M
// ─────────────────────────────────────────

func (req *ModifyVideoReq) toM() (officialwebsitemod.M, error) {
	if req == nil {
		return nil, stderr.CodeEmptyData
	}
	set := officialwebsitemod.M{}
	if req.AlbumID != nil {
		if *req.AlbumID != "" {
			albumID, err := primitive.ObjectIDFromHex(*req.AlbumID)
			if err != nil || isNilObjectID(albumID) {
				return nil, stderr.ErrParamError
			}
			set["albumId"] = albumID
		}
	}
	if req.HeroID != nil {
		if *req.HeroID != "" {
			heroID, err := primitive.ObjectIDFromHex(*req.HeroID)
			if err != nil || isNilObjectID(heroID) {
				return nil, stderr.ErrParamError
			}
			set["heroId"] = heroID
		}
	}
	if req.Title != nil {
		set["title"] = *req.Title
	}
	if req.Description != nil {
		set["description"] = *req.Description
	}
	if req.Cover != nil {
		set["cover"] = *req.Cover
	}
	if req.Url != nil {
		set["url"] = *req.Url
	}
	if req.Tags != nil {
		set["tags"] = *req.Tags
	}
	if req.SeoSlug != nil && *req.SeoSlug != "" {
		set["seoSlug"] = *req.SeoSlug
	}
	if req.IsHot != nil {
		set["isHot"] = *req.IsHot
	}
	if req.Sort != nil {
		set["sort"] = *req.Sort
	}
	if req.IsActive != nil {
		set["isActive"] = *req.IsActive
	}
	if req.WatchCount != nil {
		set["watchCount"] = *req.WatchCount
	}
	if req.LikeCount != nil {
		set["likeCount"] = *req.LikeCount
	}
	if req.CommentCount != nil {
		set["commentCount"] = *req.CommentCount
	}
	if req.CollectCount != nil {
		set["collectCount"] = *req.CollectCount
	}
	if len(set) == 0 {
		return nil, nil
	}
	set["updatedAt"] = time.Now().UTC()
	return officialwebsitemod.M{"$set": set}, nil
}

func BatchImportVideo(req *BatchImportVideoReq) (resp BatchImportVideoResp, err error) {
	if req == nil || len(req.VideoIds) == 0 {
		err = stderr.ErrParamError
		return
	}
	objIds := make([]primitive.ObjectID, 0, len(req.VideoIds))
	videoIDSet := make(map[primitive.ObjectID]struct{}, len(req.VideoIds))
	for _, videoId := range req.VideoIds {
		var id primitive.ObjectID
		id, err = primitive.ObjectIDFromHex(videoId)
		if err != nil {
			return
		}
		if _, exists := videoIDSet[id]; exists {
			continue
		}
		videoIDSet[id] = struct{}{}
		objIds = append(objIds, id)
	}
	if len(objIds) == 0 {
		return
	}

	// 1) Filter out videos that already exist in official website video table by `_id`.
	var videoMod = &officialwebsitemod.Video{}
	officialVideos, findVideoErr := videoMod.FindMany(officialwebsitemod.M{"_id": bson.M{"$in": objIds}})
	if findVideoErr != nil {
		err = findVideoErr
		return
	}
	existedVideoMap := make(map[primitive.ObjectID]struct{}, len(officialVideos))
	for _, v := range officialVideos {
		existedVideoMap[v.ID] = struct{}{}
	}

	needImportVideoIDs := make([]primitive.ObjectID, 0, len(objIds))
	for _, id := range objIds {
		if _, exists := existedVideoMap[id]; exists {
			continue
		}
		needImportVideoIDs = append(needImportVideoIDs, id)
	}
	if len(needImportVideoIDs) == 0 {
		return
	}

	mats := []vidmod.Matcher{
		(&vidmod.IDInMatch{IDs: needImportVideoIDs}).New(),
	}
	list, err := vidmod.FindMany(mats...)
	if err != nil {
		return
	}
	if len(list) == 0 {
		return
	}

	var insertVideos []officialwebsitemod.Video
	allTagIDs := make([]primitive.ObjectID, 0)
	allTagIDSet := make(map[primitive.ObjectID]struct{})
	for _, video := range list {
		insertVideos = append(insertVideos, officialwebsitemod.Video{
			ID:           video.ID,
			Title:        video.Title,
			Description:  video.Content,
			Cover:        video.Cover,
			Url:          video.SourceURL,
			IsHot:        false,
			WatchCount:   int64(video.FakePlayCount+video.PlayCount) * rand.Int64N(10),
			LikeCount:    int64(video.FakeLikeCount+video.LikeCount) * rand.Int64N(10),
			CommentCount: int64(video.FakeCommentCount+video.CommentCount) * rand.Int64N(10),
			CollectCount: int64(video.CollectCount) * rand.Int64N(10),
			SortModel: officialwebsitemod.SortModel{
				IsActive: true,
			},
			BaseModel: officialwebsitemod.BaseModel{
				CreatedAt: time.Now().UTC(),
				UpdatedAt: time.Now().UTC(),
			},
		})
		for _, tag := range video.Tags {
			if _, exists := allTagIDSet[tag]; exists {
				continue
			}
			allTagIDSet[tag] = struct{}{}
			allTagIDs = append(allTagIDs, tag)
		}
	}

	if len(insertVideos) == 0 {
		return
	}

	// 2) Filter out tags that already exist in official website tag table by `_id`.
	var tagMod = &officialwebsitemod.Tag{}
	existedTagMap := map[primitive.ObjectID]struct{}{}
	existedOfficialTagInfoMap := map[primitive.ObjectID]officialwebsitemod.Tag{}
	if len(allTagIDs) > 0 {
		officialWebsiteTags, findTagErr := tagMod.FindMany(officialwebsitemod.M{
			"_id":  bson.M{"$in": allTagIDs},
			"type": officialwebsitemod.OfficialWebsiteTagTypeVideo,
		})
		if findTagErr != nil {
			err = findTagErr
			return
		}
		existedTagMap = make(map[primitive.ObjectID]struct{}, len(officialWebsiteTags))
		for _, t := range officialWebsiteTags {
			existedTagMap[t.ID] = struct{}{}
			existedOfficialTagInfoMap[t.ID] = t
		}
	}

	needImportTagIDs := make([]primitive.ObjectID, 0, len(allTagIDs))
	for _, tagID := range allTagIDs {
		if _, exists := existedTagMap[tagID]; exists {
			continue
		}
		needImportTagIDs = append(needImportTagIDs, tagID)
	}

	tagsMap, err := tagmod.FindTagsMapByIDS(needImportTagIDs)
	if err != nil {
		return
	}

	var insertTags []officialwebsitemod.Tag
	for _, tagID := range needImportTagIDs {
		tag, ok := tagsMap[tagID]
		if !ok {
			continue
		}
		insertTags = append(insertTags, officialwebsitemod.Tag{
			ID:    tag.ID,
			Name:  tag.TagName,
			Type:  officialwebsitemod.OfficialWebsiteTagTypeVideo,
			IsHot: len(tag.HotMark) > 0,
			SortModel: officialwebsitemod.SortModel{
				IsActive: true,
			},
			BaseModel: officialwebsitemod.BaseModel{
				CreatedAt: time.Now().UTC(),
				UpdatedAt: time.Now().UTC(),
			},
		})
	}

	// Fill video tags from tag info map to keep video docs self-contained.
	for i := range insertVideos {
		srcVideo := list[i]
		videoTags := make([]officialwebsitemod.Tag, 0, len(srcVideo.Tags))
		for _, tagID := range srcVideo.Tags {
			if oldTag, exists := existedOfficialTagInfoMap[tagID]; exists {
				videoTags = append(videoTags, officialwebsitemod.Tag{
					ID:    oldTag.ID,
					Name:  oldTag.Name,
					Type:  officialwebsitemod.OfficialWebsiteTagTypeVideo,
					IsHot: oldTag.IsHot,
					SortModel: officialwebsitemod.SortModel{
						Sort:     oldTag.Sort,
						IsActive: true,
					},
				})
				continue
			}
			tag, ok := tagsMap[tagID]
			if !ok {
				continue
			}
			videoTags = append(videoTags, officialwebsitemod.Tag{
				ID:    tag.ID,
				Name:  tag.TagName,
				Type:  officialwebsitemod.OfficialWebsiteTagTypeVideo,
				IsHot: len(tag.HotMark) > 0,
				SortModel: officialwebsitemod.SortModel{
					IsActive: true,
				},
			})
		}
		insertVideos[i].Tags = videoTags
	}

	// 3) Insert filtered videos and tags into official website tables separately.
	var ids []primitive.ObjectID
	ids, err = videoMod.InsertMany(insertVideos)
	if err != nil {
		return
	}

	for i := range insertTags {
		if createErr := insertTags[i].Create(); createErr != nil {
			err = createErr
			return
		}
	}

	resp.Count = int64(len(ids))
	return
}

// ─────────────────────────────────────────
// Batch Import types
// ─────────────────────────────────────────

type BatchImportVideoReq struct {
	VideoIds []string `json:"videoIds"`
}

type BatchImportVideoResp struct {
	Count int64 `json:"count"`
}

// ─────────────────────────────────────────
// List types
// ─────────────────────────────────────────

type VideoListReq struct {
	PageReq
	ID           *string              `form:"id"`
	IDs          []string             `form:"ids"`
	PrimiteveIDs []primitive.ObjectID `form:"primitiveIds"`
	AlbumID      *string              `form:"albumId"`
	HeroID       *string              `form:"heroID"`
	Title        *string              `form:"title"`
	Description  *string              `form:"description"`
	Cover        *string              `form:"cover"`
	Url          *string              `form:"url"`
	Tags         *string              `form:"tags"`
	IsHot        *bool                `form:"isHot"`
	Sort         *int64               `form:"sort"`
	IsActive     *bool                `form:"isActive"`
	CreatedAt    *time.Time           `form:"createdAt"`
	UpdatedAt    *time.Time           `form:"updatedAt"`
	DeletedAt    *time.Time           `form:"deletedAt"`
}

func (r *VideoListReq) Query() (officialwebsitemod.M, error) {
	filter := officialwebsitemod.M{}
	if err := parseObjectIDFilter(filter, "_id", r.ID); err != nil {
		return nil, err
	}
	if len(r.IDs) > 0 {
		var objIDs []primitive.ObjectID
		for _, id := range r.IDs {
			objID, err := primitive.ObjectIDFromHex(id)
			if err != nil {
				return nil, err
			}
			objIDs = append(objIDs, objID)
		}
		filter["_id"] = bson.M{"$in": objIDs}
	}
	if len(r.PrimiteveIDs) > 0 {
		filter["_id"] = bson.M{"$in": r.PrimiteveIDs}
	}
	if err := parseObjectIDFilter(filter, "albumId", r.AlbumID); err != nil {
		return nil, err
	}
	if err := parseObjectIDFilter(filter, "heroId", r.HeroID); err != nil {
		return nil, err
	}
	if r.Title != nil {
		filter["title"] = *r.Title
	}
	if r.Description != nil {
		filter["description"] = *r.Description
	}
	if r.Cover != nil {
		filter["cover"] = *r.Cover
	}
	if r.Url != nil {
		filter["url"] = *r.Url
	}
	if err := parseJSONFilter(filter, "tags", r.Tags, &[]officialwebsitemod.Tag{}); err != nil {
		return nil, err
	}
	if r.IsHot != nil {
		filter["isHot"] = *r.IsHot
	}
	if r.Sort != nil {
		filter["sort"] = *r.Sort
	}
	if r.IsActive != nil {
		filter["isActive"] = *r.IsActive
	}
	if r.CreatedAt != nil {
		filter["createdAt"] = *r.CreatedAt
	}
	if r.UpdatedAt != nil {
		filter["updatedAt"] = *r.UpdatedAt
	}
	if r.DeletedAt != nil {
		filter["deletedAt"] = *r.DeletedAt
	}
	return filter, nil
}