import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { api } from '@/lib/api';
import type {
  AdjudicateInput,
  AdminActivityQueryInput,
  AdminDisputesQueryInput,
  AdminOrdersQueryInput,
  AdminStoresQueryInput,
} from '@alqove/api-client';

export const ADMIN_NOTIFICATION_CATEGORIES = 'disputes,account_admin,system';

export function useAdminDashboard() {
  return useQuery({
    queryKey: ['admin', 'dashboard'],
    queryFn: () => api.admin.dashboardMetrics(),
    refetchInterval: 30_000,
  });
}

export function useAdminStores(params: AdminStoresQueryInput) {
  return useQuery({
    queryKey: ['admin', 'stores', params],
    queryFn: () => api.admin.listStores(params),
  });
}

export function useAdminOrders(params: AdminOrdersQueryInput) {
  return useQuery({
    queryKey: ['admin', 'orders', params],
    queryFn: () => api.admin.listOrders(params),
  });
}

export function useAdminDisputes(params: AdminDisputesQueryInput) {
  return useQuery({
    queryKey: ['admin', 'disputes', params],
    queryFn: () => api.admin.listDisputes(params),
  });
}

export function useAdminDispute(purchaseId: string | null) {
  return useQuery({
    queryKey: ['admin', 'dispute', purchaseId],
    queryFn: () => api.admin.showDispute(purchaseId!),
    enabled: Boolean(purchaseId),
  });
}

export function useAdjudicateDispute(purchaseId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (body: AdjudicateInput) => api.admin.adjudicate(purchaseId, body),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'dispute', purchaseId] });
      qc.invalidateQueries({ queryKey: ['admin', 'disputes'] });
      qc.invalidateQueries({ queryKey: ['admin', 'dashboard'] });
    },
  });
}

export function useSubmitEvidence(purchaseId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (extraText?: string) => api.admin.submitEvidence(purchaseId, extraText),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'dispute', purchaseId] });
      qc.invalidateQueries({ queryKey: ['admin', 'disputes'] });
    },
  });
}

export function useAdminStore(storeId: string | null) {
  return useQuery({
    queryKey: ['admin', 'store', storeId],
    queryFn: () => api.admin.showStore(storeId!),
    enabled: Boolean(storeId),
  });
}

export function useAdminVerifyStore(storeId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (justification: string) => api.admin.verifyStore(storeId, justification),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'store', storeId] });
      qc.invalidateQueries({ queryKey: ['admin', 'stores'] });
      qc.invalidateQueries({ queryKey: ['admin', 'dashboard'] });
    },
  });
}

export function useAdminSuspendStore(storeId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (justification: string) => api.admin.suspendStore(storeId, justification),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'store', storeId] });
      qc.invalidateQueries({ queryKey: ['admin', 'stores'] });
      qc.invalidateQueries({ queryKey: ['admin', 'orders'] });
      qc.invalidateQueries({ queryKey: ['admin', 'dashboard'] });
    },
  });
}

export function useAdminUnsuspendStore(storeId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (justification: string) => api.admin.unsuspendStore(storeId, justification),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'store', storeId] });
      qc.invalidateQueries({ queryKey: ['admin', 'stores'] });
    },
  });
}

export function useAdminOrder(orderId: string | null) {
  return useQuery({
    queryKey: ['admin', 'order', orderId],
    queryFn: () => api.admin.showOrder(orderId!),
    enabled: Boolean(orderId),
  });
}

export function useAdminRefund(orderId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({ amountCents, justification }: { amountCents: number; justification: string }) =>
      api.admin.refundOrder(orderId, amountCents, justification),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'order', orderId] });
      qc.invalidateQueries({ queryKey: ['admin', 'orders'] });
      qc.invalidateQueries({ queryKey: ['admin', 'dashboard'] });
    },
  });
}

export function useAdminForceCancel(orderId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (justification: string) => api.admin.forceCancelOrder(orderId, justification),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['admin', 'order', orderId] });
      qc.invalidateQueries({ queryKey: ['admin', 'orders'] });
    },
  });
}

export function useAdminReverseTransfer(orderId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (justification: string) => api.admin.reverseOrderTransfer(orderId, justification),
    onSuccess: () => qc.invalidateQueries({ queryKey: ['admin', 'order', orderId] }),
  });
}

export function useAdminInbox(filter: 'all' | 'unread' = 'all') {
  return useQuery({
    queryKey: ['admin', 'inbox', filter],
    queryFn: () =>
      api.notifications.list({
        filter,
        category: ADMIN_NOTIFICATION_CATEGORIES,
        per_page: 50,
      }),
    refetchInterval: 60_000,
  });
}

export function useAdminInboxUnreadCount() {
  return useQuery({
    queryKey: ['admin', 'inbox-unread'],
    queryFn: () => api.notifications.unreadCount(),
    refetchInterval: 30_000,
  });
}

export function useAdminActivity(params: AdminActivityQueryInput = {}) {
  return useQuery({
    queryKey: ['admin', 'activity', params],
    queryFn: () => api.admin.listActivity(params),
  });
}