package handler

import (
	"net/http"

	"datarush/internal/gw/domain"
	"datarush/internal/gw/grpc_client"
	"datarush/internal/gw/utils"

	resultspb "datarush/pkg/api/results"
)

type ResultsHandler struct {
	resultsClient *grpc_client.ResultsClient
}

func NewResultsHandler(resultsClient *grpc_client.ResultsClient) *ResultsHandler {
	return &ResultsHandler{resultsClient: resultsClient}
}

func (h *ResultsHandler) GetCompetitionResults(w http.ResponseWriter, r *http.Request) {
	competitionID := getPathParam(r, "competition_id")
	pageSize := getQueryParamInt32(r, "page_size", 20)
	pageToken := getQueryParamInt32(r, "page_token", 0)

	req := &resultspb.GetCompetitionResultsRequest{
		CompetitionId: competitionID,
		PageSize:      pageSize,
		PageToken:     pageToken,
	}

	resp, err := h.resultsClient.GetCompetitionResults(r.Context(), req)
	if err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to get competition results"))
		return
	}

	results := make([]domain.UserResultResponse, len(resp.Results))
	for i, result := range resp.Results {
		results[i] = *utils.UserResultProtoToHTTP(result)
	}

	utils.RespondJSON(w, http.StatusOK, &domain.CompetitionResultsResponse{
		Results:       results,
		TotalCount:    resp.TotalCount,
		NextPageToken: resp.NextPageToken,
	})
}

func (h *ResultsHandler) GetMyResults(w http.ResponseWriter, r *http.Request) {
	userID, err := getUserIDFromContext(r.Context())
	if err != nil {
		utils.RespondError(w, domain.NewUnauthorizedError("unauthorized"))
		return
	}

	competitionID := getPathParam(r, "competition_id")

	result, err := h.resultsClient.GetUserCompetitionResults(r.Context(), competitionID, userID)
	if err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to get user results"))
		return
	}

	utils.RespondJSON(w, http.StatusOK, utils.UserResultProtoToHTTP(result))
}

func (h *ResultsHandler) RecalculateResults(w http.ResponseWriter, r *http.Request) {
	competitionID := getPathParam(r, "competition_id")

	if err := h.resultsClient.RecalculateResults(r.Context(), competitionID); err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to recalculate results"))
		return
	}

	w.WriteHeader(http.StatusNoContent)
}