package auth

import (
	"context"
	"errors"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
	"nl-video-api/internal/dao"
	"nl-video-api/internal/model/entity"
)

// RoleService 角色服务
type RoleService struct{}

var Role = &RoleService{}

// RoleCreateReq 创建角色请求
type RoleCreateReq struct {
	Name        string `json:"name" v:"required|length:2,50#角色名称不能为空|角色名称长度为2-50位"`
	Slug        string `json:"slug" v:"required|length:2,50#角色标识不能为空|角色标识长度为2-50位"`
	Level       int    `json:"level" v:"required|min:1,max:10#角色等级不能为空|角色等级范围1-10"`
	Description string `json:"description"` // 角色描述
	Sort        int    `json:"sort"`        // 排序
	Status      int    `json:"status" v:"in:0,1#状态只能为0或1"`
	IsSystem    int    `json:"is_system" v:"in:0,1#系统角色标识只能为0或1"`
}

// RoleUpdateReq 更新角色请求
type RoleUpdateReq struct {
	Id          int    `json:"id" v:"required|min:1#角色ID不能为空"`
	Name        string `json:"name" v:"required|length:2,50#角色名称不能为空|角色名称长度为2-50位"`
	Slug        string `json:"slug" v:"required|length:2,50#角色标识不能为空|角色标识长度为2-50位"`
	Level       int    `json:"level" v:"required|min:1,max:10#角色等级不能为空|角色等级范围1-10"`
	Description string `json:"description"` // 角色描述
	Sort        int    `json:"sort"`        // 排序
	Status      int    `json:"status" v:"in:0,1#状态只能为0或1"`
	IsSystem    int    `json:"is_system" v:"in:0,1#系统角色标识只能为0或1"`
}

// RolePermissionReq 角色权限分配请求
type RolePermissionReq struct {
	RoleId        int   `json:"role_id" v:"required|min:1#角色ID不能为空"`
	PermissionIds []int `json:"permission_ids"` // 权限ID列表
}

// Create 创建角色
func (s *RoleService) Create(ctx context.Context, req *RoleCreateReq) (int, error) {
	// 检查角色标识是否存在
	exists, err := dao.Role.CheckCodeExists(ctx, req.Slug, 0)
	if err != nil {
		return 0, err
	}
	if exists {
		return 0, errors.New("角色标识已存在")
	}
	
	// 创建角色数据
	role := &entity.Role{
		Name:        req.Name,
		Slug:        req.Slug,
		Level:       req.Level,
		Description: req.Description,
		Sort:        req.Sort,
		Status:      req.Status,
		IsSystem:    req.IsSystem,
		CreatedAt:   gtime.Now().String(),
		UpdatedAt:   gtime.Now().String(),
	}
	
	return dao.Role.Create(ctx, role)
}

// Update 更新角色
func (s *RoleService) Update(ctx context.Context, req *RoleUpdateReq) error {
	// 检查角色是否存在
	role, err := dao.Role.GetById(ctx, req.Id)
	if err != nil {
		return err
	}
	if role == nil {
		return errors.New("角色不存在")
	}
	
	// 系统角色不允许修改标识和系统标识
	if role.IsSystem == 1 {
		if req.Slug != role.Slug {
			return errors.New("系统角色不允许修改标识")
		}
		if req.IsSystem != role.IsSystem {
			return errors.New("系统角色不允许修改系统标识")
		}
	}
	
	// 检查角色标识是否存在（排除自己）
	exists, err := dao.Role.CheckCodeExists(ctx, req.Slug, req.Id)
	if err != nil {
		return err
	}
	if exists {
		return errors.New("角色标识已存在")
	}
	
	// 更新数据
	updateData := g.Map{
		"name":        req.Name,
		"slug":        req.Slug,
		"level":       req.Level,
		"description": req.Description,
		"sort":        req.Sort,
		"status":      req.Status,
		"is_system":   req.IsSystem,
		"updated_at":  gtime.Now().String(),
	}
	
	return dao.Role.Update(ctx, req.Id, updateData)
}

// GetById 获取角色详情
func (s *RoleService) GetById(ctx context.Context, id int) (*entity.Role, error) {
	return dao.Role.GetById(ctx, id)
}

// GetList 获取角色列表
func (s *RoleService) GetList(ctx context.Context, req *dao.RoleListReq) ([]*entity.Role, int, error) {
	return dao.Role.GetList(ctx, req)
}

// GetAll 获取所有角色
func (s *RoleService) GetAll(ctx context.Context) ([]*entity.Role, error) {
	return dao.Role.GetAll(ctx)
}

// Delete 删除角色
func (s *RoleService) Delete(ctx context.Context, id int) error {
	// 检查角色是否存在
	role, err := dao.Role.GetById(ctx, id)
	if err != nil {
		return err
	}
	if role == nil {
		return errors.New("角色不存在")
	}
	
	// 系统角色不允许删除
	if role.IsSystem == 1 {
		return errors.New("系统角色不允许删除")
	}
	
	// 检查是否有管理员使用该角色
	// 这里需要查询管理员表，暂时跳过
	
	return dao.Role.Delete(ctx, id)
}

// AssignPermissions 为角色分配权限
func (s *RoleService) AssignPermissions(ctx context.Context, req *RolePermissionReq) error {
	// 检查角色是否存在
	role, err := dao.Role.GetById(ctx, req.RoleId)
	if err != nil {
		return err
	}
	if role == nil {
		return errors.New("角色不存在")
	}
	
	// 验证权限ID是否有效
	if len(req.PermissionIds) > 0 {
		permissions, err := dao.Permission.GetPermissionsByIds(ctx, req.PermissionIds)
		if err != nil {
			return err
		}
		if len(permissions) != len(req.PermissionIds) {
			return errors.New("存在无效的权限ID")
		}
	}
	
	return dao.Role.AssignPermissions(ctx, req.RoleId, req.PermissionIds)
}

// GetRolePermissions 获取角色权限
func (s *RoleService) GetRolePermissions(ctx context.Context, roleId int) ([]*entity.Permission, error) {
	// 检查角色是否存在
	role, err := dao.Role.GetById(ctx, roleId)
	if err != nil {
		return nil, err
	}
	if role == nil {
		return nil, errors.New("角色不存在")
	}
	
	return dao.Role.GetRolePermissions(ctx, roleId)
}

// GetRolePermissionIds 获取角色权限ID列表
func (s *RoleService) GetRolePermissionIds(ctx context.Context, roleId int) ([]int, error) {
	permissions, err := s.GetRolePermissions(ctx, roleId)
	if err != nil {
		return nil, err
	}
	
	var permissionIds []int
	for _, permission := range permissions {
		permissionIds = append(permissionIds, permission.Id)
	}
	
	return permissionIds, nil
}

// BatchUpdateStatus 批量更新角色状态
func (s *RoleService) BatchUpdateStatus(ctx context.Context, ids []int, status int) error {
	if len(ids) == 0 {
		return errors.New("请选择要操作的角色")
	}
	
	// 检查是否包含系统角色
	roles, err := dao.Role.GetRolesByIds(ctx, ids)
	if err != nil {
		return err
	}
	
	for _, role := range roles {
		if role.IsSystem == 1 {
			return errors.New("不能修改系统角色状态")
		}
	}
	
	// 批量更新
	successCount := 0
	for _, id := range ids {
		updateData := g.Map{
			"status":     status,
			"updated_at": gtime.Now().String(),
		}
		if err := dao.Role.Update(ctx, id, updateData); err != nil {
			g.Log().Errorf(ctx, "批量更新角色状态失败: ID=%d, 错误=%v", id, err)
		} else {
			successCount++
		}
	}
	
	if successCount == 0 {
		return errors.New("批量更新失败")
	}
	
	return nil
}

// CopyRole 复制角色
func (s *RoleService) CopyRole(ctx context.Context, sourceId int, newName, newSlug string) (int, error) {
	// 检查源角色是否存在
	sourceRole, err := dao.Role.GetById(ctx, sourceId)
	if err != nil {
		return 0, err
	}
	if sourceRole == nil {
		return 0, errors.New("源角色不存在")
	}
	
	// 检查新角色标识是否存在
	exists, err := dao.Role.CheckCodeExists(ctx, newSlug, 0)
	if err != nil {
		return 0, err
	}
	if exists {
		return 0, errors.New("角色标识已存在")
	}
	
	// 创建新角色
	newRole := &entity.Role{
		Name:        newName,
		Slug:        newSlug,
		Level:       sourceRole.Level,
		Description: sourceRole.Description + " (复制)",
		Sort:        sourceRole.Sort,
		Status:      1, // 默认启用
		IsSystem:    0, // 复制的角色不是系统角色
		CreatedAt:   gtime.Now().String(),
		UpdatedAt:   gtime.Now().String(),
	}
	
	newRoleId, err := dao.Role.Create(ctx, newRole)
	if err != nil {
		return 0, err
	}
	
	// 复制权限
	sourcePermissions, err := dao.Role.GetRolePermissions(ctx, sourceId)
	if err != nil {
		return newRoleId, err // 角色创建成功，但权限复制失败
	}
	
	if len(sourcePermissions) > 0 {
		var permissionIds []int
		for _, permission := range sourcePermissions {
			permissionIds = append(permissionIds, permission.Id)
		}
		
		err = dao.Role.AssignPermissions(ctx, newRoleId, permissionIds)
		if err != nil {
			g.Log().Errorf(ctx, "复制角色权限失败: 新角色ID=%d, 错误=%v", newRoleId, err)
		}
	}
	
	return newRoleId, nil
}

// GetRolesByLevel 根据等级获取角色
func (s *RoleService) GetRolesByLevel(ctx context.Context, level int) ([]*entity.Role, error) {
	req := &dao.RoleListReq{
		Level:    level,
		Status:   1, // 只获取启用的角色
		Page:     0, // 不分页
		PageSize: 0,
	}
	
	roles, _, err := dao.Role.GetList(ctx, req)
	return roles, err
}

// CheckRoleExists 检查角色是否存在
func (s *RoleService) CheckRoleExists(ctx context.Context, id int) (bool, error) {
	role, err := dao.Role.GetById(ctx, id)
	if err != nil {
		return false, err
	}
	return role != nil, nil
}