package controller

import (
	"strconv"

	"seeyon-filesystem/dto"
	"seeyon-filesystem/service"
	"seeyon-filesystem/utils"

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

// OpenAPIController 开放平台控制器
type OpenAPIController struct {
	openService *service.OpenAPIService
}

func NewOpenAPIController() *OpenAPIController {
	return &OpenAPIController{
		openService: service.NewOpenAPIService(),
	}
}

// ========== 管理员接口 ==========

// ListApps 获取应用列表
// GET /api/admin/apps
func (c *OpenAPIController) ListApps(ctx *gin.Context) {
	apps, err := c.openService.ListApps()
	if err != nil {
		utils.ServerError(ctx, "查询失败")
		return
	}
	utils.Success(ctx, apps)
}

// CreateApp 创建应用
// POST /api/admin/apps
func (c *OpenAPIController) CreateApp(ctx *gin.Context) {
	var req dto.AppCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	app, err := c.openService.CreateApp(req.AppName)
	if err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.Success(ctx, app)
}

// DeleteApp 删除应用
// DELETE /api/admin/apps/:id
func (c *OpenAPIController) DeleteApp(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的ID")
		return
	}
	if err := c.openService.DeleteApp(id); err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "删除成功", nil)
}

// ToggleApp 启用/禁用应用
// PUT /api/admin/apps/:id/toggle
func (c *OpenAPIController) ToggleApp(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的ID")
		return
	}

	var req struct {
		Status int8 `json:"status"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误")
		return
	}

	if err := c.openService.ToggleApp(id, req.Status); err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "操作成功", nil)
}

// BindUsers 绑定用户到应用
// PUT /api/admin/apps/:id/users
func (c *OpenAPIController) BindUsers(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的ID")
		return
	}

	var req dto.AppBindUsersRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	userIDs := make([]uint64, len(req.UserIDs))
	for i, uid := range req.UserIDs {
		userIDs[i] = uint64(uid)
	}
	if err := c.openService.BindUsers(id, userIDs); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "绑定成功", nil)
}

// UnbindUser 解绑用户
// DELETE /api/admin/apps/:id/users/:userId
func (c *OpenAPIController) UnbindUser(ctx *gin.Context) {
	appID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的应用ID")
		return
	}
	userID, err := strconv.ParseUint(ctx.Param("userId"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的用户ID")
		return
	}

	if err := c.openService.UnbindUser(appID, userID); err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "解绑成功", nil)
}

// ========== 开放API (给OA调用) ==========

// ValidateToken 验证SSO Token
// POST /api/openapi/token/validate
// Body: { "app_id": "xxx", "token": "encrypted-string" }
// 返回: JWT token
func (c *OpenAPIController) ValidateToken(ctx *gin.Context) {
	var req struct {
		AppID string `json:"app_id" binding:"required"`
		Token string `json:"token" binding:"required"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: app_id和token必填")
		return
	}

	// 验证token, 获取用户名
	username, err := c.openService.ValidateToken(req.AppID, req.Token)
	if err != nil {
		utils.Unauthorized(ctx, err.Error())
		return
	}

	// 生成JWT
	result, err := c.openService.GenerateJWTForUser(username)
	if err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}

	utils.Success(ctx, result)
}

// GenerateTestToken 生成测试Token (仅调试用)
// POST /api/openapi/token/generate
// Body: { "app_id": "xxx", "username": "admin" }
func (c *OpenAPIController) GenerateTestToken(ctx *gin.Context) {
	var req struct {
		AppID    string `json:"app_id" binding:"required"`
		Username string `json:"username" binding:"required"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误")
		return
	}

	token, err := c.openService.GenerateToken(req.AppID, req.Username)
	if err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.Success(ctx, gin.H{
		"token": token,
		"usage": "OA系统使用此token调用 POST /api/openapi/token/validate 获取JWT",
	})
}