package logic

import (
	"context"

	"spark-server/internal/module/friend/entity"
	userentity "spark-server/internal/module/user/entity"
	"spark-server/internal/pkg/errs"
)

type UserCard struct {
	UID      int64             `json:"uid"`
	SparkID  string            `json:"spark_id"`
	Nickname string            `json:"nickname"`
	Avatar   string            `json:"avatar"`
	Gender   userentity.Gender `json:"gender"`
}

type FriendView struct {
	UserCard
	Remark    string              `json:"remark"`
	Relation  entity.RelationKind `json:"relation"`
	Blocked   bool                `json:"blocked"`
	Pinned    bool                `json:"pinned"`
	CreatedAt int64               `json:"created_at,omitempty"`
}

type FriendList struct {
	Items []*FriendView `json:"items"`
}

func cardOf(u *userentity.User) UserCard {
	if u == nil {
		return UserCard{}
	}
	return UserCard{
		UID: u.ID, SparkID: u.SparkID, Nickname: u.Nickname,
		Avatar: u.Avatar, Gender: u.Gender,
	}
}

func viewOf(u *userentity.User, rel *entity.Relation) *FriendView {
	v := &FriendView{UserCard: cardOf(u), Relation: entity.RelationNone}
	if rel == nil {
		return v
	}
	v.Remark = rel.Remark
	v.Blocked = rel.Blocked
	v.Pinned = rel.Pinned
	v.Relation = entity.ViewRelation(rel.Active(), rel.Blocked)
	if rel.Active() {
		v.CreatedAt = entity.UnixMS(rel.CreatedAt)
	}
	return v
}

func (s *Service) List(ctx context.Context, userID int64, limit int) (*FriendList, error) {
	if !s.ready() || userID <= 0 {
		return nil, errs.ErrUnauthorized
	}
	rels, err := s.repo.ListFriends(ctx, userID, entity.ClampLimit(limit))
	if err != nil {
		return nil, err
	}
	items := make([]*FriendView, 0, len(rels))
	for _, rel := range rels {
		u, err := s.users.Get(ctx, rel.FriendID)
		if err != nil {
			continue
		}
		items = append(items, viewOf(u, rel))
	}
	return &FriendList{Items: items}, nil
}

func (s *Service) Get(ctx context.Context, userID, friendID int64) (*FriendView, error) {
	if !s.ready() || userID <= 0 {
		return nil, errs.ErrUnauthorized
	}
	if friendID <= 0 {
		return nil, errs.ErrInvalidArgument
	}
	rel, err := s.repo.GetRelation(ctx, userID, friendID)
	if err != nil {
		return nil, err
	}
	if !rel.Active() {
		return nil, errs.ErrNotFound
	}
	u, err := s.activeUser(ctx, friendID)
	if err != nil {
		return nil, err
	}
	return viewOf(u, rel), nil
}