package srv_videocollection

import (
	"context"
	"time"
	"videoweb/pub/common/srvdef"
	"videoweb/pub/models/videocollectionmediamod"
	"videoweb/pub/models/videoinformationmod"
	"videoweb/pub/pubdef"

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

func VideoCollectionOptionMedia(ctx context.Context, req *VideoCollectionOptionMediaReq) *srvdef.SrvErr {
	_, err := videoinformationmod.FindOneVideoInformation(ctx, bson.M{
		videoinformationmod.FN.VideoInformation.Id:        req.CollectionID,
		videoinformationmod.FN.VideoInformation.MediaType: videoinformationmod.MediaType_Collection,
	})
	if err != nil {
		return err
	}
	if req.IsAdd {
		// 追加视频
		videos, err := videocollectionmediamod.FindManyVideoCollectionMediaModels(ctx, bson.M{
			videocollectionmediamod.FN.VideoCollectionMediaModel.CollectionID: req.CollectionID,
			videocollectionmediamod.FN.VideoCollectionMediaModel.VideoId:      bson.M{"$in": req.VideoIds},
		})
		if err != nil {
			return err
		}
		existVideoIds := make(map[int64]struct{}, len(videos))
		for _, video := range videos {
			existVideoIds[video.VideoId] = struct{}{}
		}
		addIds := make([]int64, 0, len(req.VideoIds))
		for _, id := range req.VideoIds {
			if _, ok := existVideoIds[id]; !ok {
				addIds = append(addIds, id)
				existVideoIds[id] = struct{}{}
			}
		}
		if len(addIds) > 0 {
			now := time.Now()
			addInfos := make(videocollectionmediamod.VideoCollectionMediaModelList, 0, len(addIds))
			for _, id := range addIds {
				addInfos = append(addInfos, &videocollectionmediamod.VideoCollectionMediaModel{
					ID:           primitive.NewObjectID(),
					CollectionID: req.CollectionID,
					VideoId:      id,
					Status:       pubdef.InformationStatusVerifyOK,
					Rank:         0,
					CreatedAt:    now,
					UpdatedAt:    now,
				})
			}
			err = videocollectionmediamod.InsertManyVideoCollectionMedia(ctx, addInfos)
			if err != nil {
				return err
			}
		}
	} else {
		// 移除视频
		_, err = videocollectionmediamod.DelManyVideoCollectionMediaModel(ctx, bson.M{
			videocollectionmediamod.FN.VideoCollectionMediaModel.CollectionID: req.CollectionID,
			videocollectionmediamod.FN.VideoCollectionMediaModel.VideoId:      bson.M{"$in": req.VideoIds},
		})
		if err != nil {
			return err
		}
	}
	count, err := videocollectionmediamod.CountVideoCollectionMediaModels(ctx, bson.M{
		videocollectionmediamod.FN.VideoCollectionMediaModel.CollectionID: req.CollectionID,
	})
	if err == nil {
		_ = videoinformationmod.UpdateOneVideoInformation(ctx, bson.M{
			videoinformationmod.FN.VideoInformation.Id: req.CollectionID,
		}, bson.M{"$set": bson.M{
			videoinformationmod.FN.VideoInformation.VideoCount: count,
			videoinformationmod.FN.VideoInformation.UpdatedAt:  time.Now(),
		}})
	}
	return nil
}

func UpdateCollectionMediaRank(ctx context.Context, req *UpdateCollectionMediaRankReq) *srvdef.SrvErr {
	err := videocollectionmediamod.UpdateOneVideoCollectionMediaModel(ctx, bson.M{
		videocollectionmediamod.FN.VideoCollectionMediaModel.CollectionID: req.CollectionID,
		videocollectionmediamod.FN.VideoCollectionMediaModel.VideoId:      req.VideoId,
	}, bson.M{"$set": bson.M{
		videocollectionmediamod.FN.VideoCollectionMediaModel.Rank: req.Rank,
	}})
	return err
}

func GetCollectionMediaList(ctx context.Context, req *GetCollectionMediaListReq) (*GetCollectionMediaListResp, *srvdef.SrvErr) {
	_, err := videoinformationmod.FindOneVideoInformation(ctx, bson.M{
		videoinformationmod.FN.VideoInformation.Id:        req.CollectionID,
		videoinformationmod.FN.VideoInformation.MediaType: videoinformationmod.MediaType_Collection,
	})
	if err != nil {
		return nil, err
	}
	opts := &options.FindOptions{}
	opts.SetSort(bson.M{videocollectionmediamod.FN.VideoCollectionMediaModel.Rank: 1})
	opts.SetLimit(req.PageSize)
	opts.SetSkip((req.PageNum - 1) * req.PageSize)
	total, err := videocollectionmediamod.CountVideoCollectionMediaModels(ctx, bson.M{
		videocollectionmediamod.FN.VideoCollectionMediaModel.CollectionID: req.CollectionID,
	})
	if err != nil {
		return nil, err
	}
	if total == 0 {
		return &GetCollectionMediaListResp{
			Total: 0,
			List:  make([]CollectionMediaInfo, 0),
		}, nil
	}
	videos, err := videocollectionmediamod.FindManyVideoCollectionMediaModels(ctx, bson.M{
		videocollectionmediamod.FN.VideoCollectionMediaModel.CollectionID: req.CollectionID,
	}, opts)
	if err != nil {
		return nil, err
	}
	videoIds := make([]int64, 0, len(videos))
	for _, video := range videos {
		videoIds = append(videoIds, video.VideoId)
	}
	videoInfos, err := videoinformationmod.FindManyVideoInformations(ctx, bson.M{
		videoinformationmod.FN.VideoInformation.Id: bson.M{"$in": videoIds},
	})
	if err != nil {
		return nil, err
	}
	videoInfoMap := make(map[int64]*videoinformationmod.VideoInformation, len(videoInfos))
	for _, info := range videoInfos {
		videoInfoMap[info.Id] = info
	}
	infos := make([]CollectionMediaInfo, 0, len(videos))
	for _, video := range videos {
		info, ok := videoInfoMap[video.VideoId]
		if !ok {
			continue
		}
		infos = append(infos, CollectionMediaInfo{
			Id:        video.VideoId,
			Title:     info.Title,
			CoverImg:  info.CoverImg,
			Desc:      info.Desc,
			Remark:    info.Remark,
			Nodes:     info.Nodes,
			Status:    info.Status,
			Video:     info.Video,
			Rank:      video.Rank,
			UpdatedAt: video.UpdatedAt,
			CreatedAt: video.CreatedAt,
		})
	}
	resp := &GetCollectionMediaListResp{
		Total: total,
		List:  infos,
	}
	return resp, nil
}