import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";
import { taskService } from "../services/task.service";
import { PaginationParams } from "@/lib/pagination";
import toast from "react-hot-toast";
import { CreateTaskWithDocsResult, Task } from "../type/task.type";

const TASK_KEY = "tasks";
const SVC_KEY = "available-services";
const SVC_DETAIL_KEY = "service-detail";

const getErrorMessage = (err: unknown, fallback: string) => {
  if (err instanceof AxiosError) {
    return err.response?.data?.error || fallback;
  }
  return fallback;
};

export const useGetAvailableServices = () =>
  useQuery({
    queryKey: [SVC_KEY],
    queryFn: () => taskService.getAvailableServices(),
  });

export const useGetServiceDetail = (serviceId: string) =>
  useQuery({
    queryKey: [SVC_DETAIL_KEY, serviceId],
    queryFn: () => taskService.getServiceDetail(serviceId),
    enabled: !!serviceId,
  });

export const useGetTasks = (
  params: PaginationParams & { status?: string; search?: string },
) =>
  useQuery({
    queryKey: [TASK_KEY, params],
    queryFn: () => taskService.getTasks(params),
    placeholderData: (prev) => prev,
  });

export const useGetTask = (taskId: string) =>
  useQuery({
    queryKey: [TASK_KEY, taskId],
    queryFn: () => taskService.getTask(taskId),
    enabled: !!taskId,
  });

export const useCreateTaskWithDocuments = (
  onSuccess?: (result: CreateTaskWithDocsResult) => void,
) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (formData: FormData) =>
      taskService.createTaskWithDocuments(formData),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      toast.success(res.message || "Task created successfully!");
      onSuccess?.(res.data);
    },
    onError: (err: AxiosError<{ error?: string }>) => {
      toast.error(getErrorMessage(err, "Failed to create task"));
    },
  });
};

export const useUpdateTask = (
  taskId: string,
  onSuccess?: (result: Task) => void,
) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (formData: FormData) =>
      taskService.updateTask(taskId, formData),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      toast.success(res.message || "Task updated successfully!");
      onSuccess?.(res.data);
    },
    onError: (err: AxiosError<{ error?: string }>) => {
      toast.error(getErrorMessage(err, "Failed to update task"));
    },
  });
};

export const useDeleteTask = (onSuccess?: () => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (taskId: string) => taskService.deleteTask(taskId),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      toast.success(res.message || "Task deleted successfully!");
      onSuccess?.();
    },
    onError: (err: AxiosError<{ error?: string }>) => {
      toast.error(getErrorMessage(err, "Failed to delete task"));
    },
  });
};

export const useUploadTaskDocuments = (
  taskId: string,
  onSuccess?: () => void,
) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (files: File[]) =>
      taskService.uploadTaskDocuments(taskId, files),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY, taskId] });
      toast.success(res.message || "Documents uploaded successfully!");
      onSuccess?.();
    },
    onError: (err: AxiosError<{ error?: string }>) => {
      toast.error(getErrorMessage(err, "Failed to upload documents"));
    },
  });
};

export const useDeleteTaskDocument = (
  taskId: string,
  onSuccess?: () => void,
) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (documentId: string) =>
      taskService.deleteTaskDocument(taskId, documentId),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY, taskId] });
      toast.success(res.message || "Document deleted successfully!");
      onSuccess?.();
    },
    onError: (err: AxiosError<{ error?: string }>) => {
      toast.error(getErrorMessage(err, "Failed to delete document"));
    },
  });
};

export const useClientDecideTask = (onSuccess?: (result: Task) => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({
      taskId,
      body,
    }: {
      taskId: string;
      body: { status: "APPROVED" | "REJECTED"; remarks?: string };
    }) => taskService.clientDecideTask(taskId, body),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      toast.success(res.message || "Task decision submitted successfully!");
      onSuccess?.(res.data);
    },
    onError: (err: AxiosError<{ error?: string }>) => {
      toast.error(getErrorMessage(err, "Failed to submit decision"));
    },
  });
};