package logic

import (
	"context"
	"errors"

	"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   int    `json:"gender"`
}

type FriendView struct {
	UserCard
	Remark    string `json:"remark"`
	Relation  int    `json:"relation"`
	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 (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
	}
	ids := make([]int64, 0, len(rels))
	for _, rel := range rels {
		if other := rel.Other(userID); other > 0 {
			ids = append(ids, other)
		}
	}
	notes, err := s.repo.ListRemarks(ctx, userID, ids)
	if err != nil {
		return nil, err
	}
	items := make([]*FriendView, 0, len(rels))
	for _, rel := range rels {
		other := rel.Other(userID)
		u, err := s.users.Get(ctx, other)
		if err != nil {
			continue
		}
		items = append(items, &FriendView{
			UserCard:  cardOf(u),
			Remark:    notes[other],
			Relation:  entity.RelationFriend,
			CreatedAt: entity.UnixMS(rel.CreatedAt),
		})
	}
	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 {
		if errors.Is(err, errs.ErrNotFound) {
			return nil, errs.ErrNotFound
		}
		return nil, err
	}
	u, err := s.activeUser(ctx, friendID)
	if err != nil {
		return nil, err
	}
	remark, err := s.repo.GetRemark(ctx, userID, friendID)
	if err != nil {
		return nil, err
	}
	return &FriendView{
		UserCard:  cardOf(u),
		Remark:    remark,
		Relation:  entity.RelationFriend,
		CreatedAt: entity.UnixMS(rel.CreatedAt),
	}, nil
}