package service

import (
	"context"
	"fmt"
	"gofaster/internal/auth/model"
	"gofaster/internal/auth/repository"

	"gorm.io/gorm"
)

type RoleService struct {
	roleRepo repository.RoleRepository
}

func NewRoleService(roleRepo repository.RoleRepository) *RoleService {
	return &RoleService{
		roleRepo: roleRepo,
	}
}

// CreateRole 创建角色
func (s *RoleService) CreateRole(ctx context.Context, role *model.Role) error {
	// 检查角色代码是否已存在
	existing, err := s.roleRepo.GetByCode(ctx, role.Code)
	if err != nil && err != gorm.ErrRecordNotFound {
		return fmt.Errorf("检查角色代码失败: %v", err)
	}
	if existing != nil {
		return fmt.Errorf("角色代码 %s 已存在", role.Code)
	}

	return s.roleRepo.Create(ctx, role)
}

// UpdateRole 更新角色
func (s *RoleService) UpdateRole(ctx context.Context, role *model.Role) error {
	// 检查角色是否存在
	existing, err := s.roleRepo.GetByID(ctx, role.ID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return fmt.Errorf("角色不存在")
		}
		return fmt.Errorf("查询角色失败: %v", err)
	}

	// 如果修改了代码，需要检查代码唯一性
	if existing.Code != role.Code {
		codeExists, err := s.roleRepo.GetByCode(ctx, role.Code)
		if err != nil && err != gorm.ErrRecordNotFound {
			return fmt.Errorf("检查角色代码失败: %v", err)
		}
		if codeExists != nil {
			return fmt.Errorf("角色代码 %s 已存在", role.Code)
		}
	}

	return s.roleRepo.Update(ctx, role)
}

// DeleteRole 删除角色
func (s *RoleService) DeleteRole(ctx context.Context, id uint) error {
	// 检查角色是否存在
	_, err := s.roleRepo.GetByID(ctx, id)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return fmt.Errorf("角色不存在")
		}
		return fmt.Errorf("查询角色失败: %v", err)
	}

	// 检查是否有用户在使用此角色
	users, err := s.roleRepo.GetUsersByRole(ctx, id)
	if err != nil {
		return fmt.Errorf("查询用户失败: %v", err)
	}

	if len(users) > 0 {
		return fmt.Errorf("无法删除正在使用的角色，有 %d 个用户在使用此角色", len(users))
	}

	return s.roleRepo.Delete(ctx, id)
}

// GetRole 获取角色详情
func (s *RoleService) GetRole(ctx context.Context, id uint) (*model.Role, error) {
	return s.roleRepo.GetByID(ctx, id)
}

// ListRoles 获取角色列表
func (s *RoleService) ListRoles(ctx context.Context, page, pageSize int) ([]*model.Role, int64, error) {
	offset := (page - 1) * pageSize
	return s.roleRepo.List(ctx, offset, pageSize)
}

// AssignRolesToUser 为用户分配角色
func (s *RoleService) AssignRolesToUser(ctx context.Context, userID uint, roleIDs []uint) error {
	// 检查角色是否都存在
	for _, roleID := range roleIDs {
		role, err := s.roleRepo.GetByID(ctx, roleID)
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				return fmt.Errorf("角色ID %d 不存在", roleID)
			}
			return fmt.Errorf("查询角色失败: %v", err)
		}
		if role == nil {
			return fmt.Errorf("角色ID %d 不存在", roleID)
		}
	}

	// 分配角色
	return s.roleRepo.AssignRolesToUser(ctx, userID, roleIDs)
}

// GetUserRoles 获取用户的角色列表
func (s *RoleService) GetUserRoles(ctx context.Context, userID uint) ([]*model.Role, error) {
	return s.roleRepo.GetUserRoles(ctx, userID)
}

// RemoveRolesFromUser 从用户移除角色
func (s *RoleService) RemoveRolesFromUser(ctx context.Context, userID uint, roleIDs []uint) error {
	return s.roleRepo.RemoveRolesFromUser(ctx, userID, roleIDs)
}