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"
)

// GetAllLeagues godoc
// @Summary Gets all leagues
// @Description Gets all leagues
// @Tags leagues
// @Accept json
// @Produce json
// @Success 200 {array} domain.League
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/leagues [get]
func (h *Handler) GetAllLeagues(c *fiber.Ctx) error {
	page := c.QueryInt("page", 1)
	pageSize := c.QueryInt("page_size", 10)

	limit := domain.ValidInt64{
		Value: int64(pageSize),
		Valid: pageSize == 0,
	}
	offset := domain.ValidInt64{
		Value: int64(page - 1),
		Valid: true,
	}

	countryCodeQuery := c.Query("cc")
	countryCode := domain.ValidString{
		Value: countryCodeQuery,
		Valid: countryCodeQuery != "",
	}
	isActiveQuery := c.QueryBool("is_active", false)
	isActiveFilter := c.QueryBool("is_active_filter", false)
	isActive := domain.ValidBool{
		Value: isActiveQuery,
		Valid: isActiveFilter,
	}

	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("sport_id", 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,
		}
	}

	leagues, err := h.leagueSvc.GetAllLeagues(c.Context(), domain.LeagueFilter{
		CountryCode: countryCode,
		IsActive:    isActive,
		SportID:     sportID,
		Limit:       limit,
		Offset:      offset,
	})

	if err != nil {
		fmt.Printf("Error fetching league %v \n", err)
		h.mongoLoggerSvc.Error("Failed to get all leagues",
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to get leagues:"+err.Error())
	}
	return response.WriteJSON(c, fiber.StatusOK, "All leagues retrieved", leagues, nil)
}

type SetLeagueActiveReq struct {
	IsActive bool `json:"is_active"`
}

// SetLeagueActive godoc
// @Summary Set the league to active
// @Description Set the league to active
// @Tags leagues
// @Accept json
// @Produce json
// @Param id path int true "League ID"
// @Param active body SetLeagueActiveReq true "League Active Request"
// @Success 200 {object} response.APIResponse
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/leagues/{id}/set-active [put]
func (h *Handler) SetLeagueActive(c *fiber.Ctx) error {
	leagueIdStr := c.Params("id")
	if leagueIdStr == "" {
		return fiber.NewError(fiber.StatusBadRequest, "Missing league id")
	}
	leagueId, err := strconv.Atoi(leagueIdStr)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, "invalid league id")
	}

	var req SetLeagueActiveReq
	if err := c.BodyParser(&req); err != nil {
		h.logger.Error("SetLeagueReq failed", "error", err)
		h.mongoLoggerSvc.Error("SetLeagueReq failed to parse request body",
			zap.Any("request", req),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, "Failed to parse request:"+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.Info("Failed to validate SetLeagueActiveReq",
			zap.Any("request", req),
			zap.Int("status_code", fiber.StatusBadRequest),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, errMsg)
	}

	if err := h.leagueSvc.SetLeagueActive(c.Context(), int64(leagueId), req.IsActive); err != nil {
		h.mongoLoggerSvc.Error("Failed to update league active",
			zap.Int64("leagueID", int64(leagueId)),
			zap.Bool("is_active", req.IsActive),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update league:"+err.Error())
	}

	h.mongoLoggerSvc.Info("League Active has been successfully updated",
		zap.Int64("userID", int64(leagueId)),
		zap.Int64("leagueID", int64(leagueId)),
		zap.Bool("is_active", req.IsActive),
		zap.Int("status_code", fiber.StatusOK),
		zap.Time("timestamp", time.Now()),
	)

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

type SetLeagueAsFeatured struct {
	IsFeatured bool `json:"is_featured" example:"true"`
}

// SetLeagueFeatured godoc
// @Summary Set the league to featured/un-featured
// @Description Set the league to featured/un-featured
// @Tags leagues
// @Accept json
// @Produce json
// @Param id path int true "League ID"
// @Param active body SetLeagueAsFeatured true "League Featured Request"
// @Success 200 {object} response.APIResponse
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/leagues/{id}/featured [put]
func (h *Handler) SetLeagueFeatured(c *fiber.Ctx) error {
	leagueIdStr := c.Params("id")
	if leagueIdStr == "" {
		return fiber.NewError(fiber.StatusBadRequest, "Missing league id")
	}
	leagueId, err := strconv.Atoi(leagueIdStr)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, "invalid league id")
	}

	var req SetLeagueAsFeatured
	if err := c.BodyParser(&req); err != nil {
		h.logger.Error("SetLeagueFeaturedReq failed", "error", err)
		h.mongoLoggerSvc.Info("SetLeagueFeaturedReq failed to parse request body",
			zap.Int("status_code", fiber.StatusBadRequest),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, "Failed to parse request body:"+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.Info("Failed to validate SetLeagueFeaturedReq",
			zap.Any("request", req),
			zap.Int("status_code", fiber.StatusBadRequest),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusBadRequest, errMsg)

	}
	err = h.leagueSvc.UpdateLeague(c.Context(), domain.UpdateLeague{
		ID: int64(leagueId),
		IsFeatured: domain.ValidBool{
			Value: req.IsFeatured,
			Valid: true,
		},
	})
	if err != nil {
		h.mongoLoggerSvc.Error("Failed to update league",
			zap.Int64("leagueID", int64(leagueId)),
			zap.Int("status_code", fiber.StatusInternalServerError),
			zap.Error(err),
			zap.Time("timestamp", time.Now()),
		)
		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update league:"+err.Error())
	}
	h.mongoLoggerSvc.Info("League Featured has been successfully updated",
		zap.Int64("userID", int64(leagueId)),
		zap.Int64("leagueID", int64(leagueId)),
		zap.Bool("is_featured", req.IsFeatured),
		zap.Int("status_code", fiber.StatusOK),
		zap.Time("timestamp", time.Now()),
	)
	return response.WriteJSON(c, fiber.StatusOK, "League updated successfully", nil, nil)
}