// Type definitions for flexsearch 0.7
// Project: https://github.com/nextapps-de/flexsearch/
// Definitions by: LOSSES Don <https://github.com/Losses>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

/************************************/
/* Utils                            */
/************************************/
export type Id = number | string;
export type Limit = number;
export type ExportHandler<T> = (id: string | number, value: T) => void;
export type AsyncCallback<T = undefined> = T extends undefined ? () => void : (result: T) => void;
export type UnknownFunction = (...x: unknown[]) => unknown;

export type StoreOption = boolean | string | string[];
export type EnrichStoreOption = true | string | string[];

/************************************/
/* Common Options                   */
/************************************/

/**
 * **Document:**
 * * Presets: https://github.com/nextapps-de/flexsearch#presets
 */
export type Preset = "memory" | "performance" | "match" | "score" | "default";

/**
 * **Document:**
 * * Tokenizer: https://github.com/nextapps-de/flexsearch#tokenizer-prefix-search
 * * Add custom tokenizer: https://github.com/nextapps-de/flexsearch#add-custom-tokenizer
 */
export type Tokenizer =
   | "strict"
   | "forward"
   | "reverse"
   | "full"
   | ((x: string) => string[]);

/**
 * **Document:**
 * * Encoders: https://github.com/nextapps-de/flexsearch#encoders
 */
export type Encoders =
   | false
   | "default"
   | "simple"
   | "balance"
   | "advanced"
   | "extra"
   | ((x: string) => string[]);

/**
 * **Document:**
 * * Contextual search: https://github.com/nextapps-de/flexsearch#contextual
 */
export interface ContextOptions {
   resolution: number;
   depth: false | number;
   bidirectional: boolean;
}

/**
 * **Document:**
 * * Search options: https://github.com/nextapps-de/flexsearch#search-options
 */
export interface SearchOptions {
   query?: string;
   limit?: number;
   offset?: number;
   suggest?: boolean;
}

/**
 * **Document:**
 * * The document descriptor: https://github.com/nextapps-de/flexsearch#the-document-descriptor
 */
export interface Descriptor<T, Store extends StoreOption = false> {
   id: string | number;
   field: string[] | Array<IndexOptions<T, Store>>;
}

/**
 * **Document:**
 * * Context Options: https://github.com/nextapps-de/flexsearch#context-options
 */
export interface ContextOptions {
   resolution: number;
   depth: false | number;
   bidirectional: boolean;
}

/**
 * **Document:**
 * * Charset options: https://github.com/nextapps-de/flexsearch#charset-options
 */
export interface CharsetOptions {
   split: false | string | RegExp;
   rtl: boolean;
   encode: (x: string) => string[];
}

export interface Stemmer {
   [key: string]: string;
}

export interface Matcher {
   [key: string]: string;
}

export type FilterFunction = (x: string) => boolean;
export type FilterArray = string[];

/**
 * **Document:**
 * * Language Options: https://github.com/nextapps-de/flexsearch#language-options
 * * Language: https://github.com/nextapps-de/flexsearch#languages
 */
export interface LanguageOptions {
   stemmer: false | string | Stemmer | UnknownFunction;
   filter: false | string | FilterArray | FilterFunction;
   matcher: false | string | Matcher | UnknownFunction;
}

/**
 * These options will determine how the documents be indexed.
 *
 * **Generic type parameters:**
 *
 * @template T The type of the document.
 * @template Store If store is enabled.
 *
 * **Document:**
 * * Index options: https://github.com/nextapps-de/flexsearch#index-options
 * * Language: https://github.com/nextapps-de/flexsearch#languages
 */
export interface IndexOptions<T, Store extends StoreOption = false> {
   preset?: Preset;
   tokenize?: Tokenizer;
   cache?: boolean | number;
   resolution?: number;
   context?: boolean | IndexOptions<T, Store> | ContextOptions;
   optimize?: boolean;
   boost?: (words: string[], term: string, index: number) => number;

   // Language-specific Options and Encoding
   charset?: CharsetOptions | string;
   language?: LanguageOptions | string;
   encode?: Encoders;
   stemmer?: LanguageOptions['stemmer'];
   filter?: LanguageOptions['filter'];
   matcher?: LanguageOptions['matcher'];
}

/************************************/
/* Index Search                     */
/************************************/

export type IndexSearchResult = Id[];

/**
 * **Document:**
 * * Basic usage and variants: https://github.com/nextapps-de/flexsearch#basic-usage-and-variants
 * * API overview: https://github.com/nextapps-de/flexsearch#api-overview
 * * Usage: https://github.com/nextapps-de/flexsearch#usage
 */

export class Index {
   constructor(x?: Preset | IndexOptions<string>);
   add(id: Id, item: string): this;
   append(id: Id, item: string): this;
   update(id: Id, item: string): this;
   remove(target: Id): this;
   search(query: string, options?: Limit | SearchOptions): IndexSearchResult;
   search(
      query: string,
      limit: number,
      options: SearchOptions
   ): IndexSearchResult;
   search(options: SearchOptions): IndexSearchResult;

   // https://github.com/nextapps-de/flexsearch#check-existence-of-already-indexed-ids
   contain(id: Id): boolean;

   export(handler: ExportHandler<string>): Promise<void>;
   import(id: Id, item: string): Promise<void>;

   // Async Methods
   addAsync(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   appendAsync(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   updateAsync(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   removeAsync(target: Id, callback?: AsyncCallback<this>): Promise<this>;
   searchAsync(
      query: string,
      options?: Limit | SearchOptions,
      callback?: AsyncCallback<IndexSearchResult>
   ): Promise<IndexSearchResult>;
   searchAsync(
      query: string,
      limit: number,
      options?: Limit | SearchOptions
   ): IndexSearchResult;
   searchAsync(options: SearchOptions): Promise<IndexSearchResult>;
}

/**
 * **Document:**
 * * Basic usage and variants: https://github.com/nextapps-de/flexsearch#basic-usage-and-variants
 * * API overview: https://github.com/nextapps-de/flexsearch#api-overview
 * * Worker index: https://github.com/nextapps-de/flexsearch#worker-index
 */
export class Worker {
   constructor(x?: Preset | IndexOptions<string>);

   add(id: Id, item: string, callback?: AsyncCallback<Worker>): Promise<this>;
   append(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   update(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   remove(target: Id, callback?: AsyncCallback<this>): Promise<this>;
   search(
      query: string,
      options?: Limit | SearchOptions,
      callback?: AsyncCallback<IndexSearchResult>
   ): Promise<IndexSearchResult>;
   search(
      query: string,
      limit: number,
      options?: Limit | SearchOptions
   ): IndexSearchResult;
   search(options: SearchOptions): Promise<IndexSearchResult>;

   // Async Methods
   addAsync(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   appendAsync(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   updateAsync(id: Id, item: string, callback?: AsyncCallback<this>): Promise<this>;
   removeAsync(target: Id, callback?: AsyncCallback<this>): Promise<this>;
   searchAsync(
      query: string,
      options?: Limit | SearchOptions,
      callback?: AsyncCallback<IndexSearchResult>
   ): Promise<IndexSearchResult>;
   searchAsync(
      query: string,
      limit: number,
      options?: Limit | SearchOptions
   ): IndexSearchResult;
   searchAsync(options: SearchOptions): Promise<IndexSearchResult>;
}

/************************************/
/* Document Search                  */
/************************************/

/*
* **Document:**
* * Document options: https://github.com/nextapps-de/flexsearch#document-options
*/
export interface DocumentOptions<T, Store extends StoreOption = false> {
   id: string;
   tag?: false | string;
   index: string | string[] | Array<IndexOptions<T, Store> & { field: string }>;
   store?: Store;
}

/*
* **Document:**
* * Index options: https://github.com/nextapps-de/flexsearch#index-options
*/
export interface IndexOptionsForDocumentSearch<
   T,
   Store extends StoreOption = false
   > extends IndexOptions<T, Store> {
   // Additional Options for Document Indexes
   worker?: boolean;
   document?: DocumentOptions<T, Store> | Descriptor<T, Store>;
}

export interface SimpleDocumentSearchResultSetUnit {
   field: string;
   result: Id[];
}

export interface EnrichedDocumentSearchResultSetUnitResultUnit<T> {
   id: Id[];
   doc: T;
}

export interface EnrichedDocumentSearchResultSetUnit<T> {
   field: string;
   result: Array<EnrichedDocumentSearchResultSetUnitResultUnit<T>>;
}

/**
 *  # Document Search Result
 *
 *  To make your result return the full document:
 *  * set `store` to `true` while creating the document;
 *  * set `enrich` to `true` while searching.
 *
 *  If neither of these conditions is met, then the returned result will be a `ISimpleDocumentSearchResult`.
 */
export type DocumentSearchResult<
   T,
   Store extends StoreOption = false,
   Enrich extends boolean = false
   > = [Store, Enrich] extends [EnrichStoreOption, true]
   ? Array<EnrichedDocumentSearchResultSetUnit<T>>
   : SimpleDocumentSearchResultSetUnit[];

/**
 * **Document:**
 * * Document search options: https://github.com/nextapps-de/flexsearch#document-search-options
 */
export interface DocumentSearchOptions<T extends boolean>
   extends SearchOptions {
   index?: string | string[] | SearchOptions[];
   tag?: string | string[];
   enrich?: T;
   bool?: "and" | "or";
}

/**
 * **Document:**
 * * Basic usage and variants: https://github.com/nextapps-de/flexsearch#basic-usage-and-variants
 * * API overview: https://github.com/nextapps-de/flexsearch#api-overview
 * * Document store: https://github.com/nextapps-de/flexsearch#document-store
 */
export class Document<T, Store extends StoreOption = false> {
   constructor(
      options: IndexOptionsForDocumentSearch<T, Store>,
      typeHack?: T
   );
   add(document: T): this;
   add(id: Id, document: T): this;
   append(document: T): this;
   append(id: Id, document: T): this;
   update(document: T): this;
   update(id: Id, document: T): this;
   remove(target: Id | T): this;
   search(query: string, limit?: number): SimpleDocumentSearchResultSetUnit[];

   // https://github.com/nextapps-de/flexsearch#field-search
   search(query: string, options: string[] | Partial<DocumentSearchOptions<boolean>>): SimpleDocumentSearchResultSetUnit[];

   search<Enrich extends boolean = false>(
      query: string,
      limit?: number,
      options?: Partial<DocumentSearchOptions<Enrich>>
   ): DocumentSearchResult<T, Store, Enrich>;
   search(
      options: Partial<DocumentSearchOptions<boolean>>
   ): SimpleDocumentSearchResultSetUnit[];
   export(handler: ExportHandler<T>): Promise<void>;
   import(id: Id, document: T): Promise<void>;

   // Async Methods
   addAsync(id: Id, document: T, callback?: AsyncCallback): Promise<this>;
   appendAsync(id: Id, document: T, callback?: AsyncCallback): Promise<this>;
   updateAsync(id: Id, document: T, callback?: AsyncCallback): Promise<this>;
   removeAsync(target: Id | T, callback?: AsyncCallback): Promise<this>;
   searchAsync<Enrich extends boolean = false>(
      query: string,
      options: string[] | Partial<DocumentSearchOptions<Enrich>>
   ): Promise<DocumentSearchResult<T, Store, Enrich>>;
   searchAsync(
      query: string,
      limit?: number,
   ): Promise<SimpleDocumentSearchResultSetUnit[]>;
   searchAsync(
      query: string,
      limit: number,
      callback: AsyncCallback<SimpleDocumentSearchResultSetUnit[]>
   ): Promise<this>;
   searchAsync<Enrich extends boolean = false>(
      query: string,
      options: Partial<DocumentSearchOptions<Enrich>>,
      callback: AsyncCallback<DocumentSearchResult<T, Store, Enrich>>
   ): Promise<this>;
   searchAsync<Enrich extends boolean = false>(
      options: Partial<DocumentSearchOptions<Enrich>>
   ): Promise<DocumentSearchResult<T, Store, Enrich>>;
   searchAsync<Enrich extends boolean = false>(
      options: Partial<DocumentSearchOptions<Enrich>>,
      callback: AsyncCallback<DocumentSearchResult<T, Store, Enrich>>
   ): Promise<this>;
}

/************************************/
/* Miscellaneous                    */
/************************************/
export function create(options: IndexOptions<string>): Index;
export function registerCharset(name: string, charset: CharsetOptions): void;
export function registerLanguage(
   name: string,
   language: LanguageOptions
): void;