package logic

import (
	"context"
	"errors"

	"spark-server/internal/module/group/entity"
	"spark-server/internal/pkg/errs"
)

func (s *Service) PurgeUser(ctx context.Context, userID int64) error {
	if s == nil || s.repo == nil || userID <= 0 {
		return nil
	}
	groups, err := s.repo.ListAllActiveByUser(ctx, userID)
	if err != nil {
		return err
	}
	for _, g := range groups {
		if g == nil {
			continue
		}
		if g.OwnerID == userID {
			if err := s.handOffOwnedGroup(ctx, userID, g); err != nil {
				return err
			}
			continue
		}
		if err := s.repo.RemoveMember(ctx, g.ID, userID); err != nil && !errors.Is(err, errs.ErrNotFound) {
			return err
		}
		s.invalidateMembers(g.ConversationID)
	}
	return nil
}

func (s *Service) handOffOwnedGroup(ctx context.Context, ownerID int64, g *entity.Group) error {
	members, err := s.repo.ListMembers(ctx, g.ID, entity.MemberListMax)
	if err != nil {
		return err
	}
	next := successorOwnerID(ownerID, members)
	if next == 0 {
		err := s.Dissolve(ctx, ownerID, g.ID)
		if err != nil && !errors.Is(err, errs.ErrNotFound) {
			return err
		}
		return nil
	}
	if _, err := s.Transfer(ctx, ownerID, g.ID, &TransferInput{UID: next}); err != nil {
		return err
	}
	if err := s.RemoveMember(ctx, ownerID, g.ID, ownerID); err != nil && !errors.Is(err, errs.ErrNotFound) {
		return err
	}
	return nil
}

func successorOwnerID(ownerID int64, members []*entity.Member) int64 {
	var firstOther int64
	for _, m := range members {
		if m == nil || m.UserID == ownerID {
			continue
		}
		if m.Role == entity.RoleAdmin {
			return m.UserID
		}
		if firstOther == 0 {
			firstOther = m.UserID
		}
	}
	return firstOther
}