package handler

import (
	"strconv"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"

	"dianshang/internal/model"
	"dianshang/internal/service"
	"dianshang/pkg/response"
)

type AdminRoleHandler struct {
	db          *gorm.DB
	roleService *service.RoleService
}

func NewAdminRoleHandler(db *gorm.DB, roleService *service.RoleService) *AdminRoleHandler {
	return &AdminRoleHandler{
		db:          db,
		roleService: roleService,
	}
}

// GetRoles 获取角色列表
func (h *AdminRoleHandler) GetRoles(c *gin.Context) {
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
	keyword := c.Query("keyword")
	status := c.Query("status")

	conditions := make(map[string]interface{})
	if keyword != "" {
		conditions["keyword"] = keyword
	}
	if status != "" {
		conditions["status"] = status
	}

	roles, pagination, err := h.roleService.GetRoleList(page, pageSize, conditions)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, gin.H{
		"list":       roles,
		"pagination": pagination,
	})
}

// GetRole 获取角色详情
func (h *AdminRoleHandler) GetRole(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的角色ID")
		return
	}

	role, err := h.roleService.GetRoleByID(uint(id))
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, role)
}

// CreateRole 创建角色
func (h *AdminRoleHandler) CreateRole(c *gin.Context) {
	var req struct {
		Name        string `json:"name" binding:"required"`
		Description string `json:"description"`
		Status      uint8  `json:"status"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数错误")
		return
	}

	role := &model.Role{
		Name:        req.Name,
		Description: req.Description,
		Status:      int(req.Status),
	}

	err := h.roleService.CreateRole(role)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, role)
}

// UpdateRole 更新角色
func (h *AdminRoleHandler) UpdateRole(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的角色ID")
		return
	}

	var req struct {
		Name        string `json:"name"`
		Description string `json:"description"`
		Status      uint8  `json:"status"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数错误")
		return
	}

	updates := make(map[string]interface{})
	if req.Name != "" {
		updates["name"] = req.Name
	}
	if req.Description != "" {
		updates["description"] = req.Description
	}
	updates["status"] = req.Status

	err = h.roleService.UpdateRole(uint(id), updates)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}

// DeleteRole 删除角色
func (h *AdminRoleHandler) DeleteRole(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的角色ID")
		return
	}

	err = h.roleService.DeleteRole(uint(id))
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}

// GetPermissions 获取权限列表
func (h *AdminRoleHandler) GetPermissions(c *gin.Context) {
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
	keyword := c.Query("keyword")
	module := c.Query("module")
	status := c.Query("status")

	conditions := make(map[string]interface{})
	if keyword != "" {
		conditions["keyword"] = keyword
	}
	if module != "" {
		conditions["module"] = module
	}
	if status != "" {
		conditions["status"] = status
	}

	permissions, pagination, err := h.roleService.GetPermissionList(page, pageSize, conditions)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, gin.H{
		"list":       permissions,
		"pagination": pagination,
	})
}

// CreatePermission 创建权限
func (h *AdminRoleHandler) CreatePermission(c *gin.Context) {
	var req struct {
		Name        string `json:"name" binding:"required"`
		DisplayName string `json:"display_name" binding:"required"`
		Description string `json:"description"`
		Module      string `json:"module" binding:"required"`
		Resource    string `json:"resource"`
		Action      string `json:"action" binding:"required"`
		Status      uint8  `json:"status"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数错误")
		return
	}

	permission := &model.Permission{
		Name:        req.Name,
		DisplayName: req.DisplayName,
		Description: req.Description,
		Module:      req.Module,
		Resource:    req.Resource,
		Action:      req.Action,
		Status:      int(req.Status),
	}

	err := h.roleService.CreatePermission(permission)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, permission)
}

// UpdatePermission 更新权限
func (h *AdminRoleHandler) UpdatePermission(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的权限ID")
		return
	}

	var req struct {
		Name        string `json:"name"`
		Code        string `json:"code"`
		Description string `json:"description"`
		Type        string `json:"type"`
		Resource    string `json:"resource"`
		Action      string `json:"action"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数错误")
		return
	}

	updates := make(map[string]interface{})
	if req.Name != "" {
		updates["name"] = req.Name
	}
	if req.Code != "" {
		updates["code"] = req.Code
	}
	if req.Description != "" {
		updates["description"] = req.Description
	}
	if req.Type != "" {
		updates["type"] = req.Type
	}
	if req.Resource != "" {
		updates["resource"] = req.Resource
	}
	if req.Action != "" {
		updates["action"] = req.Action
	}

	err = h.roleService.UpdatePermission(uint(id), updates)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}

// DeletePermission 删除权限
func (h *AdminRoleHandler) DeletePermission(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的权限ID")
		return
	}

	err = h.roleService.DeletePermission(uint(id))
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}

// AssignPermissionsToRole 为角色分配权限
func (h *AdminRoleHandler) AssignPermissionsToRole(c *gin.Context) {
	idStr := c.Param("id")
	roleID, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的角色ID")
		return
	}

	var req struct {
		PermissionIDs []uint `json:"permission_ids" binding:"required"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数错误")
		return
	}

	err = h.roleService.AssignPermissionsToRole(uint(roleID), req.PermissionIDs)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}

// GetRolePermissions 获取角色权限
func (h *AdminRoleHandler) GetRolePermissions(c *gin.Context) {
	idStr := c.Param("id")
	roleID, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的角色ID")
		return
	}

	role, err := h.roleService.GetRoleByID(uint(roleID))
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, role.Permissions)
}

// AssignRolesToUser 为用户分配角色
func (h *AdminRoleHandler) AssignRolesToUser(c *gin.Context) {
	idStr := c.Param("id")
	userID, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的用户ID")
		return
	}

	var req struct {
		RoleIDs []uint `json:"role_ids" binding:"required"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数错误")
		return
	}

	err = h.roleService.AssignRolesToUser(uint(userID), req.RoleIDs)
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}

// GetUserRoles 获取用户角色
func (h *AdminRoleHandler) GetUserRoles(c *gin.Context) {
	idStr := c.Param("id")
	userID, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的用户ID")
		return
	}

	roles, err := h.roleService.GetUserRoles(uint(userID))
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, roles)
}

// GetUserPermissions 获取用户权限
func (h *AdminRoleHandler) GetUserPermissions(c *gin.Context) {
	idStr := c.Param("id")
	userID, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.BadRequest(c, "无效的用户ID")
		return
	}

	permissions, err := h.roleService.GetUserPermissions(uint(userID))
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, permissions)
}

// InitializeDefaultRoles 初始化默认角色和权限
func (h *AdminRoleHandler) InitializeDefaultRoles(c *gin.Context) {
	err := h.roleService.InitDefaultRolesAndPermissions()
	if err != nil {
		response.ErrorWithMessage(c, response.ERROR, err.Error())
		return
	}

	response.Success(c, nil)
}