package handler

import (
	"lune/talentscale/internal/domain"
	"lune/talentscale/pkg/response"

	"github.com/gofiber/fiber/v2"
	"github.com/google/uuid"
)

type TestTypeHandler struct {
	usecase domain.TestTypeUsecase
}

func NewTestTypeHandler(usecase domain.TestTypeUsecase) *TestTypeHandler {
	return &TestTypeHandler{usecase: usecase}
}

func (h *TestTypeHandler) List(c *fiber.Ctx) error {
	res, err := h.usecase.GetAll(c.Context())
	if err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.OK(c, "Success", res)
}

func (h *TestTypeHandler) ListActive(c *fiber.Ctx) error {
	res, err := h.usecase.GetAll(c.Context())
	if err != nil {
		return response.InternalError(c, err.Error())
	}

	// Transform to the format requested by the user
	type publicTestType struct {
		ID                uuid.UUID `json:"id"`
		Name              string    `json:"name"`
		Code              string    `json:"code"`
		Description       string    `json:"description"`
		Category          string    `json:"category"`
		EstimatedDuration int       `json:"estimated_duration"`
	}

	var result []publicTestType
	for _, tt := range res {
		// Mock duration for now or get from config if available
		duration := 15
		if tt.Category == "Cognitive" {
			duration = 30
		} else if tt.Category == "Psychological" {
			duration = 20
		}

		result = append(result, publicTestType{
			ID:                tt.ID,
			Name:              tt.Name,
			Code:              tt.Code,
			Description:       tt.Description,
			Category:          tt.Category,
			EstimatedDuration: duration,
		})
	}

	return c.Status(fiber.StatusOK).JSON(fiber.Map{
		"success": true,
		"data":    result,
	})
}

func (h *TestTypeHandler) GetByID(c *fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := uuid.Parse(idStr)
	if err != nil {
		return response.BadRequest(c, "Invalid ID format")
	}

	res, err := h.usecase.GetByID(c.Context(), id)
	if err != nil {
		return response.NotFound(c, "Test type not found")
	}
	return response.OK(c, "Success", res)
}

func (h *TestTypeHandler) Create(c *fiber.Ctx) error {
	var req domain.TestType
	if err := c.BodyParser(&req); err != nil {
		return response.BadRequest(c, "Invalid request body")
	}

	if req.ID == uuid.Nil {
		req.ID = uuid.New()
	}

	if err := h.usecase.Create(c.Context(), &req); err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.Created(c, "Test type created", req)
}

func (h *TestTypeHandler) Update(c *fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := uuid.Parse(idStr)
	if err != nil {
		return response.BadRequest(c, "Invalid ID format")
	}

	var req domain.TestType
	if err := c.BodyParser(&req); err != nil {
		return response.BadRequest(c, "Invalid request body")
	}

	req.ID = id
	if err := h.usecase.Update(c.Context(), &req); err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.OK(c, "Test type updated", req)
}

func (h *TestTypeHandler) Delete(c *fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := uuid.Parse(idStr)
	if err != nil {
		return response.BadRequest(c, "Invalid ID format")
	}

	if err := h.usecase.Delete(c.Context(), id); err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.OK(c, "Test type deleted", nil)
}