package handlers

import (
	"strconv"

	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/ticket"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/response"
	"github.com/gofiber/fiber/v2"
)

// CreateTicket godoc
// @Summary Create a temporary ticket
// @Description Creates a temporary ticket
// @Tags ticket
// @Accept json
// @Produce json
// @Param createTicket body domain.CreateTicketReq true "Creates ticket"
// @Success 200 {object} domain.CreateTicketRes
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /ticket [post]
func (h *Handler) CreateTicket(c *fiber.Ctx) error {
	var req domain.CreateTicketReq
	if err := c.BodyParser(&req); err != nil {
		h.logger.Error("Failed to parse CreateTicket request", "error", err)
		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
	}

	if valErrs, ok := h.validator.Validate(c, req); !ok {
		return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid request", valErrs, nil)
	}

	newTicket, rows, err := h.ticketSvc.CreateTicket(c.Context(), req, c.IP())

	if err != nil {
		switch err {
		case ticket.ErrEventHasBeenRemoved, ticket.ErrTicketHasExpired,
			ticket.ErrRawOddInvalid, ticket.ErrTooManyOutcomesForTicket,
			ticket.ErrTicketAmountTooHigh, ticket.ErrTicketLimitForSingleUser,
			ticket.ErrTicketWinningTooHigh:
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}
	res := domain.CreateTicketRes{
		FastCode:      newTicket.ID,
		CreatedNumber: rows,
	}
	return response.WriteJSON(c, fiber.StatusOK, "Ticket Created", res, nil)

}

// GetTicketByID godoc
// @Summary Get ticket by ID
// @Description Retrieve ticket details by ticket ID
// @Tags ticket
// @Accept json
// @Produce json
// @Param id path int true "Ticket ID"
// @Success 200 {object} domain.TicketRes
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /ticket/{id} [get]
func (h *Handler) GetTicketByID(c *fiber.Ctx) error {
	ticketID := c.Params("id")
	id, err := strconv.ParseInt(ticketID, 10, 64)
	if err != nil {
		h.logger.Error("Invalid ticket ID", "ticketID", ticketID, "error", err)
		return fiber.NewError(fiber.StatusBadRequest, "Invalid ticket ID")
	}

	ticket, err := h.ticketSvc.GetTicketByID(c.Context(), id)
	if err != nil {
		h.logger.Error("Failed to get ticket by ID", "ticketID", id, "error", err)
		return fiber.NewError(fiber.StatusNotFound, "Failed to retrieve ticket")
	}

	res := domain.TicketRes{
		ID:        ticket.ID,
		Outcomes:  ticket.Outcomes,
		Amount:    ticket.Amount.Float32(),
		TotalOdds: ticket.TotalOdds,
	}
	return response.WriteJSON(c, fiber.StatusOK, "Ticket retrieved successfully", res, nil)
}

// GetAllTickets godoc
// @Summary Get all tickets
// @Description Retrieve all tickets
// @Tags ticket
// @Accept json
// @Produce json
// @Success 200 {array} domain.TicketRes
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /ticket [get]
func (h *Handler) GetAllTickets(c *fiber.Ctx) error {

	tickets, err := h.ticketSvc.GetAllTickets(c.Context())
	if err != nil {
		h.logger.Error("Failed to get tickets", "error", err)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to retrieve tickets")
	}

	res := make([]domain.TicketRes, len(tickets))
	for i, ticket := range tickets {
		res[i] = domain.TicketRes{
			ID:        ticket.ID,
			Outcomes:  ticket.Outcomes,
			Amount:    ticket.Amount.Float32(),
			TotalOdds: ticket.TotalOdds,
		}
	}

	return response.WriteJSON(c, fiber.StatusOK, "All tickets retrieved successfully", res, nil)
}