package service

import (
	"fmt"

	"filestoragesystem/internal/model"
	"filestoragesystem/internal/repository"
	"filestoragesystem/pkg/apperr"
)

// RoleService 角色权限服务
type RoleService struct {
	roleRepo *repository.RoleRepo
	permRepo *repository.PermissionRepo
}

// ListRoles 角色列表
func (s *RoleService) ListRoles() ([]model.Role, error) {
	return s.roleRepo.List()
}

// GetRole 角色详情(含权限)
func (s *RoleService) GetRole(id uint) (*model.Role, error) {
	r, err := s.roleRepo.FindByID(id)
	if err != nil {
		return nil, apperr.ErrNotFound
	}
	return r, nil
}

// CreateRole 创建角色
func (s *RoleService) CreateRole(name, code, description string, permIDs []uint) (*model.Role, error) {
	if name == "" || code == "" {
		return nil, fmt.Errorf("角色名称和编码不能为空")
	}
	if _, err := s.roleRepo.FindByCode(code); err == nil {
		return nil, fmt.Errorf("角色编码已存在")
	}
	role := &model.Role{
		Name: name, Code: code, Description: description,
		IsSystem: false, Status: 1,
		Permissions: s.mustPerms(permIDs),
	}
	if err := s.roleRepo.Create(role); err != nil {
		return nil, err
	}
	return role, nil
}

// UpdateRole 编辑角色(系统角色仅允许改描述与权限)
func (s *RoleService) UpdateRole(id uint, name, description string, permIDs []uint) (*model.Role, error) {
	role, err := s.roleRepo.FindByID(id)
	if err != nil {
		return nil, apperr.ErrNotFound
	}
	if role.Code == "super_admin" {
		return nil, apperr.ErrSystemRole
	}
	if name != "" && !role.IsSystem {
		role.Name = name
	}
	if description != "" {
		role.Description = description
	}
	if err := s.roleRepo.Update(role); err != nil {
		return nil, err
	}
	if permIDs != nil {
		if err := s.roleRepo.ReplacePermissions(id, permIDs); err != nil {
			return nil, err
		}
	}
	return s.roleRepo.FindByID(id)
}

// DeleteRole 删除角色(系统角色不可删，有用户的角色不可删)
func (s *RoleService) DeleteRole(id uint) error {
	role, err := s.roleRepo.FindByID(id)
	if err != nil {
		return apperr.ErrNotFound
	}
	if role.IsSystem {
		return apperr.ErrSystemRole
	}
	if n, _ := s.roleRepo.CountUsersByRole(id); n > 0 {
		return fmt.Errorf("该角色下仍有 %d 个用户，无法删除", n)
	}
	return s.roleRepo.Delete(id)
}

// SetPermissions 配置角色权限
func (s *RoleService) SetPermissions(id uint, permIDs []uint) error {
	role, err := s.roleRepo.FindByID(id)
	if err != nil {
		return apperr.ErrNotFound
	}
	if role.Code == "super_admin" {
		return apperr.ErrSystemRole
	}
	return s.roleRepo.ReplacePermissions(id, permIDs)
}

// ListPermissions 全部权限
func (s *RoleService) ListPermissions() ([]model.Permission, error) {
	return s.permRepo.List()
}

// PermissionsGrouped 按模块分组权限
func (s *RoleService) PermissionsGrouped() (map[string][]model.Permission, []string, error) {
	perms, err := s.permRepo.List()
	if err != nil {
		return nil, nil, err
	}
	groups := make(map[string][]model.Permission)
	var order []string
	seen := make(map[string]bool)
	for _, p := range perms {
		if !seen[p.Module] {
			seen[p.Module] = true
			order = append(order, p.Module)
		}
		groups[p.Module] = append(groups[p.Module], p)
	}
	return groups, order, nil
}

func (s *RoleService) mustPerms(ids []uint) []model.Permission {
	if len(ids) == 0 {
		return nil
	}
	perms, err := s.permRepo.ListByIDs(ids)
	if err != nil {
		return nil
	}
	return perms
}