package handlers

import (
	"fmt"
	"strconv"
	"time"

	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/response"
	"github.com/gofiber/fiber/v2"
	"go.uber.org/zap"
)

// @Summary Retrieve all upcoming events
// @Description Retrieve all upcoming events from the database
// @Tags prematch
// @Accept json
// @Produce json
// @Param page query int false "Page number"
// @Param page_size query int false "Page size"
// @Param league_id query string false "League ID Filter"
// @Param sport_id query string false "Sport ID Filter"
// @Param cc query string false "Country Code Filter"
// @Param first_start_time query string false "Start Time"
// @Param last_start_time query string false "End Time"
// @Success 200 {array} domain.UpcomingEvent
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/events [get]
func (h *Handler) GetAllUpcomingEvents(c *fiber.Ctx) error {
	page := c.QueryInt("page", 1)
	pageSize := c.QueryInt("page_size", 10)
	limit := domain.ValidInt64{
		Value: int64(pageSize),
		Valid: true,
	}
	offset := domain.ValidInt64{
		Value: int64(page - 1),
		Valid: true,
	}

	leagueIDQuery := c.Query("league_id")
	var leagueID domain.ValidInt32
	if leagueIDQuery != "" {
		leagueIDInt, err := strconv.Atoi(leagueIDQuery)
		if err != nil {
			h.mongoLoggerSvc.Error("invalid league id",
				zap.String("league_id", leagueIDQuery),
				zap.Int("status_code", fiber.StatusBadRequest),
				zap.Error(err),
				zap.Time("timestamp", time.Now()),
			)
			return fiber.NewError(fiber.StatusBadRequest, "invalid league id")
		}
		leagueID = domain.ValidInt32{
			Value: int32(leagueIDInt),
			Valid: true,
		}
	}
	sportIDQuery := c.Query("sport_id")
	var sportID domain.ValidInt32
	if sportIDQuery != "" {
		sportIDint, err := strconv.Atoi(sportIDQuery)
		if err != nil {
			h.mongoLoggerSvc.Info("invalid sport id",
				zap.String("sportID", sportIDQuery),
				zap.Int("status_code", fiber.StatusBadRequest),
				zap.Error(err),
				zap.Time("timestamp", time.Now()),
			)
			return fiber.NewError(fiber.StatusBadRequest, "invalid sport id")
		}
		sportID = domain.ValidInt32{
			Value: int32(sportIDint),
			Valid: true,
		}
	}
	firstStartTimeQuery := c.Query("first_start_time")
	var firstStartTime domain.ValidTime
	if firstStartTimeQuery != "" {
		firstStartTimeParsed, err := time.Parse(time.RFC3339, firstStartTimeQuery)
		if err != nil {
			h.mongoLoggerSvc.Info("invalid start_time format",
				zap.String("first_start_time", firstStartTimeQuery),
				zap.Int("status_code", fiber.StatusBadRequest),
				zap.Error(err),
				zap.Time("timestamp", time.Now()),
			)
			return fiber.NewError(fiber.StatusBadRequest, "Invalid start_time format")
		}
		firstStartTime = domain.ValidTime{
			Value: firstStartTimeParsed,
			Valid: true,
		}
	}

	lastStartTimeQuery := c.Query("last_start_time")
	var lastStartTime domain.ValidTime
	if lastStartTimeQuery != "" {
		lastStartTimeParsed, err := time.Parse(time.RFC3339, lastStartTimeQuery)
		if err != nil {
			h.mongoLoggerSvc.Info("invalid start_time format",
				zap.String("last_start_time", lastStartTimeQuery),
				zap.Int("status_code", fiber.StatusBadRequest),
				zap.Error(err),
				zap.Time("timestamp", time.Now()),
			)
			return fiber.NewError(fiber.StatusBadRequest, "Invalid start_time format")
		}
		lastStartTime = domain.ValidTime{
			Value: lastStartTimeParsed,
			Valid: true,
		}
	}

	countryCodeQuery := c.Query("cc")
	countryCode := domain.ValidString{
		Value: countryCodeQuery,
		Valid: countryCodeQuery != "",
	}

	flaggedQuery := c.Query("flagged")
	var flagged domain.ValidBool
	if flaggedQuery != "" {
		flaggedParsed, err := strconv.ParseBool(flaggedQuery)
		if err != nil {
			h.mongoLoggerSvc.Error("Failed to parse flagged",
				zap.Int("status_code", fiber.StatusBadRequest),
				zap.Error(err),
				zap.Time("timestamp", time.Now()),
			)
			return fiber.NewError(fiber.StatusBadRequest, "Failed to parse is_shop_bet")
		}

		flagged = domain.ValidBool{
			Value: flaggedParsed,
			Valid: true,
		}
	}

	events, total, err := h.eventSvc.GetPaginatedUpcomingEvents(
		c.Context(), domain.EventFilter{
			SportID:        sportID,
			LeagueID:       leagueID,
			FirstStartTime: firstStartTime,
			LastStartTime:  lastStartTime,
			Limit:          limit,
			Offset:         offset,
			CountryCode:    countryCode,
			Flagged:        flagged,
		})

	// fmt.Printf("League ID: %v", leagueID)
	if err != nil {
		h.mongoLoggerSvc.Error("Failed to retrieve all upcoming events",
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	return response.WritePaginatedJSON(c, fiber.StatusOK, "All upcoming events retrieved successfully", events, nil, page, int(total))

}

type TopLeaguesRes struct {
	Leagues []TopLeague `json:"leagues"`
}

type TopLeague struct {
	LeagueID      int64                  `json:"league_id"`
	LeagueName    string                 `json:"league_name"`
	LeagueCC      string                 `json:"league_cc"`
	LeagueSportID int32                  `json:"league_sport_id"`
	Events        []domain.UpcomingEvent `json:"events"`
	// Total    int64                  `json:"total"`
}

// @Summary Retrieve all top leagues
// @Description Retrieve all top leagues
// @Tags prematch
// @Accept json
// @Produce json
// @Success 200 {array} TopLeague
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/top-leagues [get]
func (h *Handler) GetTopLeagues(c *fiber.Ctx) error {

	leagues, err := h.leagueSvc.GetFeaturedLeagues(c.Context())

	if err != nil {
		h.mongoLoggerSvc.Error("Error while fetching top leagues",
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	var topLeague []TopLeague = make([]TopLeague, 0, len(leagues))
	for _, league := range leagues {
		events, _, err := h.eventSvc.GetPaginatedUpcomingEvents(
			c.Context(), domain.EventFilter{
				LeagueID: domain.ValidInt32{
					Value: int32(league.ID),
					Valid: true,
				},
			})
		if err != nil {
			h.mongoLoggerSvc.Warn("Error while fetching events for top league",
				zap.Int64("LeagueID", league.ID),
				zap.Int("status_code", fiber.StatusInternalServerError),
				zap.Error(err),
				zap.Time("timestamp", time.Now()),
			)
		}
		topLeague = append(topLeague, TopLeague{
			LeagueID:      league.ID,
			LeagueName:    league.Name,
			LeagueCC:      league.CountryCode,
			LeagueSportID: league.SportID,
			Events:        events,
		})
	}

	res := TopLeaguesRes{
		Leagues: topLeague,
	}
	return response.WriteJSON(c, fiber.StatusOK, "All top leagues events retrieved successfully", res, nil)

}

// @Summary Retrieve an upcoming by ID
// @Description Retrieve an upcoming event by ID
// @Tags prematch
// @Accept json
// @Produce json
// @Param id path string true "ID"
// @Success 200 {object} domain.UpcomingEvent
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/events/{id} [get]
func (h *Handler) GetUpcomingEventByID(c *fiber.Ctx) error {

	id := c.Params("id")
	if id == "" {
		h.mongoLoggerSvc.Info("Failed to parse event id",
			zap.String("id", id),
			zap.Int("status_code", fiber.StatusBadRequest),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, "Missing id")
	}

	event, err := h.eventSvc.GetUpcomingEventByID(c.Context(), id)
	if err != nil {
		h.mongoLoggerSvc.Error("Failed to get upcoming event by id",
			zap.String("eventID", id),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	return response.WriteJSON(c, fiber.StatusOK, "Upcoming event retrieved successfully", event, nil)

}

type UpdateEventStatusReq struct {
}

// SetEventStatusToRemoved godoc
// @Summary Set the event status to removed
// @Description Set the event status to removed
// @Tags event
// @Accept json
// @Produce json
// @Param id path int true "Event ID"
// @Success 200 {object} response.APIResponse
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/events/{id} [delete]
func (h *Handler) SetEventStatusToRemoved(c *fiber.Ctx) error {
	eventID := c.Params("id")
	err := h.eventSvc.UpdateEventStatus(c.Context(), eventID, domain.STATUS_REMOVED)

	if err != nil {
		h.mongoLoggerSvc.Error("Failed to update event status",
			zap.String("EventID", eventID),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update event status")
	}

	return response.WriteJSON(c, fiber.StatusOK, "Event updated successfully", nil, nil)

}

type UpdateEventFlaggedReq struct {
	Flagged bool `json:"flagged" example:"true"`
}

// UpdateEventFlagged godoc
// @Summary update the event flagged
// @Description Update the event flagged
// @Tags event
// @Accept json
// @Produce json
// @Param id path int true "Event ID"
// @Success 200 {object} response.APIResponse
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/events/{id}/flag [put]
func (h *Handler) UpdateEventFlagged(c *fiber.Ctx) error {
	eventID := c.Params("id")

	var req UpdateEventFlaggedReq

	if err := c.BodyParser(&req); err != nil {
		h.mongoLoggerSvc.Info("Failed to parse user id",
			zap.String("eventID", eventID),
			zap.Int("status_code", fiber.StatusBadRequest),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}

	valErrs, ok := h.validator.Validate(c, req)
	if !ok {
		var errMsg string
		for field, msg := range valErrs {
			errMsg += fmt.Sprintf("%s: %s; ", field, msg)
		}
		h.mongoLoggerSvc.Error("Failed to update event flagged",
			zap.Any("request", req),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, errMsg)
	}
	err := h.eventSvc.UpdateFlagged(c.Context(), eventID, req.Flagged)

	if err != nil {
		h.mongoLoggerSvc.Error("Failed to update event flagged",
			zap.String("eventID", eventID),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	return response.WriteJSON(c, fiber.StatusOK, "Event updated successfully", nil, nil)

}