package controller

import (
	"backend/model"
	"backend/util"

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

type permissionIDRequest struct {
	ID int `json:"id" binding:"required"`
}

type groupRoleSetRequest struct {
	GroupID int   `json:"group_id" binding:"required"`
	RoleIDs []int `json:"role_ids"`
}

type groupRoleListRequest struct {
	GroupID int `json:"group_id" binding:"required"`
}

type rolePermissionSetRequest struct {
	RoleID        int   `json:"role_id" binding:"required"`
	PermissionIDs []int `json:"permission_ids"`
}

type rolePermissionListRequest struct {
	RoleID int `json:"role_id" binding:"required"`
}

type userGroupListRequest struct {
	AdminID int `json:"admin_id" binding:"required"`
}

type userGroupSetRequest struct {
	AdminID  int   `json:"admin_id" binding:"required"`
	GroupIDs []int `json:"group_ids"`
}

type userPermissionSetRequest struct {
	AdminID     int                        `json:"admin_id" binding:"required"`
	Permissions []model.UserPermissionItem `json:"permissions"`
}

type userAdminIDRequest struct {
	AdminID int `json:"admin_id" binding:"required"`
}

type userAdminIDsRequest struct {
	AdminIDs []int `json:"admin_ids" binding:"required"`
}

func PermissionUserGroupList(c *gin.Context) {
	var req model.PermissionUserGroupListParams
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	items, total, err := model.ListPermissionUserGroups(req)
	if err != nil {
		failed(c, "Failed to list user groups: "+err.Error())
		return
	}
	success(c, gin.H{"items": items, "total": total})
}

func PermissionUserGroupAdd(c *gin.Context) {
	var req model.PermissionUserGroup
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if req.GroupCode == "" || req.GroupName == "" {
		failed(c, "group_code and group_name are required")
		return
	}
	if err := model.CreatePermissionUserGroup(&req, c.GetString("admin")); err != nil {
		failed(c, "Failed to add user group: "+err.Error())
		return
	}
	util.AddAdminLog(c, "新增权限用户组", req)
	success(c, req)
}

func PermissionUserGroupEdit(c *gin.Context) {
	var req model.PermissionUserGroup
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if req.ID <= 0 {
		failed(c, "id is required")
		return
	}
	if err := model.UpdatePermissionUserGroup(&req, c.GetString("admin")); err != nil {
		failed(c, "Failed to edit user group: "+err.Error())
		return
	}
	util.AddAdminLog(c, "编辑权限用户组", req)
	success(c, req)
}

func PermissionUserGroupDelete(c *gin.Context) {
	var req permissionIDRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.DeletePermissionUserGroup(req.ID); err != nil {
		failed(c, "Failed to delete user group: "+err.Error())
		return
	}
	util.AddAdminLog(c, "删除权限用户组", req)
	success(c, gin.H{"id": req.ID})
}

func PermissionRoleList(c *gin.Context) {
	var req model.PermissionRoleListParams
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	items, total, err := model.ListPermissionRoles(req)
	if err != nil {
		failed(c, "Failed to list roles: "+err.Error())
		return
	}
	success(c, gin.H{"items": items, "total": total})
}

func PermissionRoleAdd(c *gin.Context) {
	var req model.PermissionRole
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if req.RoleCode == "" || req.RoleName == "" {
		failed(c, "role_code and role_name are required")
		return
	}
	if err := model.CreatePermissionRole(&req, c.GetString("admin")); err != nil {
		failed(c, "Failed to add role: "+err.Error())
		return
	}
	util.AddAdminLog(c, "新增权限角色", req)
	success(c, req)
}

func PermissionRoleEdit(c *gin.Context) {
	var req model.PermissionRole
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if req.ID <= 0 {
		failed(c, "id is required")
		return
	}
	if err := model.UpdatePermissionRole(&req, c.GetString("admin")); err != nil {
		failed(c, "Failed to edit role: "+err.Error())
		return
	}
	util.AddAdminLog(c, "编辑权限角色", req)
	success(c, req)
}

func PermissionRoleDelete(c *gin.Context) {
	var req permissionIDRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.DeletePermissionRole(req.ID); err != nil {
		failed(c, "Failed to delete role: "+err.Error())
		return
	}
	util.AddAdminLog(c, "删除权限角色", req)
	success(c, gin.H{"id": req.ID})
}

func PermissionGroupRoleSet(c *gin.Context) {
	var req groupRoleSetRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.SetGroupRoles(req.GroupID, req.RoleIDs, c.GetString("admin")); err != nil {
		failed(c, "Failed to set group roles: "+err.Error())
		return
	}
	util.AddAdminLog(c, "设置用户组角色", req)
	success(c, gin.H{"group_id": req.GroupID, "role_ids": req.RoleIDs})
}

func PermissionGroupRoleList(c *gin.Context) {
	var req groupRoleListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	roles, err := model.ListGroupRoles(req.GroupID)
	if err != nil {
		failed(c, "Failed to list group roles: "+err.Error())
		return
	}
	success(c, roles)
}

func PermissionPointList(c *gin.Context) {
	var req model.PermissionPointListParams
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	items, total, err := model.ListPermissionPoints(req)
	if err != nil {
		failed(c, "Failed to list permissions: "+err.Error())
		return
	}
	success(c, gin.H{"items": items, "total": total})
}

func PermissionPointAdd(c *gin.Context) {
	var req model.PermissionPoint
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if req.PermissionCode == "" || req.PermissionName == "" {
		failed(c, "permission_code and permission_name are required")
		return
	}
	if err := model.CreatePermissionPoint(&req, c.GetString("admin")); err != nil {
		failed(c, "Failed to add permission: "+err.Error())
		return
	}
	util.AddAdminLog(c, "新增单点权限", req)
	success(c, req)
}

func PermissionPointEdit(c *gin.Context) {
	var req model.PermissionPoint
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if req.ID <= 0 {
		failed(c, "id is required")
		return
	}
	if err := model.UpdatePermissionPoint(&req, c.GetString("admin")); err != nil {
		failed(c, "Failed to edit permission: "+err.Error())
		return
	}
	util.AddAdminLog(c, "编辑单点权限", req)
	success(c, req)
}

func PermissionPointDelete(c *gin.Context) {
	var req permissionIDRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.DeletePermissionPoint(req.ID); err != nil {
		failed(c, "Failed to delete permission: "+err.Error())
		return
	}
	util.AddAdminLog(c, "删除单点权限", req)
	success(c, gin.H{"id": req.ID})
}

func PermissionRolePermissionSet(c *gin.Context) {
	var req rolePermissionSetRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.SetRolePermissions(req.RoleID, req.PermissionIDs, c.GetString("admin")); err != nil {
		failed(c, "Failed to set role permissions: "+err.Error())
		return
	}
	util.AddAdminLog(c, "设置角色权限", req)
	success(c, gin.H{"role_id": req.RoleID, "permission_ids": req.PermissionIDs})
}

func PermissionRolePermissionList(c *gin.Context) {
	var req rolePermissionListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	permissions, err := model.ListRolePermissions(req.RoleID)
	if err != nil {
		failed(c, "Failed to list role permissions: "+err.Error())
		return
	}
	success(c, permissions)
}

func PermissionUserGroupRelList(c *gin.Context) {
	var req userGroupListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	groups, err := model.ListUserGroups(req.AdminID)
	if err != nil {
		failed(c, "Failed to list user groups: "+err.Error())
		return
	}
	success(c, groups)
}

func PermissionUserGroupRelSet(c *gin.Context) {
	var req userGroupSetRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.SetUserGroups(req.AdminID, req.GroupIDs, c.GetString("admin")); err != nil {
		failed(c, "Failed to set user groups: "+err.Error())
		return
	}
	util.AddAdminLog(c, "设置管理员用户组", req)
	success(c, gin.H{"admin_id": req.AdminID, "group_ids": req.GroupIDs})
}

func PermissionUserPermissionList(c *gin.Context) {
	var req userAdminIDRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	items, err := model.ListUserPermissions(req.AdminID)
	if err != nil {
		failed(c, "Failed to list user permissions: "+err.Error())
		return
	}
	success(c, items)
}

func PermissionUserPermissionSet(c *gin.Context) {
	var req userPermissionSetRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	if err := model.SetUserPermissions(req.AdminID, req.Permissions, c.GetString("admin")); err != nil {
		failed(c, "Failed to set user permissions: "+err.Error())
		return
	}
	util.AddAdminLog(c, "设置管理员单点权限", req)
	success(c, gin.H{"admin_id": req.AdminID, "permissions": req.Permissions})
}

func PermissionUserRoleList(c *gin.Context) {
	var req userAdminIDRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	roles, err := model.ListUserRoles(req.AdminID)
	if err != nil {
		failed(c, "Failed to list user roles: "+err.Error())
		return
	}
	success(c, roles)
}

func PermissionUserRoleBatchList(c *gin.Context) {
	var req userAdminIDsRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		failed(c, "Invalid input: "+err.Error())
		return
	}
	roles, err := model.ListUserRolesByAdminIDs(req.AdminIDs)
	if err != nil {
		failed(c, "Failed to list user roles: "+err.Error())
		return
	}
	success(c, roles)
}