package admin

import (
	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"

	"github.com/break/junhong_cmp_fiber/internal/handler/validation"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	prioritypollingquery "github.com/break/junhong_cmp_fiber/internal/query/prioritypolling"
	pollingSvc "github.com/break/junhong_cmp_fiber/internal/service/polling"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/errors"
	"github.com/break/junhong_cmp_fiber/pkg/middleware"
	"github.com/break/junhong_cmp_fiber/pkg/response"
)

// PriorityPollingHandler 处理卡轮询优先队列的人工入队与只读查询请求。
type PriorityPollingHandler struct {
	enqueue   *pollingSvc.PriorityEnqueueService
	query     *prioritypollingquery.Query
	validator *validator.Validate
}

// NewPriorityPollingHandler 创建卡轮询优先队列处理器。
func NewPriorityPollingHandler(
	enqueue *pollingSvc.PriorityEnqueueService,
	query *prioritypollingquery.Query,
	validator *validator.Validate,
) *PriorityPollingHandler {
	return &PriorityPollingHandler{enqueue: enqueue, query: query, validator: validator}
}

// Enqueue 人工优先入队。
// POST /api/admin/polling-priority-items
func (h *PriorityPollingHandler) Enqueue(c *fiber.Ctx) error {
	if h.enqueue == nil {
		return errors.New(errors.CodeInternalError, "人工优先入队能力未配置")
	}
	var req dto.EnqueuePriorityPollingRequest
	if err := c.BodyParser(&req); err != nil {
		return errors.New(errors.CodeInvalidParam, "请求参数格式不正确")
	}
	if err := h.validator.Struct(&req); err != nil {
		return errors.New(errors.CodeInvalidParam, validation.Message("人工优先入队参数不合法", &req, err))
	}
	result, err := h.enqueue.Enqueue(c.UserContext(), req.CardID, req.Reason, middleware.GetUserIDFromContext(c.UserContext()))
	if err != nil {
		return err
	}
	taskTypeNames := make([]string, 0, len(result.TaskTypes))
	items := make([]dto.EnqueuePriorityPollingItemView, 0, len(result.Items))
	for _, taskType := range result.TaskTypes {
		taskTypeNames = append(taskTypeNames, constants.PollingPriorityTaskTypeName(taskType))
	}
	for _, item := range result.Items {
		items = append(items, dto.EnqueuePriorityPollingItemView{
			ItemID:          item.ItemID,
			TaskType:        item.TaskType,
			TaskTypeName:    constants.PollingPriorityTaskTypeName(item.TaskType),
			Status:          item.Status,
			StatusName:      constants.PollingPriorityStatusName(item.Status),
			TriggerCount:    item.TriggerCount,
			LastTriggeredAt: item.LastTriggeredAt,
			Created:         item.Created,
		})
	}
	return response.Success(c, dto.EnqueuePriorityPollingResponse{
		CardID:        result.CardID,
		TaskTypes:     result.TaskTypes,
		TaskTypeNames: taskTypeNames,
		CreatedCount:  result.CreatedCount,
		MergedCount:   result.MergedCount,
		Items:         items,
	})
}

// ListPriorityItems 分页查询优先轮询项。
// GET /api/admin/polling-priority-items
func (h *PriorityPollingHandler) ListPriorityItems(c *fiber.Ctx) error {
	if h.query == nil {
		return errors.New(errors.CodeInternalError, "优先轮询项查询能力未配置")
	}
	var req dto.PriorityPollingItemListRequest
	if err := c.QueryParser(&req); err != nil {
		return errors.New(errors.CodeInvalidParam, "请求参数解析失败")
	}
	if err := h.validator.Struct(&req); err != nil {
		return errors.New(errors.CodeInvalidParam, validation.Message("优先轮询项查询参数不合法", &req, err))
	}
	result, err := h.query.List(c.UserContext(), req)
	if err != nil {
		return err
	}
	return response.SuccessWithPagination(c, result.List, result.Total, result.Page, result.PageSize)
}

// GetPriorityItem 查询优先轮询项详情。
// GET /api/admin/polling-priority-items/:id
func (h *PriorityPollingHandler) GetPriorityItem(c *fiber.Ctx) error {
	if h.query == nil {
		return errors.New(errors.CodeInternalError, "优先轮询项查询能力未配置")
	}
	id, err := pathID(c)
	if err != nil {
		return err
	}
	result, err := h.query.Detail(c.UserContext(), id)
	if err != nil {
		return err
	}
	return response.Success(c, result)
}