/* eslint-disable @typescript-eslint/no-explicit-any */
/// <reference types="immutable/dist/immutable" />
/// <reference types="react" />

/**
 * Type declarations for package `@orange-marmalade/paginate-this`,
 * base type signatures
 */
declare module '@orange-marmalade/paginate-this' {
    // @ts-check: This path is generated at build time and conflicts otherwise
    // import { ReactElementTypeInferred } from '../dist/src/typings/global' TODO:current typescript doesn't allow importing from path
    // @ts-check: This path is generated at build time and conflicts otherwise
    // import { RecordProps, FlipProps, PaginateProps } from '../dist/src/typings/decorators' TODO: current typescript doesn't allow importing from path

    import {
        Store,
        Reducer,
        Action,
        AnyAction,
        ActionCreator,
        ActionCreatorsMapObject
    } from 'redux'

    // type utilities
    // --------------
    /**
     * Infers component's props witch omit common props
     * and return its signature type
     */
    declare type ReactElementTypeInferred<
        C extends React.ElementType,
        CommonProps = {}
    > = C extends React.ElementType<infer P>
        ? React.ComponentType<Omit<P, keyof CommonProps>>
        : React.ComponentType<any>

    declare type MapObjImmutable<K = string | symbol> = Immutable.Map<K, any>

    // InitialSettings
    export interface InitPageSettings {
        preloaded: boolean
        initialized: boolean
        page: number
        pageSize: number
        totalCount: number
        sort: string
        sortReverse: boolean
        isLoading: boolean
        stale: boolean
        results: Record<string | number | symbol, any>[]
        updating: Array<number | string>
        massUpdating: Array<number | string>
        removing: Array<number | string>
        requestId: number | string | null
        loadError: any
        filters: { [key: string]: any }
    }

    /**
     * Like ConfigPageParams typing, but these are translate to work internally
     */
    export interface PageParams {
        pageParam: string // as page in ConfigPageParams
        pageSizeParam: string // as perPage in ConfigPageParams
        sortParam: string // as sort in ConfigPageParams
        sortOrderParam: string // as sortOrder in ConfigPageParams
        useBooleanOrdering: boolean // // as sortReverse in ConfigPageParams
        totalCountProp: string // as totalCount in ConfigPageParams
        resultsProp: string // as results in ConfigPageParams
        idProp: string // as id in ConfigPageParams
    }

    /**
     * Type signature for paginate's global configuration parameters
     */
    export interface ConfigPageParams {
        page?: string
        perPage?: string
        sort?: string
        sortOrder?: string
        sortReverse?: boolean
        totalCount?: string
        results?: string
        id?: string
    }

    /**
     * Configuration type when it's created a paginator
     */
    export type PaginatorConfig = {
        listId: string
        fetch: (...args: any[]) => any
        cache?: boolean
        sticky?: boolean
        initialSettings?: Partial<InitPageSettings>
        pageParams?: Partial<PageParams>
        locator?: (S: any) => any
        augmentWith?: ActionCreatorsMapObject<any>
    }

    /**
     * Settings which the paginate works with them at payload internally
     */
    export interface PaginatorSettings extends InitPageSettings {
        results: Immutable.List<any>
        updating: Immutable.Set<any>
        massUpdating: Immutable.Set<any>
        removing: Immutable.Set<any>
        filters: Immutable.Map<string, any>
    }

    export interface ComposablesConfig {
        listId: string
    }

    export interface AnyComposablesConfig extends ComposablesConfig {
        [extraConf: string]: any
    }

    export interface PageInfo {
        query: {
            [anyFilter: string]: any
        }
    }

    export type FetchActionCreator<A> = {
        (pageInfo: PageInfo, config: any): A
    }

    export type Paginator = MapObjImmutable<keyof PaginatorSettings>

    export type PropsWithPaginator<P = { [extraProps: string]: any }> = P & {
        paginator: Paginator
    }

    // pagination's composed action creators
    export interface PageActionCreators<A extends Action = AnyAction> {
        expire: ActionCreator<A>
        updatingItem: ActionCreator<A>
        updateItem: ActionCreator<A>
        updatingItems: ActionCreator<A>
        updateItems: ActionCreator<A>
        updateComplete: ActionCreator<A>
        updateFailed: ActionCreator<A>
        massUpdateComplete: ActionCreator<A>
        massUpdateFailed: ActionCreator<A>
        resetItem: ActionCreator<A>
        updatingAll: ActionCreator<A>
        updateAll: ActionCreator<A>
        resetResults: ActionCreator<A>
        removingItem: ActionCreator<A>
        removeItem: ActionCreator<A>
        // Async
        updateAsync: ActionCreator<(...args: any[]) => void | Promise<any>>
        updateItemsAsync: ActionCreator<(...args: any[]) => void | Promise<any>>
        removeAsync: ActionCreator<(...args: any[]) => void | Promise<any>>
        reload: ActionCreator<(...args: any[]) => void | Promise<any>>
        // Fetch actions
        initialize: ActionCreator<A>
        reset: ActionCreator<A>
        next: ActionCreator<A>
        prev: ActionCreator<A>
        goTo: ActionCreator<A>
        setPageSize: ActionCreator<A>
        toggleFilterItem: ActionCreator<A>
        setFilter: ActionCreator<A>
        setFilters: ActionCreator<A>
        resetFilters: ActionCreator<A>
        sort: ActionCreator<A>
    }

    export type WithPageActions<T> = T & {
        pageActions: PageActionCreators<AnyAction>
    }

    /**
     * type definition for decorators components
     */
    // selected props for paginate and list
    export type RecordProps = {
        record: Record<string | number | symbol, any>
        updating: boolean
        removing: boolean
    }

    export type FlipProps = {
        hasPreviousPage: boolean
        hasNextPage: boolean
    }

    export type PaginateProps = {
        currentPage: number
        totalPages: number
    } & FlipProps

    /* declare interface Decorate<
        T extends React.ComponentType<any>,
        F = (
            props: T extends React.ComponentType<infer P>
                ? PropsWithPaginator<P>
                : PropsWithPaginator
        ) => Record<string | symbol, any>
    > {
        (Component: T, decorator: F): T extends React.ComponentType<infer P>
            ? React.ExoticComponent<WithPageActions<P>>
            : React.ExoticComponent<WithPageActions<any>>
    } */

    /**
     * Pagination's Store
     */
    export interface PaginationStore<S = any, A extends AnyAction = AnyAction> extends Store<S, A> {
        decorate(...args: any[]): any
        [extraApi: string]: any
    }

    declare interface Decorators<T = React.ComponentType<any>> {
        flip<C extends T = T>(Component: C): ReactElementTypeInferred<C, WithPageActions<FlipProps>>
        paginate<C extends T = T>(
            Component: C
        ): ReactElementTypeInferred<C, WithPageActions<PaginateProps>>
        stretch<C extends T = T>(Component: C): ReactElementTypeInferred<C, WithPageActions<{}>>
        sort<C extends T = T>(Component: C): ReactElementTypeInferred<C, WithPageActions<{}>>
        tabulate<C extends T = T>(Component: C): ReactElementTypeInferred<C, WithPageActions<{}>>
        tabulateLean<C extends T = T>(
            Component: C
        ): ReactElementTypeInferred<C, WithPageActions<{}>>
        paginateThis<C extends T = T>(
            Component: C
        ): ReactElementTypeInferred<C, WithPageActions<{}>>
        withRecordProps<C extends T = T>(
            Component: C
        ): ReactElementTypeInferred<C, WithPageActions<RecordProps>>
        withListId<C extends T = T>(Component: C): ReactElementTypeInferred<C, WithPageActions<{}>>
        decorate<
            C extends T = T,
            F = (
                props: C extends React.ComponentType<infer P>
                    ? PropsWithPaginator<P>
                    : PropsWithPaginator
            ) => Record<string | symbol, any>
        >(
            Component: C,
            decorator: F
        ): ReactElementTypeInferred<C, ReturnType<F> & { listActions: any }>
    }
    export const decorators: Decorators

    export function configurePageParams(config: ConfigPageParams): void
    export function composables<C extends ComposablesConfig = AnyComposablesConfig>(
        config: C
    ): PageActionCreators<AnyAction>
    export function actionFactory(
        listId: string
    ): {
        [k: string]: (...args: any[]) => any
    }
    export function expireAll(): Action<string>
    export function createPaginator(config: PaginatorConfig): Reducer<PaginatorSettings>

    // hook functions to manage paginate state
    export function getPaginator<S = any>(listId: string, state: S): Paginator
    export function getItem<S = any, I = string | number>(
        state: S,
        listId: string,
        itemId: I
    ): Immutable.Collection<any, any>
    export function isUpdating<S = any, I = string | number>(
        state: S,
        listId: string,
        itemId: I
    ): boolean
    export function isRemoving<S = any, I = string | number>(
        state: S,
        listId: string,
        itemId: I
    ): boolean
    export function currentQuery<S = any>(state: S, listId: string): PageInfo

    declare interface Middleware {
        spill(...args: any[]): any
        jelly(...args: any[]): any
    }
    export const middleware = Middleware
    export function debug(shouldDebug: boolean): void

    export function initializeStore<S = Store | undefined>(store: S): void

    export function pageData(
        currentPage: number,
        totalPages: number,
        maxPages?: number
    ): {
        firstPage: {
            page: number
            current: boolean
        }
        hasLeftSeparator: boolean
        middlePages: { page: number; current: boolean }[]
        hasRightSeparator: boolean
        lastPage: {
            page: number
            current: boolean
        }
    }

    // Premade components for pagination
    export type NextProps = {
        pageActions: {
            next: PageActionCreators['next']
        }
        hasNextPage: boolean
    }
    export const Next: ReturnType<Decorators<React.FunctionComponent<NextProps>>['flip']>
    export type PrevProps = {
        pageActions: {
            prev: PageActionCreators['prev']
        }
        hasPreviousPage: boolean
    }
    export const Prev: ReturnType<Decorators<React.FunctionComponent<PrevProps>>['flip']>
}

/**
 * Type declaration for package `@orange-marmalade/paginate-this/dist/pageInfoTranslator`
 */
declare module '@orange-marmalade/paginate-this/dist/pageInfoTranslator' {
    export function responseProps<C = number, P = {}>(): [C, P]
    export function recordProps<I = { identifier: string }>(): I
}

declare module '@orange-marmalade/paginate-this/dist/lib/stateManagement' {
    import { PaginatorConfig, PageParams } from '@orange-marmalade/paginate-this'

    declare type Config = {
        params: PageParams
    } & Pick<PaginatorConfig, Exclude<keyof PaginatorConfig, 'augmentWith' | 'pageParams'>>

    export function listConfig(listId: string): Config
}