const FilerobotUtils = require("@scaleflex/widget-utils");

declare module Filerobot {
  // Utility types
  type OmitKey<T, Key> = Pick<T, Exclude<keyof T, Key>>;

  // These are defined in @scaleflex/widget-utils instead of core so it can be used there without creating import cycles
  export type FilerobotFile<
    TMeta extends IndexedObject<any> = {},
    TBody extends IndexedObject<any> = {}
  > = FilerobotUtils.FilerobotFile<TMeta, TBody>;
  export type Store = FilerobotUtils.Store;
  export type InternalMetadata = FilerobotUtils.InternalMetadata;

  interface IndexedObject<T> {
    [key: string]: T;
    [key: number]: T;
  }

  interface UploadedFilerobotFile<TMeta, TBody>
    extends FilerobotFile<TMeta, TBody> {
    uploadURL: string;
  }

  interface FailedFilerobotFile<TMeta, TBody>
    extends FilerobotFile<TMeta, TBody> {
    error: string;
  }

  // Replace the `meta` property type with one that allows omitting internal metadata; addFile() will add that
  type FilerobotFileWithoutMeta<TMeta, TBody> = OmitKey<
    FilerobotFile<TMeta, TBody>,
    "meta"
  >;
  interface AddFileOptions<
    TMeta = IndexedObject<any>,
    TBody = IndexedObject<any>
  > extends Partial<FilerobotFileWithoutMeta<TMeta, TBody>> {
    // `.data` is the only required property here.
    data: Blob | File;
    meta?: Partial<InternalMetadata> & TMeta;
  }

  interface PluginOptions {
    id?: string;
  }
  interface DefaultPluginOptions extends PluginOptions {
    [prop: string]: any;
  }

  type PluginTarget = string | Element | typeof Plugin;

  class Plugin<TOptions extends PluginOptions = DefaultPluginOptions> {
    id: string;
    filerobot: Filerobot;
    type: string;
    constructor(filerobot: Filerobot, opts?: TOptions);
    setOptions(update: Partial<TOptions>): void;
    getPluginState(): object;
    setPluginState(update: IndexedObject<any>): object;
    update(state?: object): void;
    mount(target: PluginTarget, plugin: typeof Plugin): void;
    render(state: object): void;
    addTarget<TPlugin extends Plugin>(plugin: TPlugin): void;
    unmount(): void;
    install(): void;
    uninstall(): void;
  }

  type LocaleStrings<TNames extends string> = {
    [K in TNames]?: string | { [n: number]: string };
  };
  interface Locale<TNames extends string = string> {
    strings: LocaleStrings<TNames>;
    pluralize?: (n: number) => number;
  }

  interface Restrictions {
    maxFileSize?: number | null;
    maxNumberOfFiles?: number | null;
    minNumberOfFiles?: number | null;
    allowedFileTypes?: string[] | null;
    maxItemsSizeForCompression: number | null;
  }

  interface FilerobotOptions<TMeta extends IndexedObject<any> = {}> {
    container: string;
    securityTemplateId?: string;
    sassKey?: string;
    dev?: boolean;
    userInfo?: {
      email: string;
      name: string;
      photo_uri: string;
      uuid: string;
    };
    autoProceed?: boolean;
    allowMultipleUploads?: boolean;
    debug?: boolean;
    restrictions?: Restrictions;
    meta?: TMeta;
    onBeforeFileAdded?: (
      currentFile: FilerobotFile<TMeta>,
      files: { [key: string]: FilerobotFile<TMeta> }
    ) => FilerobotFile<TMeta> | boolean | undefined;
    onBeforeUpload?: (files: {
      [key: string]: FilerobotFile<TMeta>;
    }) => { [key: string]: FilerobotFile<TMeta> } | boolean;
    locale?: Locale;
    store?: Store;
    userPermissions?: string[];
    userFoldersScope?: string[];
    apiEndpoint?: string;
    skipApiEndpointToken?: boolean;
    adminApiEndpoint?: string;
    shareApiEndpoint?: string;
  }

  interface UploadResult<
    TMeta extends IndexedObject<any> = {},
    TBody extends IndexedObject<any> = {}
  > {
    successful: UploadedFilerobotFile<TMeta, TBody>[];
    failed: FailedFilerobotFile<TMeta, TBody>[];
  }

  interface State<
    TMeta extends IndexedObject<any> = {},
    TBody extends IndexedObject<any> = {}
  > extends IndexedObject<any> {
    capabilities?: { resumableUploads?: boolean };
    currentUploads: {};
    error?: string;
    files: {
      [key: string]:
        | UploadedFilerobotFile<TMeta, TBody>
        | FailedFilerobotFile<TMeta, TBody>;
    };
    info?: {
      isHidden: boolean;
      type: string;
      message: string;
      details: string;
    };
    plugins?: IndexedObject<any>;
    totalProgress: number;
  }

  type LogLevel = "info" | "warning" | "error";

  /** Enable the old, untyped `filerobot.use()` signature. */
  type LooseTypes = "loose";
  /** Disable the old, untyped `filerobot.use()` signature. */
  type StrictTypes = "strict";
  type TypeChecking = LooseTypes | StrictTypes;

  // This hack accepts _any_ string for `Event`, but also tricks VSCode and friends into providing autocompletions
  // for the names listed. https://github.com/microsoft/TypeScript/issues/29729#issuecomment-505826972
  type LiteralUnion<T extends U, U = string> = T | (U & {});
  type Event = LiteralUnion<
    | "file-added"
    | "file-removed"
    | "upload"
    | "upload-progress"
    | "upload-success"
    | "complete"
    | "error"
    | "upload-error"
    | "upload-retry"
    | "info-visible"
    | "info-hidden"
    | "cancel-uploads"
    | "restriction-failed"
    | "reset-progress"
  >;

  type UploadHandler = (fileIDs: string[]) => Promise<void>;

  class Filerobot<TUseStrictTypes extends TypeChecking = TypeChecking> {
    constructor(opts?: FilerobotOptions);
    on<TMeta extends IndexedObject<any> = {}>(
      event: "upload-success",
      callback: (
        file: FilerobotFile<TMeta>,
        body: any,
        uploadURL: string
      ) => void
    ): this;
    on<TMeta extends IndexedObject<any> = {}>(
      event: "complete",
      callback: (result: UploadResult<TMeta>) => void
    ): this;
    on(event: Event, callback: (...args: any[]) => void): this;
    off(event: Event, callback: (...args: any[]) => void): this;
    /**
     * For use by plugins only.
     */
    emit(event: Event, ...args: any[]): void;
    updateAll(state: object): void;
    setOptions(update: Partial<FilerobotOptions>): void;
    setState(patch: object): void;
    getState<TMeta extends IndexedObject<any> = {}>(): State<TMeta>;
    readonly state: State;
    addPreProcessor(fn: UploadHandler): void;
    removePreProcessor(fn: UploadHandler): void;
    addPostProcessor(fn: UploadHandler): void;
    removePostProcessor(fn: UploadHandler): void;
    addFilerobot(fn: UploadHandler): void;
    removeFilerobot(fn: UploadHandler): void;
    setMeta<TMeta extends IndexedObject<any> = {}>(data: TMeta): void;
    setFileMeta<TMeta extends IndexedObject<any> = {}>(
      fileID: string,
      data: TMeta
    ): void;
    getFile<
      TMeta extends IndexedObject<any> = {},
      TBody extends IndexedObject<any> = {}
    >(fileID: string): FilerobotFile<TMeta, TBody>;
    getFiles<
      TMeta extends IndexedObject<any> = {},
      TBody extends IndexedObject<any> = {}
    >(): Array<FilerobotFile<TMeta, TBody>>;
    addFile<TMeta extends IndexedObject<any> = {}>(
      file: AddFileOptions<TMeta>
    ): void;
    removeFile(fileID: string): void;
    pauseResume(fileID: string): void;
    cancelUploads(): void;
    retryUpload<TMeta extends IndexedObject<any> = {}>(
      fileID: string
    ): Promise<UploadResult<TMeta>>;
    pauseAll(): void;
    resumeAll(): void;
    retryAll<TMeta extends IndexedObject<any> = {}>(): Promise<
      UploadResult<TMeta>
    >;
    cancelAll(): void;
    getId(): string;
    /**
     * Add a plugin to this Filerobot instance.
     */
    use<TOptions, TInstance extends Plugin<TOptions>>(
      pluginClass: new (filerobot: this, opts: TOptions) => TInstance,
      opts?: TOptions
    ): this;
    /**
     * Fallback `.use()` overload with unchecked plugin options.
     *
     * This does not validate that the options you pass in are correct.
     * We recommend disabling this overload by using the `Filerobot<Filerobot.StrictTypes>` type, instead of the plain `Filerobot` type, to enforce strict typechecking.
     * This overload will be removed in Filerobot 2.0.
     */
    use(
      pluginClass: TUseStrictTypes extends StrictTypes
        ? never
        : new (filerobot: this, opts: any) => Plugin<any>,
      opts?: object
    ): this;
    getPlugin(name: string): Plugin;
    iteratePlugins(callback: (plugin: Plugin) => void): void;
    removePlugin(instance: Plugin): void;
    close(): void;
    info(
      message: string | { message: string; details: string },
      type?: LogLevel,
      duration?: number
    ): void;
    hideInfo(): void;
    log(msg: string, type?: LogLevel): void;
    /**
     * Obsolete: do not use. This method does nothing and will be removed in a future release.
     */
    run(): this;
    restore<TMeta extends IndexedObject<any> = {}>(
      uploadID: string
    ): Promise<UploadResult<TMeta>>;
    addResultData(uploadID: string, data: object): void;
    upload<TMeta extends IndexedObject<any> = {}>(): Promise<
      UploadResult<TMeta>
    >;
  }
}

/**
 * Create a filerobot instance.
 *
 * By default, Filerobot's `.use(Plugin, options)` method uses loose type checking.
 * In Filerobot 2.0, the `.use()` method will get a stricter type signature. You can enable strict type checking of plugin classes and their options today by using:
 * ```ts
 * const filerobot = Filerobot<Filerobot.StrictTypes>()
 * ```
 * Make sure to also declare any variables and class properties with the `StrictTypes` parameter:
 * ```ts
 * private filerobot: Filerobot<Filerobot.StrictTypes>;
 * ```
 */
declare function Filerobot<
  TUseStrictTypes extends Filerobot.TypeChecking = Filerobot.TypeChecking
>(opts?: Filerobot.FilerobotOptions): Filerobot.Filerobot<TUseStrictTypes>;

export = Filerobot;