package service

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/google/uuid"
	"github.com/muyuqingfeng/iloom/auth-service/internal/model"
	"github.com/muyuqingfeng/iloom/auth-service/internal/repository"
	sgrpc "github.com/muyuqingfeng/iloom/shared/pkg/grpc"
)

type MemberService struct {
	memberRepo *repository.MemberRepo
	sysClient  *sgrpc.SystemClient
}

func NewMemberService(memberRepo *repository.MemberRepo, sysClient *sgrpc.SystemClient) *MemberService {
	return &MemberService{
		memberRepo: memberRepo,
		sysClient:  sysClient,
	}
}

type CreateMemberRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
	RealName string `json:"real_name"`
	Phone    string `json:"phone"`
}

func (s *MemberService) List(ctx context.Context, companyID string) ([]model.Profile, error) {
	return s.memberRepo.ListByCompany(ctx, companyID)
}

func (s *MemberService) Create(ctx context.Context, companyID, roleKey string, req CreateMemberRequest) (*model.Profile, error) {
	roleID := roleIDMap[roleKey]

	userID, err := s.sysClient.CreateUser(ctx, req.Username, req.Password, req.RealName, req.Phone, roleID)
	if err != nil {
		return nil, fmt.Errorf("create user: %w", err)
	}

	now := time.Now()
	member := &model.CompanyMember{
		ID:        uuid.New().String(),
		CompanyID: companyID,
		UserID:    userID,
		Role:      "member",
		CreatedAt: now,
	}
	if err := s.memberRepo.Create(ctx, member); err != nil {
		return nil, fmt.Errorf("create member: %w", err)
	}

	return &model.Profile{
		ID:        userID,
		Username:  req.Username,
		RealName:  req.RealName,
		Phone:     req.Phone,
		CompanyID: companyID,
		CreatedAt: now,
	}, nil
}

func (s *MemberService) Delete(ctx context.Context, memberID, companyID string) error {
	member, err := s.memberRepo.GetByUserAndCompany(ctx, memberID, companyID)
	if err != nil {
		return fmt.Errorf("get member: %w", err)
	}
	if member == nil {
		return errors.New("member not found")
	}

	return s.memberRepo.Delete(ctx, member.ID, companyID)
}