import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { adminTaskService } from "../services/task.service";
import { AdminUpdateTaskPayload } from "../types/task.type";
import { PaginationParams } from "@/lib/pagination";
import { showToast } from "@/lib/toast";

const TASK_KEY = "admin-tasks";
const EMP_KEY = "admin-active-employees";
const CLIENT_KEY = "admin-active-clients";
const DEPT_EMP_KEY = "admin-dept-employees";

export const useAdminTaskStats = () =>
  useQuery({
    queryKey: [TASK_KEY, "stats"],
    queryFn: () => adminTaskService.getTaskStats(),
    select: (res) => res.data,
    staleTime: 30_000,
  });

export const useAdminGetTasks = (
  params: PaginationParams & { clientId?: string; departmentId?: string; assignedEmployeeId?: string; priority?: string }
) =>
  useQuery({
    queryKey: [TASK_KEY, params],
    queryFn: () => adminTaskService.getTasks(params),
    placeholderData: (prev) => prev,
  });

export const useAdminGetTask = (taskId: string) =>
  useQuery({
    queryKey: [TASK_KEY, taskId],
    queryFn: () => adminTaskService.getTask(taskId),
    select: (res) => res.data,
    enabled: !!taskId,
  });

export const useAdminUpdateTask = (onSuccess?: () => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({ taskId, payload }: { taskId: string; payload: AdminUpdateTaskPayload }) =>
      adminTaskService.updateTask(taskId, payload),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      showToast.success(res.message || "Task updated successfully!");
      onSuccess?.();
    },
    onError: (err: any) => {
      showToast.error(err?.response?.data?.error || "Failed to update task");
    },
  });
};

export const useAdminActiveEmployees = () =>
  useQuery({
    queryKey: [EMP_KEY],
    queryFn: () => adminTaskService.getActiveEmployees(),
    select: (res) => res.data,
    staleTime: 5 * 60 * 1000,
  });

export const useAdminActiveClients = (search: string, page = 1) =>
  useQuery({
    queryKey: [CLIENT_KEY, search, page],
    queryFn: () => adminTaskService.getActiveClients({ search: search || undefined, page, limit: 10 }),
    staleTime: 30 * 1000,
  });

export const useAdminEmployeesByDepartment = (departmentId: string, search: string) =>
  useQuery({
    queryKey: [DEPT_EMP_KEY, departmentId, search],
    queryFn: () => adminTaskService.getEmployeesByDepartment(departmentId, { search: search || undefined }),
    select: (res) => res.data,
    enabled: !!departmentId,
    staleTime: 30 * 1000,
  });
export const useAdminDeleteTask = (onSuccess?: () => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (taskId: string) => adminTaskService.deleteTask(taskId),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      showToast.success("Task deleted successfully!");
      onSuccess?.();
    },
    onError: (err: any) => {
      showToast.error(err?.response?.data?.error || "Failed to delete task");
    },
  });
};

export const useAdminCreateTask = (onSuccess?: () => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (formData: FormData) => adminTaskService.createTask(formData),
    onSuccess: (res) => {
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      showToast.success(res.message || "Task created successfully!");
      onSuccess?.();
    },
    onError: (err: any) => {
      showToast.error(err?.response?.data?.error || "Failed to create task");
    },
  });
};

export const useAdminUploadTaskDocuments = (taskId: string, onSuccess?: () => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (files: File[]) => adminTaskService.uploadTaskDocuments(taskId, files),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: [TASK_KEY, taskId] });
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      showToast.success("Documents uploaded successfully!");
      onSuccess?.();
    },
    onError: (err: any) => {
      showToast.error(err?.response?.data?.error || "Failed to upload documents");
    },
  });
};

export const useAdminDeleteTaskDocument = (taskId: string, onSuccess?: () => void) => {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (documentId: string) => adminTaskService.deleteTaskDocument(taskId, documentId),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: [TASK_KEY, taskId] });
      qc.invalidateQueries({ queryKey: [TASK_KEY] });
      showToast.success("Document deleted!");
      onSuccess?.();
    },
    onError: (err: any) => {
      showToast.error(err?.response?.data?.error || "Failed to delete document");
    },
  });
};