package mediabookshelfser

import (
	"91porn-server/app/service/mediaser"
	"91porn-server/common"
	"91porn-server/common/log"
	"91porn-server/middleware/ua"
	"91porn-server/models/cache/mediabookshelfdata"
	"91porn-server/models/commod"
	"91porn-server/models/v/mediabookshelfmod"
	"91porn-server/models/v/mediamod"
	"91porn-server/models/v/usermod"
	"errors"
	"time"

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

type AppQueryListReq struct {
	Type     string `json:"type" form:"type" binding:"required,oneof=video image text drama"` // 类型 "video":动漫,"image":漫画,"text":小说,"drama":短剧
	SortType int    `json:"sortType" form:"sortType"`                                         // 排序 0、最新收藏 1.最近更新
	commod.Page
}

type AppListRes struct {
	Total   int64                              `json:"total" bson:"total"`     // 总数
	HasNext bool                               `json:"hasNext" bson:"hasNext"` // 是否有下一页
	List    []mediabookshelfdata.AppSimpleData `json:"list" bson:"list"`       // 列表数据
}

// GetList 获取列表
func (p *AppQueryListReq) GetList(uid uint64) (any, error) {
	if p.Type == mediamod.MediaTypeDrama {
		return p.getDramaList(uid)
	}
	if p.SortType == 0 {
		return p.getListByCreateAt(uid)
	}
	// 按照更新时间获取
	// 获取列表
	filter := bson.M{"shelfType": p.Type, "uid": uid}
	data, _, _, err := mediabookshelfdata.GetListFromCache(uid, filter, 0, 100, bson.D{})
	if err != nil {
		log.Error("获取媒体书架列表列表数据错误", log.Any("Params", *p), log.E(err))
		return nil, err
	}
	ids := []primitive.ObjectID{}
	for _, v := range data {
		ids = append(ids, v.MID)
	}
	// 按照子集更新时间来排
	res := AppListRes{}
	res.List = mediabookshelfdata.FormatAppSimpleDataList(data, int64(p.Skip()), int64(p.Limit()), bson.D{{Key: "contentUpdateTime", Value: -1}})
	return res, nil
}

func (p *AppQueryListReq) getDramaList(uid uint64) (res struct {
	Total   int64                    `json:"total"`
	HasNext bool                     `json:"hasNext"`
	List    []*mediamod.AppMediaBase `json:"list"`
}, err error) {
	ids, total, hasNext, err := mediabookshelfmod.GetDramaMediaIDs(
		uid, int64(p.Skip()), int64(p.Limit()), p.SortType == 1,
	)
	if err != nil {
		return res, err
	}
	_, mediaMap, err := mediamod.GetListByIds(ids)
	if err != nil {
		return res, err
	}
	ordered := make([]*mediamod.Media, 0, len(ids))
	for _, id := range ids {
		media, ok := mediaMap[id]
		if !ok || media.MediaType != mediamod.MediaTypeDrama || media.Status != 1 || media.IsDelete {
			continue
		}
		copy := media
		ordered = append(ordered, &copy)
	}
	res.Total = total
	res.HasNext = hasNext
	res.List = mediaser.FillMedias(ordered, uid, true)
	if res.List == nil {
		res.List = make([]*mediamod.AppMediaBase, 0)
	}
	return res, nil
}

func (p *AppQueryListReq) getListByCreateAt(uid uint64) (res AppListRes, err error) {

	filter := bson.M{"shelfType": p.Type, "uid": uid}
	sort := bson.D{{"readAt", -1}, {"_id", -1}}
	// 获取列表
	var data []mediabookshelfmod.MediaBookshelf
	data, res.Total, res.HasNext, err = mediabookshelfdata.GetListFromCache(uid, filter, int64(p.Skip()), int64(p.Limit()), sort)
	if err != nil {
		log.Error("获取媒体书架列表列表数据错误", log.Any("Params", *p), log.E(err))
		return
	}
	res.List = mediabookshelfdata.FormatAppSimpleDataList(data, 0, int64(len(data)), bson.D{})

	return
}

type AppAddBookshelfReq struct {
	Id string `json:"id" form:"id"` // 媒体ID
}

// Add 添加入书架
func (p *AppAddBookshelfReq) Add(uid uint64, ua ua.UA, ip string) (err error) {
	oid, err := primitive.ObjectIDFromHex(p.Id)
	if err != nil {
		return err
	}

	// 获取媒体
	mediaInfo, err := mediamod.GetInfo(oid)
	if err != nil {
		return err
	}

	if mediaInfo.ID.IsZero() {
		return errors.New("media is not exist")
	}
	if mediaInfo.MediaType == mediamod.MediaTypeDrama && (mediaInfo.Status != 1 || mediaInfo.IsDelete) {
		return errors.New("drama is inactive")
	}
	//// 获取当前用户书架里的书的数量
	//total, err := mediabookshelfmod.GetCount(uid)
	//if err != nil {
	//	return
	//}
	//user, err := usermod.FindUserByUID(uid)
	//if err != nil {
	//	return
	//}
	//if (user.VipLevel > 0 && total >= 100) || (user.VipLevel == 0 && total >= 30) {
	//	log.Info("加入书架失败,超过数量限制", log.Any("uid", uid), log.Any("vipLvel", user.VipLevel), log.Any("total", total))
	//	return errors.New("加入失败")
	//}
	// 获取是否添加书架
	filter := bson.M{"uid": uid, "mid": mediaInfo.ID}
	info, err := mediabookshelfmod.GetInfoByCond(filter)
	if err != nil {
		return err
	}
	if !info.ID.IsZero() {
		return errors.New("book already added")
	}

	now := time.Now()
	// 添加数据记录
	data := mediabookshelfmod.MediaBookshelf{
		ShelfType:  mediaInfo.MediaType,
		MID:        mediaInfo.ID,
		UID:        uid,
		IsDelete:   false,
		ReadAt:     now,
		UpdateTime: now,
		CreatedAt:  now,
	}

	// 创建数据
	if _, err := mediabookshelfdata.InsertData(nil, uid, data); err != nil {
		return err
	}
	common.Go(func() {
		mediamod.IncCollectCount(mediaInfo.ID, 1)
	})
	return nil
}

type AppDelBookshelfReq struct {
	Id string `json:"id" bson:"id"` // 媒体id
}

// Del 删除书架中书籍
func (p *AppDelBookshelfReq) Del(uid uint64, ua ua.UA, ip string) (err error) {
	user, err := usermod.FindUserByUID(uid)
	if err != nil {
		return err
	}
	if user == nil || user.ID.IsZero() {
		return errors.New("user is not exist")
	}

	oid, _ := primitive.ObjectIDFromHex(p.Id)
	// 获取媒体
	mediaInfo, err := mediamod.GetInfo(oid)
	if err != nil {
		return err
	}

	filter := bson.M{"mid": oid, "uid": uid}
	err = mediabookshelfdata.DeleteDataByCond(nil, uid, filter)
	if err != nil {
		return err
	}

	common.Go(func() {

		mediamod.IncCollectCount(mediaInfo.ID, -1)

	})

	return nil
}

type AppDelBatchBookshelfReq struct {
	IDS []primitive.ObjectID `json:"ids" bson:"ids"` // acg的id
}

// Del 删除书架中书籍
func (p *AppDelBatchBookshelfReq) Del(uid uint64) (err error) {
	user, err := usermod.FindUserByUID(uid)
	if err != nil {
		return err
	}
	if user == nil || user.ID.IsZero() {
		return errors.New("user is not exist")
	}

	err = mediabookshelfdata.DeleteDataByIds(nil, uid, p.IDS)
	if err != nil {
		return err
	}
	go func() {
		for _, id := range p.IDS {
			mediamod.IncCollectCount(id, -1)
		}
	}()
	return nil
}