package cv

import (
	"hilo-algoCenter/common/mysql"
	"hilo-algoCenter/protocol/userProxy"
)

type CvUserTinyVipLike struct {
	CvUserTinyVip
	//是否喜欢别人
	IsLike bool `json:"isLike"`
	//别人是否喜欢我
	IsLikeMe bool `json:"isLikeMe"`
}

func GetUserTinyVipLikes(myUserId uint64, userIds []uint64) ([]CvUserTinyVipLike, error) {
	if len(userIds) == 0 {
		return []CvUserTinyVipLike{}, nil
	}
	userTinyVipMap, err := GetUserTinyVipMap(userIds)
	if err != nil {
		return nil, err
	}
	iLikeMap, err := CheckILike(myUserId, userIds)
	if err != nil {
		return nil, err
	}
	//
	likeMeMap, err := CheckLikeMe(myUserId, userIds)
	if err != nil {
		return nil, err
	}
	results := make([]CvUserTinyVipLike, 0, len(userIds))
	for _, r := range userIds {
		results = append(results, CvUserTinyVipLike{
			CvUserTinyVip: userTinyVipMap[r],
			IsLike:        iLikeMap[r],
			IsLikeMe:      likeMeMap[r],
		})
	}
	return results, nil
}


// GetOtherUserInfo 获取otherUserId的信息
// param myUserId:用来判断喜欢/被喜欢等关系
// param otherUserId:需要获取的用户
func GetOtherUserInfo(myUserId, otherUserId uint64) (*userProxy.User, error) {
	otherUser, err := GetUserTinyVipLikes(myUserId, []uint64{otherUserId})
	if err != nil {
		return nil, err
	}
	if len(otherUser) <= 0 {
		return nil, err
	}
	otherUserInfo := otherUser[0]
	var birthday uint64
	if otherUserInfo.Birthday != nil {
		birthday = *otherUserInfo.Birthday
	}
	return &userProxy.User{
		Id:          otherUserInfo.Id,
		ExternalId:  otherUserInfo.ExternalId,
		Nick:        otherUserInfo.Nick,
		Avatar:      otherUserInfo.Avatar,
		Country:     otherUserInfo.Country,
		CountryIcon: otherUserInfo.CountryIcon,
		Birthday:    birthday,
		IsVip:       otherUserInfo.IsVip,
		IsLike:      otherUserInfo.IsLike,
		IsLikeMe:    otherUserInfo.IsLikeMe,
	}, nil
}

//用户喜欢
type UserLike struct {
	mysql.Entity
	UserId     mysql.ID
	LikeUserId mysql.ID
	SceneType  mysql.Type
}

func CheckILike(myUserId uint64, userIds []uint64) (map[uint64]bool, error) {
	var userLikes []UserLike
	if err := mysql.Db.Model(&UserLike{}).Where(&UserLike{
		UserId: myUserId,
	}).Where("like_user_id in (?)", userIds).Find(&userLikes).Error; err != nil {
		return nil, err
	}
	m := map[uint64]struct{}{}
	for _, r := range userLikes {
		m[r.LikeUserId] = struct{}{}
	}
	result := make(map[uint64]bool, len(userIds))
	for _, r := range userIds {
		_, flag := m[r]
		result[r] = flag
	}
	return result, nil
}

func CheckLikeMe(myUserId uint64, userIds []uint64) (map[uint64]bool, error) {
	var userLikes []UserLike
	if err := mysql.Db.Model(&UserLike{}).Where(&UserLike{
		LikeUserId: myUserId,
	}).Where("user_id in (?)", userIds).Find(&userLikes).Error; err != nil {
		return nil, err
	}
	m := map[uint64]struct{}{}
	for _, r := range userLikes {
		m[r.UserId] = struct{}{}
	}
	result := make(map[uint64]bool, len(userIds))
	for _, r := range userIds {
		_, flag := m[r]
		result[r] = flag
	}
	return result, nil
}