import * as react from 'react';
import { FC, ReactNode } from 'react';

type RowDataBase = Record<string, unknown>;

/** Definition for a column in the table. */
interface ColumnDefinition<RowData extends RowDataBase> {
  /** The unique identifier for the column. Used as the key in the data. */
  id: keyof RowData;
  /** The text title to display in the header. */
  title: string;
}

interface TabulusOptions {
  /** How to align the table within its parent. */
  align: 'center' | 'left' | 'right';
}

// TODO: Make the generic types work correctly?
/** Props passed to the Tabulus component as well as contexts and hooks. */
interface TabulusProps<RowData extends RowDataBase = RowDataBase> {
  /** Definition array for the table columns. */
  readonly columns: Array<ColumnDefinition<RowData>>;
  /** The data to display in the table. */
  readonly data: Array<RowData>;
  /** Unique ID for the table. */
  readonly id: string;
  /** User options for the table to override defaults. */
  readonly options?: Partial<TabulusOptions>;
  // TODO: Write these props
  /** Callbacks to run when events are triggered. */
  readonly events?: Record<string, unknown>;
}

declare const Tabulus: FC<TabulusProps>;

/** Value of the `TableManager` context that is provided to consumers. */
interface TableManagerValue<RowData extends RowDataBase = RowDataBase>
  extends TabulusProps<RowData> {
  /** Whether the context has been initialised. */
  initialized: boolean;
  /** The rows to display on the table. */
  rows: RowData[];
}

/** Props to be passed in to the Context provider. */
interface TableManagerProviderProps<RowData extends RowDataBase = RowDataBase>
  extends Omit<TabulusProps<RowData>, 'id'> {
  /** Children of the provider that will have access to the context value. */
  readonly children: ReactNode;
  /** The ID of the table this manager belongs to. */
  readonly tableId: string;
}

/**
 * Context for storing and providing table functions and values to the tables below.
 * This is an internal context for use with our standard components.
 *
 * @private
 */
declare const TableManager: react.Context<TableManagerValue<RowDataBase>>;
declare const TableManagerProvider: FC<TableManagerProviderProps>;

/** Value of the `TableManager` context that is provided to consumers. */
interface TabulusContextValue<RowData extends RowDataBase = RowDataBase>
  extends TabulusProps<RowData> {}

/** Props to be passed in to the Context provider. */
interface TabulusContextProviderProps<RowData extends RowDataBase = RowDataBase>
  extends TabulusProps<RowData> {
  /** Children of the provider that will have access to the context value. */
  readonly children: ReactNode;
}

declare const TabulusContext: react.Context<TabulusContextValue<RowDataBase>>;
declare const TabulusContextProvider: FC<TabulusContextProviderProps>;

declare const useTabulus: <RowData extends RowDataBase>({ columns: baseColumns, data: baseData, id, options: userOptions, }: TabulusProps<RowData>) => {
    columns: ColumnDefinition<RowData>[];
    data: RowData[];
    options: TabulusOptions;
    tableId: string;
};

declare const useTabulusContext: () => TabulusContextValue<RowDataBase>;

declare const useTabulusRegistry: () => void;

export { TableManager, TableManagerProvider, Tabulus, TabulusContext, TabulusContextProvider, type TabulusProps, useTabulus, useTabulusContext, useTabulusRegistry };