"use client";

import {
  useMutation,
  useQuery,
  useQueryClient,
} from "@tanstack/react-query";

import {
  getEvaluationForm,
  saveEvaluations,
  type SaveEvaluationPayload,
} from "../service/progress-report-evaluation-service";

export const evaluationQueryKeys = {
  all: ["pswg", "progress-report-evaluation"] as const,

  form: (assignmentId: number) =>
    [
      ...evaluationQueryKeys.all,
      "form",
      assignmentId,
    ] as const,

  saved: (assignmentId: number) =>
    [
      ...evaluationQueryKeys.all,
      "saved",
      assignmentId,
    ] as const,
};

function isValidId(value: number): boolean {
  return Number.isInteger(value) && value > 0;
}

function getErrorMessage(
  error: unknown,
  fallback: string,
): string {
  return error instanceof Error ? error.message : fallback;
}

export function useProgressReportEvaluationForm(
  assignmentId: number,
  enabled = true,
) {
  const validId = isValidId(assignmentId);

  const query = useQuery({
    queryKey: evaluationQueryKeys.form(assignmentId),

    queryFn: () => getEvaluationForm(assignmentId),

    enabled: enabled && validId,

    retry: 1,

    /**
     * Always treat evaluation data as stale so opening the
     * drawer gets the newest isResolved/rating/feedback values.
     */
    staleTime: 0,

    refetchOnMount: "always",

    refetchOnWindowFocus: false,
  });

  return {
    data: query.data ?? null,

    assignment: query.data?.assignment ?? null,

    items: query.data?.items ?? [],

    totalIssues: query.data?.totalIssues ?? 0,

    isLoading: query.isLoading,

    isFetching: query.isFetching,

    error: query.error
      ? getErrorMessage(
          query.error,
          "Unable to load evaluation form.",
        )
      : null,

    refetch: query.refetch,
  };
}

export function useSaveProgressReportEvaluations(
  assignmentId: number,
) {
  const queryClient = useQueryClient();

  const mutation = useMutation({
    mutationFn: (payload: SaveEvaluationPayload) =>
      saveEvaluations(assignmentId, payload),

    onSuccess: async () => {
      /**
       * Mark both evaluation caches stale.
       * Active form queries are refetched immediately.
       */
      await Promise.all([
        queryClient.invalidateQueries({
          queryKey: evaluationQueryKeys.form(assignmentId),
          refetchType: "active",
        }),

        queryClient.invalidateQueries({
          queryKey: evaluationQueryKeys.saved(assignmentId),
        }),
      ]);
    },
  });

  return {
    save: mutation.mutateAsync,

    isPending: mutation.isPending,

    error: mutation.error
      ? getErrorMessage(
          mutation.error,
          "Unable to save evaluation.",
        )
      : null,

    reset: mutation.reset,
  };
}