package controller

import (
	"strconv"

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

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

// StorageAssignController 存储策略分配控制器
type StorageAssignController struct {
	assignService *service.StorageAssignService
}

func NewStorageAssignController() *StorageAssignController {
	return &StorageAssignController{
		assignService: service.NewStorageAssignService(),
	}
}

// ========== 用户接口 ==========

// GetMyStorageInfo 获取当前用户的存储策略信息
// GET /api/user/storage-info
func (c *StorageAssignController) GetMyStorageInfo(ctx *gin.Context) {
	userID := middleware.GetCurrentUserID(ctx)
	info, err := c.assignService.GetUserStorageInfo(userID)
	if err != nil {
		utils.ServerError(ctx, "获取存储信息失败")
		return
	}
	utils.Success(ctx, info)
}

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

// ListAssignments 获取所有分配规则
// GET /api/admin/storage-assignments
func (c *StorageAssignController) ListAssignments(ctx *gin.Context) {
	assignments, err := c.assignService.ListAssignments()
	if err != nil {
		utils.ServerError(ctx, "查询失败")
		return
	}
	utils.Success(ctx, assignments)
}

// SetDefault 设置系统默认存储策略
// POST /api/admin/storage-assignments/default
func (c *StorageAssignController) SetDefault(ctx *gin.Context) {
	var req struct {
		PolicyID uint64 `json:"policy_id" binding:"required"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误")
		return
	}

	if err := c.assignService.SetDefault(req.PolicyID); err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "默认策略已设置", nil)
}

// AssignToUser 为用户分配存储策略
// POST /api/admin/storage-assignments/user
func (c *StorageAssignController) AssignToUser(ctx *gin.Context) {
	var req dto.StorageAssignRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}
	if req.UserID == 0 {
		utils.BadRequest(ctx, "请指定用户ID")
		return
	}

	if err := c.assignService.AssignToUser(req.UserID, req.PolicyID, req.StorageQuota, req.AccessMode); err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "分配成功", nil)
}

// AssignToRole 为角色分配存储策略
// POST /api/admin/storage-assignments/role
func (c *StorageAssignController) AssignToRole(ctx *gin.Context) {
	var req dto.StorageAssignRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}
	if req.GroupID == 0 {
		utils.BadRequest(ctx, "请指定角色")
		return
	}

	if err := c.assignService.AssignToRole(req.GroupID, req.PolicyID, req.StorageQuota, req.Priority, req.AccessMode); err != nil {
		utils.ServerError(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "分配成功", nil)
}

// UpdateAssignment 更新分配规则(配额/优先级/访问模式)
// PUT /api/admin/storage-assignments/:id
func (c *StorageAssignController) UpdateAssignment(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的ID")
		return
	}

	var req struct {
		PolicyID     uint64 `json:"policy_id"`
		Priority     *int   `json:"priority"`
		StorageQuota *int64 `json:"storage_quota"`
		AccessMode   string `json:"access_mode"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误")
		return
	}

	if err := c.assignService.UpdateAssignment(id, req.PolicyID, req.Priority, req.StorageQuota, req.AccessMode); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "更新成功", nil)
}

// DeleteAssignment 删除分配规则
// DELETE /api/admin/storage-assignments/:id
func (c *StorageAssignController) DeleteAssignment(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的ID")
		return
	}

	if err := c.assignService.DeleteAssignment(id); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "删除成功", nil)
}