package controllers

import (
	"encoding/json"
	"server/models"

	"github.com/beego/beego/v2/server/web"
)

type RoleController struct {
	web.Controller
}

// GetAllRoles 获取所有角色
// @router /api/roles [get]
func (c *RoleController) GetAllRoles() {
	roles, err := models.GetAllRoles()
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取角色列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	roleList := make([]map[string]interface{}, 0)
	for _, role := range roles {
		roleList = append(roleList, map[string]interface{}{
			"roleId":      role.RoleId,
			"roleCode":    role.RoleCode,
			"roleName":    role.RoleName,
			"description": role.Description,
			"status":      role.Status,
			"sortOrder":   role.SortOrder,
			"createTime":  role.CreateTime,
			"updateTime":  role.UpdateTime,
			"createBy":    role.CreateBy,
			"updateBy":    role.UpdateBy,
		})
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "获取角色列表成功",
		"data":    roleList,
	}
	c.ServeJSON()
}

// GetRoleById 根据ID获取角色详情
// @router /api/roles/:id [get]
func (c *RoleController) GetRoleById() {
	roleId, err := c.GetInt(":id")
	if err != nil || roleId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	role, err := models.GetRoleById(roleId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取角色详情失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 确保 menuIds 是数组，即使为空
	menuIds := role.MenuIds
	if menuIds == nil {
		menuIds = []int{}
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "获取角色详情成功",
		"data": map[string]interface{}{
			"roleId":      role.RoleId,
			"tenantId":    role.TenantId,
			"roleCode":    role.RoleCode,
			"roleName":    role.RoleName,
			"description": role.Description,
			"menuIds":     menuIds,
			"status":      role.Status,
			"sortOrder":   role.SortOrder,
			"createTime":  role.CreateTime,
			"updateTime":  role.UpdateTime,
			"createBy":    role.CreateBy,
			"updateBy":    role.UpdateBy,
		},
	}
	c.ServeJSON()
}

// 根据租户ID获取角色列表
// @router /api/roles/tenant/:tenantId [get]
func (c *RoleController) GetRoleByTenantId() {
	tenantId, err := c.GetInt(":tenantId")
	if err != nil || tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	roles, err := models.GetRoleByTenantId(tenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取角色列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "获取角色列表成功",
		"data":    roles,
	}
	c.ServeJSON()
}

// CreateRole 创建角色
// @router /api/roles [post]
func (c *RoleController) CreateRole() {
	var role models.Role
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &role); err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "参数解析失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if role.RoleCode == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色代码不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	if role.RoleName == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色名称不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 检查角色代码是否已存在
	existingRole, err := models.GetRoleByCode(role.RoleCode)
	if err == nil && existingRole != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色代码已存在",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 设置默认值
	if role.Status == 0 {
		role.Status = 1
	}

	err = models.CreateRole(&role)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "创建角色失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "创建角色成功",
		"data": map[string]interface{}{
			"roleId": role.RoleId,
		},
	}
	c.ServeJSON()
}

// UpdateRole 更新角色
// @router /api/roles/:id [put]
func (c *RoleController) UpdateRole() {
	roleId, err := c.GetInt(":id")
	if err != nil || roleId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 检查角色是否存在
	existingRole, err := models.GetRoleById(roleId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色不存在: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	var role models.Role
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &role); err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "参数解析失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 如果更新了角色代码，检查是否重复
	if role.RoleCode != "" && role.RoleCode != existingRole.RoleCode {
		codeRole, err := models.GetRoleByCode(role.RoleCode)
		if err == nil && codeRole != nil && codeRole.RoleId != roleId {
			c.Data["json"] = map[string]interface{}{
				"code":    1,
				"message": "角色代码已存在",
				"data":    nil,
			}
			c.ServeJSON()
			return
		}
	}

	// 设置角色ID
	role.RoleId = roleId

	err = models.UpdateRole(&role)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "更新角色失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "更新角色成功",
		"data":    nil,
	}
	c.ServeJSON()
}

// DeleteRole 删除角色（软删除）
// @router /api/roles/:id [delete]
func (c *RoleController) DeleteRole() {
	roleId, err := c.GetInt(":id")
	if err != nil || roleId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 检查是否为系统默认角色，不允许删除
	role, err := models.GetRoleById(roleId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色不存在: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 系统默认角色不允许删除
	if role.RoleCode == "system_admin" || role.RoleCode == "admin" || role.RoleCode == "user" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "系统默认角色不允许删除",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 获取当前用户名（用于记录删除操作）
	updateBy := "system"
	if username, ok := c.Ctx.Input.GetData("username").(string); ok && username != "" {
		updateBy = username
	}

	err = models.DeleteRole(roleId, updateBy)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "删除角色失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "删除角色成功",
		"data":    nil,
	}
	c.ServeJSON()
}