import { Service, EventObject, Machine } from '@zag-js/core';

type SortDirection = "ascending" | "descending";
interface SortDescriptor<T> {
    column: keyof T;
    direction: SortDirection;
}
interface LoadDetails<T, C> {
    signal: AbortSignal | undefined;
    filterText: string;
    cursor?: C | undefined;
    sortDescriptor?: SortDescriptor<T> | undefined;
}
interface LoadResult<T, C> {
    items: T[];
    cursor?: C | undefined;
}
interface SortDetails<T> {
    items: T[];
    descriptor: SortDescriptor<T>;
    filterText: string;
}
type LoadDependency = string | number | boolean | undefined | null;
interface AsyncListProps<T, C> {
    /**
     * The function to call when the list is loaded
     */
    load: (args: LoadDetails<T, C>) => Promise<LoadResult<T, C>>;
    /**
     * The function to call when the list is sorted
     */
    sort?: ((args: SortDetails<T>) => Promise<{
        items: T[];
    }> | {
        items: T[];
    } | undefined) | undefined;
    /**
     * The initial items to display
     */
    initialItems?: T[] | undefined;
    /**
     * The initial sort descriptor to use
     */
    initialSortDescriptor?: SortDescriptor<T> | undefined;
    /**
     * The initial filter text to use
     */
    initialFilterText?: string | undefined;
    /**
     * The dependencies to watch for changes
     */
    dependencies?: LoadDependency[] | undefined;
    /**
     * Whether to automatically reload the list when the dependencies change
     */
    autoReload?: boolean | undefined;
    /**
     * The function to call when the list is loaded successfully
     */
    onSuccess?: ((details: {
        items: T[];
    }) => void | undefined) | undefined;
    /**
     * The function to call when the list fails to load
     */
    onError?: ((details: {
        error: Error;
    }) => void | undefined) | undefined;
}
interface AsyncListSchema<T, C> {
    state: "idle" | "loading" | "sorting";
    props: AsyncListProps<T, C>;
    context: {
        items: T[];
        filterText: string;
        cursor?: C | undefined;
        sortDescriptor?: SortDescriptor<T> | undefined;
        error?: any | undefined;
    };
    refs: {
        abort: AbortController | null;
        seq: number;
    };
    event: EventObject;
    action: string;
    guard: string;
    effect: string;
}
type AsyncListService<T, C> = Service<AsyncListSchema<T, C>>;
type AsyncListMachine<T, C> = Machine<AsyncListSchema<T, C>>;
interface AsyncListApi<T, C> {
    /**
     * The items in the list.
     */
    items: T[];
    /**
     * The filter text.
     */
    filterText: string;
    /**
     * The cursor.
     */
    cursor: C | undefined;
    /**
     * The sort descriptor.
     */
    sortDescriptor: SortDescriptor<T> | undefined;
    /**
     * Whether the list is loading.
     */
    loading: boolean;
    /**
     * Whether the list is sorting.
     */
    sorting: boolean;
    /**
     * Whether the list is empty.
     */
    empty: boolean;
    /**
     * Whether there are more items to load.
     */
    hasMore: boolean;
    /**
     * The error instance returned by the last fetch.
     */
    error: any | undefined;
    /**
     * Function to abort the current fetch.
     */
    abort: VoidFunction;
    /**
     * Function to reload the list
     */
    reload: VoidFunction;
    /**
     * Function to load more items
     */
    loadMore: VoidFunction;
    /**
     * Function to sort the list
     */
    sort: (sortDescriptor: SortDescriptor<T>) => void;
    /**
     * Function to set the filter text
     */
    setFilterText: (filterText: string) => void;
    /**
     * Function to clear the filter text
     */
    clearFilter: VoidFunction;
}

export type { AsyncListApi, AsyncListMachine, AsyncListProps, AsyncListSchema, AsyncListService, LoadDependency, LoadDetails, LoadResult, SortDescriptor, SortDetails, SortDirection };