package officialWebsiteser

import (
	"91porn-server/common"
	"91porn-server/models/v/officialWebsitemod"
	"sync"

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

type HeroListReq struct {
	SortType int `json:"sortType" form:"sortType"` // 1: 最多粉丝，2: 最新加入，3：后管排序

	PageNumber int64 `json:"pageNumber" form:"pageNumber"`
	PageSize   int64 `json:"pageSize" form:"pageSize"`
}

type HeroListResp struct {
	HasNext bool        `json:"hasNext"`
	List    []*HeroResp `json:"list"`
}

type HeroResp struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	SeoSlug   string `json:"seoSlug"`
	Avatar    string `json:"avatar"`
	FansCount int64  `json:"fansCount"`
	Cover     string `json:"cover"`
}

func HeroList(req *HeroListReq) (resp HeroListResp, err error) {
	var sort = bson.M{}
	switch req.SortType {
	case 2:
		sort["createdAt"] = -1
	case 3:
		sort["sort"] = -1
	default:
		sort["fansCount"] = -1
	}

	// 分页查询时，查询一条多的数据来判断是否有下一页数据
	var skip, limit = transPageAndPageNumber(req.PageSize, req.PageNumber)
	var ops = options.Find().SetSort(sort).SetSkip(skip).SetLimit(limit + 1)
	data, err := (&officialWebsitemod.Hero{}).FindMany(bson.M{"isActive": true}, ops)
	if err != nil {
		return
	}

	resp = HeroListResp{
		HasNext: len(data) > int(limit),
		List:    make([]*HeroResp, 0),
	}
	for _, v := range data {
		hero := &HeroResp{
			ID:        v.ID.Hex(),
			Name:      v.Name,
			SeoSlug:   v.SeoSlug,
			Avatar:    v.Avatar,
			FansCount: v.FansCount,
			Cover:     v.Cover,
		}
		resp.List = append(resp.List, hero)
	}
	// 如果HasNext为true，说明还有下一页数，去除多查询的一条数据
	if resp.HasNext {
		resp.List = resp.List[:len(resp.List)-1]
	}

	return
}

type HeroDetailReq struct {
	ID string `uri:"id" binding:"required"`
}

type HeroDetailResp struct {
	ID          string              `json:"id"`
	Name        string              `json:"name"`
	SeoSlug     string              `json:"seoSlug"`
	Avatar      string              `json:"avatar"`
	Height      int64               `json:"height"`
	Bust        int64               `json:"bust"`
	Waist       int64               `json:"waist"`
	Hip         int64               `json:"hip"`
	Description string              `json:"description"`
	FansCount   int64               `json:"fansCount"`
	Cover       string              `json:"cover"`
	Partners    []HeroDetailPartner `json:"partners"`
	Albums      []HeroDetailAlbum   `json:"albums"`
	Videos      []HeroDetailVideo   `json:"videos"`
	Photograph  []Photograph        `json:"photograph"`
}

type HeroDetailAlbum struct {
	ID          string          `json:"id"`
	Title       string          `json:"title"`
	SeoSlug     string          `json:"seoSlug"`
	Description string          `json:"description"`
	Cover       string          `json:"cover"`
	Tags        []HeroDetailTag `json:"tags"`
	IsHot       bool            `json:"isHot"`
}

type HeroDetailVideo struct {
	ID          string          `json:"id"`
	Title       string          `json:"title"`
	SeoSlug     string          `json:"seoSlug"`
	Description string          `json:"description"`
	Cover       string          `json:"cover"`
	Url         string          `json:"url"`
	Tags        []HeroDetailTag `json:"tags"`
	IsHot       bool            `json:"isHot"`
}

type HeroDetailPartner struct {
	ID   string `json:"id"`
	Name string `json:"name"`
	Url  string `json:"url"`
	Logo string `json:"logo"`
}

type Photograph struct {
	ID          string   `json:"id" bson:"_id,omitempty"`
	Name        string   `json:"name" bson:"name"`
	Description string   `json:"description" bson:"description"`
	Cover       string   `json:"cover" bson:"cover"`
	Photos      []string `json:"photos" bson:"photos"`
}

type HeroDetailTag struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

func HeroDetail(req *HeroDetailReq) (resp *HeroDetailResp, err error) {
	filter := bson.M{"isActive": true}
	if id, e := primitive.ObjectIDFromHex(req.ID); e == nil {
		filter["_id"] = id
	} else {
		filter["seoSlug"] = req.ID
	}
	hero := &officialWebsitemod.Hero{}
	err = hero.FindOne(filter)
	if err != nil {
		return nil, err
	}

	resp = &HeroDetailResp{
		ID:          hero.ID.Hex(),
		Name:        hero.Name,
		SeoSlug:     hero.SeoSlug,
		Avatar:      hero.Avatar,
		Height:      hero.Height,
		Bust:        hero.Bust,
		Waist:       hero.Waist,
		Hip:         hero.Hip,
		Description: hero.Description,
		FansCount:   hero.FansCount,
		Cover:       hero.Cover,
		Partners:    make([]HeroDetailPartner, 0),
		Albums:      make([]HeroDetailAlbum, 0),
		Videos:      make([]HeroDetailVideo, 0),
	}

	wg := sync.WaitGroup{}
	wg.Add(4)

	// 查询合作伙伴
	common.Go(func() {
		defer wg.Done()
		resp.Partners, err = getHeroDetailPartners(hero.Partners)
		if err != nil {
			return
		}
	})

	// 查询专辑
	common.Go(func() {
		defer wg.Done()
		resp.Albums, err = getHeroDetailAlbums(hero.ID)
		if err != nil {
			return
		}
	})

	// 查询视频
	common.Go(func() {
		defer wg.Done()
		resp.Videos, err = getHeroDetailVideos(hero.ID)
		if err != nil {
			return
		}
	})
	common.Go(func() {
		defer wg.Done()
		resp.Photograph, err = getHeroDetailPhotograph(hero.ID)
	})
	wg.Wait()

	return
}

func getHeroDetailAlbums(heroID primitive.ObjectID) (albums []HeroDetailAlbum, err error) {
	var albumMod = &officialWebsitemod.Album{}
	var filters = bson.M{"heroID": heroID}
	albumsData, err := albumMod.FindMany(filters, options.Find().SetSort(bson.D{{Key: "isHot", Value: -1}, {Key: "createdAt", Value: -1}}).SetLimit(10))
	if err != nil {
		return nil, err
	}

	albums = make([]HeroDetailAlbum, 0)
	for _, v := range albumsData {
		tags := make([]HeroDetailTag, 0)
		for _, t := range v.Tags {
			tags = append(tags, HeroDetailTag{
				ID:   t.ID.Hex(),
				Name: t.Name,
			})
		}
		albums = append(albums, HeroDetailAlbum{
			ID:          v.ID.Hex(),
			Title:       v.Title,
			SeoSlug:     v.SeoSlug,
			Description: v.Description,
			Cover:       v.Cover,
			IsHot:       v.IsHot,
			Tags:        tags,
		})
	}

	return
}

func getHeroDetailVideos(heroID primitive.ObjectID) (videos []HeroDetailVideo, err error) {
	var videoMod = &officialWebsitemod.Video{}
	var filters = bson.M{"heroID": heroID}
	videosData, err := videoMod.FindMany(filters, options.Find().SetSort(bson.D{{Key: "isHot", Value: -1}, {Key: "createdAt", Value: -1}}).SetLimit(10))
	if err != nil {
		return nil, err
	}

	videos = make([]HeroDetailVideo, 0)
	for _, v := range videosData {
		tags := make([]HeroDetailTag, 0)
		for _, t := range v.Tags {
			tags = append(tags, HeroDetailTag{
				ID:   t.ID.Hex(),
				Name: t.Name,
			})
		}
		videos = append(videos, HeroDetailVideo{
			ID:          v.ID.Hex(),
			Title:       v.Title,
			SeoSlug:     v.SeoSlug,
			Description: v.Description,
			Cover:       v.Cover,
			Url:         v.Url,
			IsHot:       v.IsHot,
			Tags:        tags,
		})
	}

	return
}

func getHeroDetailPartners(partnerIds []primitive.ObjectID) (partners []HeroDetailPartner, err error) {
	var partnerMod = &officialWebsitemod.Partner{}
	var filters = bson.M{"_id": bson.M{"$in": partnerIds}, "isActive": true}
	partnersData, err := partnerMod.FindMany(filters)
	if err != nil {
		return nil, err
	}

	partners = make([]HeroDetailPartner, 0)
	for i := range partnerIds { // 保持合作伙伴的顺序和Hero中的一致，由后管控制
		for _, v := range partnersData {
			if v.ID == partnerIds[i] {
				partners = append(partners, HeroDetailPartner{
					ID:   v.ID.Hex(),
					Name: v.Name,
					Url:  v.Url,
					Logo: v.Logo,
				})
			}
		}
	}

	return
}

func getHeroDetailPhotograph(heroID primitive.ObjectID) (photograph []Photograph, err error) {
	var photographMod = &officialWebsitemod.Photograph{}
	var filters = bson.M{"heroId": heroID, "isActive": true}
	photographData, err := photographMod.FindMany(filters, options.Find().SetSort(bson.D{{Key: "createdAt", Value: -1}}).SetLimit(10))
	if err != nil {
		return
	}
	photograph = make([]Photograph, 0)
	for _, v := range photographData {
		ph := Photograph{
			ID:          v.ID.Hex(),
			Name:        v.Name,
			Description: v.Description,
			Cover:       v.Cover,
			Photos:      v.Photos,
		}
		photograph = append(photograph, ph)
	}
	return
}