package handlers

import (
	"log"
	"strconv"
	"strings"

	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/gofiber/fiber/v2"
)

// GetPreMatchOdds godoc
// @Summary      Get pre-match odds for an event
// @Description  Fetches pre-match odds from EnetPulse for a given event
// @Tags         EnetPulse - PreMatch
// @Accept       json
// @Produce      json
// @Param        objectFK query int true "Event ID"
// @Param        oddsProviderFK query []int false "Odds provider IDs (comma separated)"
// @Param        outcomeTypeFK query int false "Outcome type ID"
// @Param        outcomeScopeFK query int false "Outcome scope ID"
// @Param        outcomeSubtypeFK query int false "Outcome subtype ID"
// @Param        limit query int false "Limit results"
// @Param        offset query int false "Offset results"
// @Param        languageTypeFK query int false "Language type ID"
// @Success      200 {object} domain.Response{data=domain.PreMatchOddsResponse}
// @Failure      400 {object} domain.ErrorResponse
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/odds/pre-match [get]
func (h *Handler) GetPreMatchOdds(c *fiber.Ctx) error {
	// Parse query parameters
	objectFK := c.QueryInt("objectFK")
	if objectFK == 0 {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Event ID (objectFK) is required",
			Error:   "missing or invalid objectFK",
		})
	}

	params := domain.PreMatchOddsRequest{
		ObjectFK:         int64(objectFK),
		OddsProviderFK:   intSliceToInt64Slice(parseIntSlice(c.Query("oddsProviderFK"))), // convert []int to []int64
		OutcomeTypeFK:    int64(c.QueryInt("outcomeTypeFK")),
		OutcomeScopeFK:   int64(c.QueryInt("outcomeScopeFK")),
		OutcomeSubtypeFK: int64(c.QueryInt("outcomeSubtypeFK")),
		Limit:            c.QueryInt("limit"),
		Offset:           c.QueryInt("offset"),
		LanguageTypeFK:   int64(c.QueryInt("languageTypeFK")),
	}

	// Call service
	res, err := h.enetPulseSvc.FetchPreMatchOdds(c.Context(), params)
	if err != nil {
		log.Println("FetchPreMatchOdds error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch pre-match odds",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "Pre-match odds fetched successfully",
		Data:       res,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetAllSports godoc
// @Summary      Get all sports
// @Description  Fetches all sports stored in the database
// @Tags         EnetPulse - Sports
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseSport}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/sports [get]
func (h *Handler) GetAllSports(c *fiber.Ctx) error {
	// Call service
	sports, err := h.enetPulseSvc.GetAllSports(c.Context())
	if err != nil {
		log.Println("GetAllSports error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch sports",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "Sports fetched successfully",
		Data:       sports,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetAllTournamentTemplates godoc
// @Summary      Get all tournament templates
// @Description  Fetches all tournament templates stored in the database
// @Tags         EnetPulse - Tournament Templates
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseTournamentTemplate}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/tournament-templates [get]
func (h *Handler) GetAllTournamentTemplates(c *fiber.Ctx) error {
	// Call service
	templates, err := h.enetPulseSvc.GetAllTournamentTemplates(c.Context())
	if err != nil {
		log.Println("GetAllTournamentTemplates error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch tournament templates",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "Tournament templates fetched successfully",
		Data:       templates,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetAllTournaments godoc
// @Summary      Get all tournaments
// @Description  Fetches all tournaments stored in the database
// @Tags         EnetPulse - Tournaments
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseTournament}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/tournaments [get]
func (h *Handler) GetAllTournaments(c *fiber.Ctx) error {
	// Call service
	tournaments, err := h.enetPulseSvc.GetAllTournaments(c.Context())
	if err != nil {
		log.Println("GetAllTournaments error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch tournaments",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "Tournaments fetched successfully",
		Data:       tournaments,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetAllTournamentStages godoc
// @Summary      Get all tournament stages
// @Description  Fetches all tournament stages stored in the database
// @Tags         EnetPulse - Tournament Stages
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseTournamentStage}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/tournament-stages [get]
func (h *Handler) GetAllTournamentStages(c *fiber.Ctx) error {
	// Call service
	stages, err := h.enetPulseSvc.GetAllTournamentStages(c.Context())
	if err != nil {
		log.Println("GetAllTournamentStages error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch tournament stages",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "Tournament stages fetched successfully",
		Data:       stages,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetFixturesByDate godoc
// @Summary      Get all stored fixtures
// @Description  Fetches all fixtures stored in the database
// @Tags         EnetPulse - Fixtures
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseFixture}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/fixtures [get]
func (h *Handler) GetFixturesByDate(c *fiber.Ctx) error {
	// Call service to get all fixtures from DB
	fixtures, err := h.enetPulseSvc.GetAllFixtures(c.Context())
	if err != nil {
		log.Println("GetAllFixtures error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch fixtures from database",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "Fixtures fetched successfully",
		Data:       fixtures,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetAllResults godoc
// @Summary      Get all results
// @Description  Fetches all EnetPulse match results stored in the database
// @Tags         EnetPulse - Results
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseResult}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/results [get]
func (h *Handler) GetAllResults(c *fiber.Ctx) error {
	// Call service
	results, err := h.enetPulseSvc.GetAllResults(c.Context())
	if err != nil {
		log.Println("GetAllResults error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch EnetPulse results",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "EnetPulse results fetched successfully",
		Data:       results,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetAllPreodds godoc
// @Summary      Get all preodds
// @Description  Fetches all EnetPulse pre-match odds stored in the database
// @Tags         EnetPulse - Preodds
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulsePreodds}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/preodds [get]
func (h *Handler) GetAllPreodds(c *fiber.Ctx) error {
	// Call service
	preodds, err := h.enetPulseSvc.GetAllPreodds(c.Context())
	if err != nil {
		log.Println("GetAllPreodds error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch EnetPulse preodds",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "EnetPulse preodds fetched successfully",
		Data:       preodds,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// GetFixturesWithPreodds godoc
// @Summary      Get fixtures with preodds
// @Description  Fetches all EnetPulse fixtures along with their associated pre-match odds
// @Tags         EnetPulse - Fixtures
// @Accept       json
// @Produce      json
// @Success      200 {object} domain.Response{data=[]domain.EnetpulseFixtureWithPreodds}
// @Failure      502 {object} domain.ErrorResponse
// @Router       /api/v1/enetpulse/fixtures/preodds [get]
func (h *Handler) GetFixturesWithPreodds(c *fiber.Ctx) error {
	// Call service
	fixtures, err := h.enetPulseSvc.GetFixturesWithPreodds(c.Context())
	if err != nil {
		log.Println("GetFixturesWithPreodds error:", err)
		return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
			Message: "Failed to fetch EnetPulse fixtures with preodds",
			Error:   err.Error(),
		})
	}

	// Return success response
	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "EnetPulse fixtures with preodds fetched successfully",
		Data:       fixtures,
		StatusCode: fiber.StatusOK,
		Success:    true,
	})
}

// Helper: parse comma-separated string into []int
func parseIntSlice(input string) []int {
	if input == "" {
		return nil
	}
	parts := strings.Split(input, ",")
	result := make([]int, 0, len(parts))
	for _, p := range parts {
		if n, err := strconv.Atoi(strings.TrimSpace(p)); err == nil {
			result = append(result, n)
		}
	}
	return result
}

// Helper: convert []int to []int64
func intSliceToInt64Slice(input []int) []int64 {
	if input == nil {
		return nil
	}
	result := make([]int64, len(input))
	for i, v := range input {
		result[i] = int64(v)
	}
	return result
}