import { useCallback, useMemo, useState } from 'react';
import { router } from '@inertiajs/react';
import type {
  OnChangeFn,
  PaginationState,
  SortingState,
} from '@tanstack/react-table';
import type { Paginated } from '@rutatiina/ui/types';

export type TableFilters = {
  sort: string;
  per_page: number;
  filter: Record<string, string>;
};

export type ExportFormat = 'csv' | 'xlsx';

type Params = {
  page?: number;
  per_page?: number;
  sort?: string;
  filter?: Record<string, string | null | undefined>;
};

function toSorting(sort: string): SortingState {
  if (!sort) return [];
  return [{ id: sort.replace(/^-/, ''), desc: sort.startsWith('-') }];
}

function toSort(sorting: SortingState): string | undefined {
  const [first] = sorting;
  return first ? `${first.desc ? '-' : ''}${first.id}` : undefined;
}

/**
 * Drives the ReUI (TanStack) DataGrid from a Laravel paginator:
 * pagination, sorting and filters live in the query string
 * (spatie/laravel-query-builder format) and each change reloads only the given props.
 */
export function useInertiaTable<T>({
  data,
  filters,
  only,
}: {
  data: Paginated<T>;
  filters: TableFilters;
  only: string[];
}) {
  const [isLoading, setIsLoading] = useState(false);

  const pagination = useMemo<PaginationState>(
    () => ({
      pageIndex: data.meta.current_page - 1,
      pageSize: data.meta.per_page,
    }),
    [data.meta.current_page, data.meta.per_page],
  );

  const sorting = useMemo(() => toSorting(filters.sort), [filters.sort]);

  const visit = useCallback(
    (params: Params) => {
      const filter = Object.fromEntries(
        Object.entries({ ...filters.filter, ...params.filter }).filter(
          ([, value]) =>
            value !== null &&
            value !== undefined &&
            value !== '' &&
            value !== 'all',
        ),
      );

      router.get(
        window.location.pathname,
        {
          page: params.page ?? 1,
          per_page: params.per_page ?? data.meta.per_page,
          sort: params.sort ?? filters.sort,
          ...(Object.keys(filter).length ? { filter } : {}),
        },
        {
          only: [...only, 'filters'],
          preserveState: true,
          preserveScroll: true,
          replace: true,
          onStart: () => setIsLoading(true),
          onFinish: () => setIsLoading(false),
        },
      );
    },
    [data.meta.per_page, filters, only],
  );

  const onPaginationChange: OnChangeFn<PaginationState> = useCallback(
    (updater) => {
      const next =
        typeof updater === 'function' ? updater(pagination) : updater;
      visit({
        page: next.pageSize !== pagination.pageSize ? 1 : next.pageIndex + 1,
        per_page: next.pageSize,
      });
    },
    [pagination, visit],
  );

  const onSortingChange: OnChangeFn<SortingState> = useCallback(
    (updater) => {
      const next = typeof updater === 'function' ? updater(sorting) : updater;
      visit({ sort: toSort(next) ?? '' });
    },
    [sorting, visit],
  );

  const setFilter = useCallback(
    (key: string, value: string | null) => visit({ filter: { [key]: value } }),
    [visit],
  );

  // The current rows (filters and sort) as a file, from the same endpoint (?export=csv).
  const exportUrl = useCallback((format: ExportFormat) => {
    const url = new URL(window.location.href);
    url.searchParams.delete('page');
    url.searchParams.delete('per_page');
    url.searchParams.set('export', format);
    return url.pathname + url.search;
  }, []);

  const reload = useCallback(
    () =>
      router.reload({
        only,
        onStart: () => setIsLoading(true),
        onFinish: () => setIsLoading(false),
      }),
    [only],
  );

  return {
    pagination,
    sorting,
    onPaginationChange,
    onSortingChange,
    filter: (key: string) => filters.filter[key] ?? '',
    setFilter,
    isLoading,
    reload,
    exportUrl,
    pageCount: data.meta.last_page,
    recordCount: data.meta.total,
  };
}
