package handler

import (
	"net/http"

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

type TaskHandler struct {
	taskClient *grpc_client.TaskClient
}

func NewTaskHandler(taskClient *grpc_client.TaskClient) *TaskHandler {
	return &TaskHandler{taskClient: taskClient}
}

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

	var req domain.TaskRequest
	if err := utils.DecodeJSON(r, &req); err != nil {
		utils.RespondError(w, err)
		return
	}

	req.CompetitionID = competitionID
	task := utils.TaskHTTPToProto(&req)
	resp, err := h.taskClient.CreateTask(r.Context(), task)
	if err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to create task"))
		return
	}

	utils.RespondJSON(w, http.StatusCreated, utils.TaskProtoToHTTP(resp))
}

func (h *TaskHandler) GetTask(w http.ResponseWriter, r *http.Request) {
	taskID := getPathParam(r, "task_id")

	task, err := h.taskClient.GetTask(r.Context(), taskID)
	if err != nil {
		utils.RespondError(w, domain.NewNotFoundError("task not found"))
		return
	}

	utils.RespondJSON(w, http.StatusOK, utils.TaskProtoToHTTP(task))
}

func (h *TaskHandler) UpdateTask(w http.ResponseWriter, r *http.Request) {
	competitionID := getPathParam(r, "competition_id")
	taskID := getPathParam(r, "task_id")

	var req domain.TaskRequest
	if err := utils.DecodeJSON(r, &req); err != nil {
		utils.RespondError(w, err)
		return
	}

	req.ID = taskID
	req.CompetitionID = competitionID
	task := utils.TaskHTTPToProto(&req)
	resp, err := h.taskClient.EditTask(r.Context(), task)
	if err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to update task"))
		return
	}

	utils.RespondJSON(w, http.StatusOK, utils.TaskProtoToHTTP(resp))
}

func (h *TaskHandler) DeleteTask(w http.ResponseWriter, r *http.Request) {
	taskID := getPathParam(r, "task_id")

	if err := h.taskClient.DeleteTask(r.Context(), taskID); err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to delete task"))
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

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

	tasks, err := h.taskClient.ListCompetitionTasks(r.Context(), competitionID)
	if err != nil {
		utils.RespondError(w, domain.NewInternalServerError("failed to list tasks"))
		return
	}

	response := make([]domain.TaskResponse, len(tasks))
	for i, task := range tasks {
		response[i] = *utils.TaskProtoToHTTP(task)
	}

	utils.RespondJSON(w, http.StatusOK, &domain.ListTasksResponse{Tasks: response})
}