package management

import (
	"context"
	"strconv"

	"git.huangwc.com/pig/pig-farm-controller/internal/app/dto"
	"git.huangwc.com/pig/pig-farm-controller/internal/app/service"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/logs"

	"github.com/labstack/echo/v4"
)

// PigBatchController 负责处理猪批次相关的API请求
type PigBatchController struct {
	ctx     context.Context
	service service.PigBatchService
}

// NewPigBatchController 创建一个新的 PigBatchController 实例
func NewPigBatchController(ctx context.Context, service service.PigBatchService) *PigBatchController {
	return &PigBatchController{
		ctx:     ctx,
		service: service,
	}
}

// CreatePigBatch godoc
// @Summary      创建猪批次
// @Description  创建一个新的猪批次
// @Tags         猪群管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        body body dto.PigBatchCreateDTO true "猪批次信息"
// @Success      201 {object} controller.Response{data=dto.PigBatchResponseDTO} "创建成功"
// @Router       /api/v1/pig-batches [post]
func (c *PigBatchController) CreatePigBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "CreatePigBatch")

	const action = "创建猪批次"
	var req dto.PigBatchCreateDTO

	return handleAPIRequestWithResponse(
		reqCtx, c, ctx, action, &req,
		func(ctx echo.Context, operatorID uint32, primaryID uint32, req *dto.PigBatchCreateDTO) (*dto.PigBatchResponseDTO, error) {
			// 对于创建操作，primaryID通常不从路径中获取，而是由服务层生成
			return c.service.CreatePigBatch(reqCtx, operatorID, req)
		},
		"创建成功",
		nil, // 无需自定义ID提取器，primaryID将为0
	)
}

// GetPigBatch godoc
// @Summary      获取单个猪批次
// @Description  根据ID获取单个猪批次信息
// @Tags         猪群管理
// @Security     BearerAuth
// @Produce      json
// @Param        id path int true "猪批次ID"
// @Success      200 {object} controller.Response{data=dto.PigBatchResponseDTO} "获取成功"
// @Router       /api/v1/pig-batches/{id} [get]
func (c *PigBatchController) GetPigBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "GetPigBatch")

	const action = "获取猪批次"

	return handleNoBodyAPIRequestWithResponse(
		reqCtx, c, ctx, action,
		func(ctx echo.Context, operatorID uint32, primaryID uint32) (*dto.PigBatchResponseDTO, error) {
			return c.service.GetPigBatch(reqCtx, primaryID)
		},
		"获取成功",
		nil, // 默认从 ":id" 路径参数提取ID
	)
}

// UpdatePigBatch godoc
// @Summary      更新猪批次
// @Description  更新一个已存在的猪批次信息
// @Tags         猪群管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        id path int true "猪批次ID"
// @Param        body body dto.PigBatchUpdateDTO true "猪批次信息"
// @Success      200 {object} controller.Response{data=dto.PigBatchResponseDTO} "更新成功"
// @Router       /api/v1/pig-batches/{id} [put]
func (c *PigBatchController) UpdatePigBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "UpdatePigBatch")

	const action = "更新猪批次"
	var req dto.PigBatchUpdateDTO

	return handleAPIRequestWithResponse(
		reqCtx, c, ctx, action, &req,
		func(ctx echo.Context, operatorID uint32, primaryID uint32, req *dto.PigBatchUpdateDTO) (*dto.PigBatchResponseDTO, error) {
			return c.service.UpdatePigBatch(reqCtx, primaryID, req)
		},
		"更新成功",
		nil, // 默认从 ":id" 路径参数提取ID
	)
}

// DeletePigBatch godoc
// @Summary      删除猪批次
// @Description  根据ID删除一个猪批次
// @Tags         猪群管理
// @Security     BearerAuth
// @Produce      json
// @Param        id path int true "猪批次ID"
// @Success      200 {object} controller.Response "删除成功"
// @Router       /api/v1/pig-batches/{id} [delete]
func (c *PigBatchController) DeletePigBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "DeletePigBatch")

	const action = "删除猪批次"

	return handleNoBodyAPIRequest(
		reqCtx, c, ctx, action,
		func(ctx echo.Context, operatorID uint32, primaryID uint32) error {
			return c.service.DeletePigBatch(reqCtx, primaryID)
		},
		"删除成功",
		nil, // 默认从 ":id" 路径参数提取ID
	)
}

// ListPigBatches godoc
// @Summary      获取猪批次列表
// @Description  获取所有猪批次的列表，支持按活跃状态筛选
// @Tags         猪群管理
// @Security     BearerAuth
// @Produce      json
// @Param        is_active query bool false "是否活跃 (true/false)"
// @Success      200 {object} controller.Response{data=[]dto.PigBatchResponseDTO} "获取成功"
// @Router       /api/v1/pig-batches [get]
func (c *PigBatchController) ListPigBatches(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "ListPigBatches")

	const action = "获取猪批次列表"
	var query dto.PigBatchQueryDTO

	return handleQueryAPIRequestWithResponse(
		reqCtx, c, ctx, action, &query,
		func(ctx echo.Context, operatorID uint32, query *dto.PigBatchQueryDTO) ([]*dto.PigBatchResponseDTO, error) {
			return c.service.ListPigBatches(reqCtx, query.IsActive)
		},
		"获取成功",
	)
}

// AssignEmptyPensToBatch godoc
// @Summary      为猪批次分配空栏
// @Description  将一个或多个空闲猪栏分配给指定的猪批次
// @Tags         猪群管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        id path int true "猪批次ID"
// @Param        body body dto.AssignEmptyPensToBatchRequest true "待分配的猪栏ID列表"
// @Success      200 {object} controller.Response "分配成功"
// @Router       /api/v1/pig-batches/assign-pens/{id} [post]
func (c *PigBatchController) AssignEmptyPensToBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "AssignEmptyPensToBatch")

	const action = "为猪批次分配空栏"
	var req dto.AssignEmptyPensToBatchRequest

	return handleAPIRequest(
		reqCtx, c, ctx, action, &req,
		func(ctx echo.Context, operatorID uint32, primaryID uint32, req *dto.AssignEmptyPensToBatchRequest) error {
			return c.service.AssignEmptyPensToBatch(reqCtx, primaryID, req.PenIDs, operatorID)
		},
		"分配成功",
		nil, // 默认从 ":id" 路径参数提取ID
	)
}

// ReclassifyPenToNewBatch godoc
// @Summary      将猪栏划拨到新批次
// @Description  将一个猪栏（连同其中的猪只）从一个批次整体划拨到另一个批次
// @Tags         猪群管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        fromBatchID path int true "源猪批次ID"
// @Param        body body dto.ReclassifyPenToNewBatchRequest true "划拨请求信息 (包含目标批次ID、猪栏ID和备注)"
// @Success      200 {object} controller.Response "划拨成功"
// @Router       /api/v1/pig-batches/reclassify-pen/{fromBatchID} [post]
func (c *PigBatchController) ReclassifyPenToNewBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "ReclassifyPenToNewBatch")

	const action = "划拨猪栏到新批次"
	var req dto.ReclassifyPenToNewBatchRequest

	return handleAPIRequest(
		reqCtx, c, ctx, action, &req,
		func(ctx echo.Context, operatorID uint32, primaryID uint32, req *dto.ReclassifyPenToNewBatchRequest) error {
			// primaryID 在这里是 fromBatchID
			return c.service.ReclassifyPenToNewBatch(reqCtx, primaryID, req.ToBatchID, req.PenID, operatorID, req.Remarks)
		},
		"划拨成功",
		func(ctx echo.Context) (uint32, error) { // 自定义ID提取器，从 ":fromBatchID" 路径参数提取
			idParam := ctx.Param("fromBatchID")
			parsedID, err := strconv.ParseUint(idParam, 10, 32)
			if err != nil {
				return 0, err
			}
			return uint32(parsedID), nil
		},
	)
}

// RemoveEmptyPenFromBatch godoc
// @Summary      从猪批次移除空栏
// @Description  将一个空闲猪栏从指定的猪批次中移除
// @Tags         猪群管理
// @Security     BearerAuth
// @Produce      json
// @Param        batchID path int true "猪批次ID"
// @Param        penID path int true "待移除的猪栏ID"
// @Success      200 {object} controller.Response "移除成功"
// @Router       /api/v1/pig-batches/remove-pen/{penID}/{batchID} [delete]
func (c *PigBatchController) RemoveEmptyPenFromBatch(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "RemoveEmptyPenFromBatch")

	const action = "从猪批次移除空栏"

	return handleNoBodyAPIRequest(
		reqCtx, c, ctx, action,
		func(ctx echo.Context, operatorID uint32, primaryID uint32) error {
			// primaryID 在这里是 batchID
			penIDParam := ctx.Param("penID")
			parsedPenID, err := strconv.ParseUint(penIDParam, 10, 32)
			if err != nil {
				return err // 返回错误，因为 penID 格式无效
			}
			return c.service.RemoveEmptyPenFromBatch(reqCtx, primaryID, uint32(parsedPenID))
		},
		"移除成功",
		func(ctx echo.Context) (uint32, error) { // 自定义ID提取器，从 ":batchID" 路径参数提取
			idParam := ctx.Param("batchID")
			parsedID, err := strconv.ParseUint(idParam, 10, 32)
			if err != nil {
				return 0, err
			}
			return uint32(parsedID), nil
		},
	)
}

// MovePigsIntoPen godoc
// @Summary      将猪只从“虚拟库存”移入指定猪栏
// @Description  将指定数量的猪只从批次的“虚拟库存”移入一个已分配的猪栏
// @Tags         猪群管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        id path int true "猪批次ID"
// @Param        body body dto.MovePigsIntoPenRequest true "移入猪只请求信息 (包含目标猪栏ID、数量和备注)"
// @Success      200 {object} controller.Response "移入成功"
// @Router       /api/v1/pig-batches/move-pigs-into-pen/{id} [post]
func (c *PigBatchController) MovePigsIntoPen(ctx echo.Context) error {
	reqCtx := logs.AddFuncName(ctx.Request().Context(), c.ctx, "MovePigsIntoPen")

	const action = "将猪只移入猪栏"
	var req dto.MovePigsIntoPenRequest

	return handleAPIRequest(
		reqCtx, c, ctx, action, &req,
		func(ctx echo.Context, operatorID uint32, primaryID uint32, req *dto.MovePigsIntoPenRequest) error {
			return c.service.MovePigsIntoPen(reqCtx, primaryID, req.ToPenID, req.Quantity, operatorID, req.Remarks)
		},
		"移入成功",
		nil, // 默认从 ":id" 路径参数提取ID
	)
}
