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

export const queryKeys = {
  status: ["status"] as const,
  providers: ["providers"] as const,
  logs: ["logs"] as const,
  backups: (target: string) => ["backups", target] as const,
  settings: ["settings"] as const,
};

export function useStatus() {
  return useQuery({ queryKey: queryKeys.status, queryFn: api.getStatus, refetchInterval: 5000 });
}

export function useProviders() {
  return useQuery({ queryKey: queryKeys.providers, queryFn: api.listProviders });
}

export function useLogs() {
  return useQuery({ queryKey: queryKeys.logs, queryFn: api.listLogs, refetchInterval: 5000 });
}

export function useBackups(target: "claude" | "codex") {
  return useQuery({ queryKey: queryKeys.backups(target), queryFn: () => api.listBackups(target) });
}

export function useSettings() {
  return useQuery({ queryKey: queryKeys.settings, queryFn: api.getSettings });
}

function invalidateAll(queryClient: ReturnType<typeof useQueryClient>) {
  return Promise.all([
    queryClient.invalidateQueries({ queryKey: queryKeys.providers }),
    queryClient.invalidateQueries({ queryKey: queryKeys.status }),
    queryClient.invalidateQueries({ queryKey: ["backups"] }),
    queryClient.invalidateQueries({ queryKey: queryKeys.settings }),
  ]);
}

export function useProviderMutations() {
  const queryClient = useQueryClient();
  const create = useMutation({
    mutationFn: (input: ProviderInput) => api.createProvider(input),
    onSuccess: () => invalidateAll(queryClient),
  });
  const update = useMutation({
    mutationFn: ({ id, input }: { id: string; input: ProviderInput }) => api.updateProvider(id, input),
    onSuccess: () => invalidateAll(queryClient),
  });
  const remove = useMutation({
    mutationFn: (id: string) => api.deleteProvider(id),
    onSuccess: () => invalidateAll(queryClient),
  });
  const apply = useMutation({
    mutationFn: ({ id, target }: { id: string; target: "claude" | "codex" }) =>
      api.applyProvider(id, target),
    onSuccess: () => invalidateAll(queryClient),
  });
  return { create, update, remove, apply };
}

export function useRestore() {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: (input: Parameters<typeof api.restore>[0]) => api.restore(input),
    onSuccess: () => invalidateAll(queryClient),
  });
}

export function useSettingsMutation() {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: (patch: Parameters<typeof api.updateSettings>[0]) => api.updateSettings(patch),
    onSuccess: () => invalidateAll(queryClient),
  });
}