package controller

import (
	"net/http"
	"strconv"

	"gofaster/internal/auth/model"
	"gofaster/internal/auth/service"
	"gofaster/internal/shared/response"

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

type ResourceController struct {
	resourceService *service.ResourceService
}

func NewResourceController(resourceService *service.ResourceService) *ResourceController {
	return &ResourceController{
		resourceService: resourceService,
	}
}

// CreateResource 创建资源
func (c *ResourceController) CreateResource(ctx *gin.Context) {
	var resource model.Resource
	if err := ctx.ShouldBindJSON(&resource); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if err := c.resourceService.CreateResource(ctx.Request.Context(), &resource); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "创建资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源创建成功", resource)
}

// UpdateResource 更新资源
func (c *ResourceController) UpdateResource(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的资源ID")
		return
	}

	var resource model.Resource
	if err := ctx.ShouldBindJSON(&resource); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	resource.ID = uint(id)

	if err := c.resourceService.UpdateResource(ctx.Request.Context(), &resource); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "更新资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源更新成功", resource)
}

// DeleteResource 删除资源
func (c *ResourceController) DeleteResource(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的资源ID")
		return
	}

	if err := c.resourceService.DeleteResource(ctx.Request.Context(), uint(id)); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "删除资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源删除成功", nil)
}

// GetResource 获取资源详情
func (c *ResourceController) GetResource(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的资源ID")
		return
	}

	resource, err := c.resourceService.GetResource(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusNotFound, "资源不存在", err.Error())
		return
	}

	response.Success(ctx, "获取资源成功", resource)
}

// ListResources 获取资源列表
func (c *ResourceController) ListResources(ctx *gin.Context) {
	pageStr := ctx.DefaultQuery("page", "1")
	pageSizeStr := ctx.DefaultQuery("pageSize", "10")

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		page = 1
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 || pageSize > 100 {
		pageSize = 10
	}

	resources, total, err := c.resourceService.ListResources(ctx.Request.Context(), page, pageSize)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取资源列表失败", err.Error())
		return
	}

	response.Success(ctx, "获取资源列表成功", gin.H{
		"data":  resources,
		"page":  page,
		"size":  pageSize,
		"total": total,
	})
}

// GetResourceTree 获取资源树
func (c *ResourceController) GetResourceTree(ctx *gin.Context) {
	resources, err := c.resourceService.GetResourceTree(ctx.Request.Context())
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取资源树失败", err.Error())
		return
	}

	response.Success(ctx, "获取资源树成功", resources)
}

// SyncResources 同步资源
func (c *ResourceController) SyncResources(ctx *gin.Context) {
	if err := c.resourceService.SyncResourcesFromRoutes(ctx.Request.Context()); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "同步资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源同步成功", nil)
}

// ListResourcesByModule 根据模块获取资源列表
func (c *ResourceController) ListResourcesByModule(ctx *gin.Context) {
	module := ctx.Param("module")
	if module == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "模块名称不能为空")
		return
	}

	resources, err := c.resourceService.ListResourcesByModule(ctx.Request.Context(), module)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取模块资源失败", err.Error())
		return
	}

	response.Success(ctx, "获取模块资源成功", resources)
}

// ListResourcesByType 根据类型获取资源列表
func (c *ResourceController) ListResourcesByType(ctx *gin.Context) {
	resourceType := ctx.Param("type")
	if resourceType == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "资源类型不能为空")
		return
	}

	resources, err := c.resourceService.ListResourcesByType(ctx.Request.Context(), resourceType)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取类型资源失败", err.Error())
		return
	}

	response.Success(ctx, "获取类型资源成功", resources)
}