// Package controllers/pms_controller.go
package controllers

import (
	"Quincy_admin/schemas"
	"Quincy_admin/services"
	"Quincy_admin/utils"
	"fmt"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

type PermissionController struct {
	PmsService *services.PermissionService
}

func NewPermissionController(PmsService *services.PermissionService) *PermissionController {
	return &PermissionController{PmsService: PmsService}
}

// GetRoutes 侧边菜单权限
// @Summary 侧边菜单权限
// @Description 根据用户Session获取侧边栏菜单权限
// @Tags 权限模块
// @Accept json
// @Produce json
// @Success 200 {object} schemas.MenuItems "菜单信息"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /pms/routes [get]
// @Security ApiKeyAuth
func (c *PermissionController) GetRoutes(ctx *gin.Context) {
	// 从请求头获取 X-Access-Token
	scode := ctx.GetHeader("X-Access-Token")
	if scode == "" {
		fmt.Println("无效的用户编码", scode)
		utils.Fail(ctx, http.StatusBadRequest, "无效的用户编码")
		return
	}

	roleIDInterface, exists := ctx.Get("role_id")
	if !exists {
		utils.Error(ctx, http.StatusUnauthorized, "权限校验错误：用户ID不存在")
		ctx.Abort()
		return
	}

	roleID, ok := roleIDInterface.(int)
	if !ok {
		utils.Error(ctx, http.StatusUnauthorized, "权限校验错误：用户ID类型错误")
		ctx.Abort()
		return
	}

	items, err := c.PmsService.GetRoutesByID(roleID)
	if err != nil {
		fmt.Println("获取路由权限失败", err)
		utils.Fail(ctx, http.StatusNotFound, "获取失败")
		return
	}

	utils.Success(ctx, items.Children)
}

// GetMenuList 获取菜单列表
// @Summary 获取菜单列表
// @Description 获取管理后台菜单列表
// @Tags 权限模块
// @Accept json
// @Produce json
// @Param role body schemas.MenuListRequest true "req"
// @Success 200 {object} schemas.MenuItems "菜单信息"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /pms/menus [post]
// @Security ApiKeyAuth
func (c *PermissionController) GetMenuList(ctx *gin.Context) {
	var req schemas.MenuListRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.Error(ctx, http.StatusBadRequest, "参数错误")
		return
	}

	if req.PageIndex <= 0 || req.PageSize <= 0 || req.PageSize > 100 {
		utils.Error(ctx, http.StatusBadRequest, "分页参数错误")
		return
	}

	items, total, err := c.PmsService.GetMenuList(req.PageIndex, req.PageSize)
	if err != nil {
		utils.Error(ctx, http.StatusInternalServerError, err.Error())
		return
	}

	response := schemas.MenuListResponse{
		Item:      items,
		Total:     total,
		PageIndex: req.PageIndex,
		PageSize:  req.PageSize,
	}

	utils.Success(ctx, response)
}

// UpdateMenuStatus 	启用停用菜单
// @Summary		启用停用菜单
// @Description	启用停用菜单
// @Tags		权限模块
// @Accept		json
// @Produce		json
// @Param		id	path		string	true	"id"
// @Param		status	query		int	false	"启用状态(1:启用,0:停用)"
// @Success		200		{object}	utils.Response{data=string}
// @Failure		400		{object}	utils.Response
// @Failure		500		{object}	utils.Response
// @Router		/pms/menus/{id} [put]
// @Security ApiKeyAuth
func (c *PermissionController) UpdateMenuStatus(ctx *gin.Context) {
	var idstr = ctx.Param("id")

	id, err := strconv.Atoi(idstr)
	if err != nil || id <= 0 {
		utils.Error(ctx, http.StatusBadRequest, "参数 id 必须是有效的整数")
		return
	}

	statusStr := ctx.Query("status")
	if statusStr == "" {
		utils.Error(ctx, http.StatusBadRequest, "参数 status 不能为空")
		return
	}

	statusValue, err := strconv.Atoi(statusStr)
	if err != nil || (statusValue != 0 && statusValue != 1) {
		utils.Error(ctx, http.StatusBadRequest, "参数 status 必须是0或1")
		return
	}

	// 直接传递整数值到服务层
	if err := c.PmsService.UpdateMenuStatus(id, statusValue); err != nil {
		utils.Error(ctx, http.StatusInternalServerError, "更新任务状态失败: "+err.Error())
		return
	}

	if statusValue == 1 {
		utils.Success(ctx, "启用成功")
	} else {
		utils.Success(ctx, "停用成功")
	}
}

// GetPermission 获取权限列表
// @Summary 获取权限列表
// @Description 根据用户Session和权限type获取权限列表
// @Tags 权限模块
// @Accept  json
// @Produce json
// @Param	type	query		string	false	"all-全部 button-按钮，route-路由，menu-菜单，api-接口"
// @Success 200 {object} []string "权限列表"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /pms/permission [get]
// @Security ApiKeyAuth
func (c *PermissionController) GetPermission(ctx *gin.Context) {
	// 获取角色	ID
	roleIDInterface, exists := ctx.Get("role_id")
	if !exists {
		utils.Error(ctx, http.StatusUnauthorized, "权限校验错误：用户ID不存在")
		ctx.Abort()
		return
	}

	roleID, ok := roleIDInterface.(int)
	if !ok {
		utils.Error(ctx, http.StatusUnauthorized, "权限校验错误：用户ID类型错误")
		ctx.Abort()
		return
	}

	typeStr := ctx.Query("type")
	if typeStr == "" {
		utils.Error(ctx, http.StatusBadRequest, "参数 type 不能为空")
		return
	}

	items, err := c.PmsService.GetPermission(roleID, typeStr)
	if err != nil {
		fmt.Println("获取路由权限失败", err)
		utils.Fail(ctx, http.StatusNotFound, "获取失败")
		return
	}

	utils.Success(ctx, items)
}

// GetAllPermission 获取所有权限
// @Summary 获取所有权限
// @Description 获取所有权限
// @Tags 权限模块
// @Accept  json
// @Produce json
// @Success 200 {object} schemas.PermissionItems "权限列表"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /pms/permission/all [get]
// @Security ApiKeyAuth
// @Security ApiKeyAuth
func (c *PermissionController) GetAllPermission(ctx *gin.Context) {
	items, err := c.PmsService.GetAllPermission()
	if err != nil {
		fmt.Println("获取路由权限失败", err)
		utils.Fail(ctx, http.StatusNotFound, "获取失败")
		return
	}

	// 返回树形结构，包含所有层级的 children
	utils.Success(ctx, items.Children)
}

// GetRolePermission 获取角色权限
// @Summary 获取角色权限
// @Description 获取角色权限
// @Tags 权限模块
// @Accept  json
// @Produce json
// @param   role_id query		int 	true 	"角色ID"
// @Param	type	query		string	false	"all-全部 button-按钮，route-路由，menu-菜单，api-接口"
// @Success 200 {object} utils.Response{data=[]int} "权限列表"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /pms/permission/role [get]
// @Security ApiKeyAuth
func (c *PermissionController) GetRolePermission(ctx *gin.Context) {
	// 获取角色	ID
	var roleIDStr = ctx.Query("role_id")
	roleID, err := strconv.Atoi(roleIDStr)
	if err != nil {
		utils.Error(ctx, http.StatusBadRequest, "参数 role_id 错误")
		return
	}

	typeStr := ctx.Query("type")
	if typeStr == "" {
		utils.Error(ctx, http.StatusBadRequest, "参数 type 不能为空")
		return
	}

	items, err := c.PmsService.GetRolePermission(roleID, typeStr)
	if err != nil {
		fmt.Println("获取路由权限失败", err)
		utils.Fail(ctx, http.StatusNotFound, "获取失败")
		return
	}

	utils.Success(ctx, items)
}

// AssignPermission 分配角色权限
// @Summary 分配角色权限
// @Description 为指定角色分配权限
// @Tags 权限模块
// @Accept json
// @Produce json
// @Param role_id path int true "角色ID"
// @Param permission_ids query []int true "权限ID数组"
// @Success 200 {object} utils.Response "权限分配成功"
// @Failure 400 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /pms/permission/assign/{role_id} [put]
// @Security ApiKeyAuth
func (c *PermissionController) AssignPermission(ctx *gin.Context) {
	// 从 path 参数获取角色 ID
	roleIDStr := ctx.Param("role_id")
	roleID, err := strconv.Atoi(roleIDStr)
	if err != nil || roleID <= 0 {
		utils.Error(ctx, http.StatusBadRequest, "参数 role_id 必须是有效的正整数")
		return
	}

	if roleID == 1 {
		utils.Error(ctx, http.StatusForbidden, "无权修改超级管理员角色")
		return
	}

	// 从请求体解析权限ID数组
	var permissionIDs []int
	if err := ctx.ShouldBindJSON(&permissionIDs); err != nil {
		utils.Error(ctx, http.StatusBadRequest, "参数格式错误: "+err.Error())
		return
	}

	// 验证权限ID数组不为空
	if len(permissionIDs) == 0 {
		utils.Error(ctx, http.StatusBadRequest, "参数 permission_ids 不能为空")
		return
	}

	// 验证每个权限ID的有效性
	for _, id := range permissionIDs {
		if id <= 0 {
			utils.Error(ctx, http.StatusBadRequest, fmt.Sprintf("权限ID '%d' 必须是有效的正整数", id))
			return
		}
	}

	// 调用服务层处理权限分配
	if err := c.PmsService.AssignPermission(roleID, permissionIDs); err != nil {
		utils.Error(ctx, http.StatusInternalServerError, "权限分配失败: "+err.Error())
		return
	}

	utils.Success(ctx, "权限分配成功")
}