// This file holds the types that don't belong to a specific file.
// Please don't import types from this file directly as its content might change in other versions.

import { AtomEnvironment, DecorationOptions, MarkerLayer, Pane, Point, TextEditor } from '../index';

export interface PixelPosition {
    left: number;
    top: number;
}

/**
 *  This custom subclass of CustomEvent exists to provide the ::abortKeyBinding
 *  method, as well as versions of the ::stopPropagation methods that record the
 *  intent to stop propagation so event bubbling can be properly simulated for
 *  detached elements.
 */
export interface CommandEvent<CurrentTarget extends EventTarget = EventTarget> extends CustomEvent {
    keyBindingAborted: boolean;
    propagationStopped: boolean;

    abortKeyBinding(): void;
    stopPropagation(): CustomEvent;
    stopImmediatePropagation(): CustomEvent;
    currentTarget: CurrentTarget;
}

export interface DecorationPropsChangedEvent {
    /** Object the old parameters the decoration used to have. */
    oldProperties: DecorationOptions;

    /** Object the new parameters the decoration now has */
    newProperties: DecorationOptions;
}

export interface EditorChangedEvent {
    /** A Point representing where the change started. */
    start: Point;

    /** A Point representing the replaced extent. */
    oldExtent: Point;

    /** A Point representing the replacement extent. */
    newExtent: Point;
}

export interface FileSavedEvent {
    /** The path to which the buffer was saved. */
    path: string;
}

export interface FilesystemChangeBasic<
    Action extends 'created' | 'modified' | 'deleted' | 'renamed' = 'created' | 'modified' | 'deleted'
> {
    /** A string describing the filesystem action that occurred. */
    action: Action;

    /** The absolute path to the filesystem entry that was acted upon. */
    path: string;
}

export interface FilesystemChangeRename extends FilesystemChangeBasic<'renamed'> {
    /**
     *  For rename events, a string containing the filesystem entry's former
     *  absolute path.
     */
    oldPath: string;
}

export type FilesystemChange = FilesystemChangeBasic | FilesystemChangeRename;

export type FilesystemChangeEvent = FilesystemChange[];

export interface HandleableErrorEvent {
    /** The error object. */
    error: Error;

    /**
     *  Call this function to indicate you have handled the error.
     *  The error will not be thrown if this function is called.
     */
    handle(): void;
}

export interface TextEditorObservedEvent {
    textEditor: TextEditor;
    pane: Pane;
    index: number;
}

export interface BuildEnvironmentOptions {
    /**
     *  An object responsible for Atom's interaction with the browser process and host OS.
     *  Use buildDefaultApplicationDelegate for a default instance.
     */
    applicationDelegate?: object | undefined;

    /** A window global. */
    window?: Window | undefined;

    /** A document global. */
    document?: Document | undefined;

    /** A path to the configuration directory (usually ~/.atom). */
    configDirPath?: string | undefined;

    /**
     *  A boolean indicating whether the Atom environment should save or load state
     *  from the file system. You probably want this to be false.
     */
    enablePersistence?: boolean | undefined;
}

export interface HistoryTransactionOptions {
    /** When provided, skip taking snapshot for other selections markerLayers except given one. */
    selectionsMarkerLayer?: MarkerLayer | undefined;
}

export interface HistoryTraversalOptions {
    /** Restore snapshot of selections marker layer to given selectionsMarkerLayer. */
    selectionsMarkerLayer?: MarkerLayer | undefined;
}

export interface ReadonlyEditOptions {
    /** Whether the readonly protections on the text editor should be ignored. */
    bypassReadOnly?: boolean | undefined;
}

export interface TextEditOptions {
    /** If true, all line endings will be normalized to match the editor's current mode. */
    normalizeLineEndings?: boolean | undefined;

    /**
     * If skip, skips the undo stack for this operation.
     * @deprecated Call groupLastChanges() on the TextBuffer afterward instead.
     */
    undo?: 'skip' | undefined;
}

export interface TextInsertionOptions extends TextEditOptions {
    /** If true, selects the newly added text. */
    select?: boolean | undefined;

    /** If true, indents all inserted text appropriately. */
    autoIndent?: boolean | undefined;

    /** If true, indent newline appropriately. */
    autoIndentNewline?: boolean | undefined;

    /**
     *  If true, decreases indent level appropriately (for example, when a closing
     *  bracket is inserted).
     */
    autoDecreaseIndent?: boolean | undefined;

    /**
     *  By default, when pasting multiple lines, Atom attempts to preserve the relative
     *  indent level between the first line and trailing lines, even if the indent
     *  level of the first line has changed from the copied text. If this option is
     *  true, this behavior is suppressed.
     */
    preserveTrailingLineIndentation?: boolean | undefined;
}

/** An interface which all custom test runners should implement. */
export type TestRunner = (params: TestRunnerParams) => Promise<number>;

export interface CancellablePromise<T> extends Promise<T> {
    cancel(): void;
}

export type FileEncoding =
    | 'iso88596' // Arabic (ISO 8859-6)
    | 'windows1256' // Arabic (Windows 1256)
    | 'iso88594' // Baltic (ISO 8859-4)
    | 'windows1257' // Baltic (Windows 1257)
    | 'iso885914' // Celtic (ISO 8859-14)
    | 'iso88592' // Central European (ISO 8859-2)
    | 'windows1250' // Central European (Windows 1250)
    | 'gb18030' // Chinese (GB18030)
    | 'gbk' // Chinese (GBK)
    | 'cp950' // Traditional Chinese (Big5)
    | 'big5hkscs' // Traditional Chinese (Big5-HKSCS)
    | 'cp866' // Cyrillic (CP 866)
    | 'iso88595' // Cyrillic (ISO 8859-5)
    | 'koi8r' // Cyrillic (KOI8-R)
    | 'koi8u' // Cyrillic (KOI8-U)
    | 'windows1251' // Cyrillic (Windows 1251)
    | 'cp437' // DOS (CP 437)
    | 'cp850' // DOS (CP 850)
    | 'iso885913' // Estonian (ISO 8859-13)
    | 'iso88597' // Greek (ISO 8859-7)
    | 'windows1253' // Greek (Windows 1253)
    | 'iso88598' // Hebrew (ISO 8859-8)
    | 'windows1255' // Hebrew (Windows 1255)
    | 'cp932' // Japanese (CP 932)
    | 'eucjp' // Japanese (EUC-JP)
    | 'shiftjis' // Japanese (Shift JIS)
    | 'euckr' // Korean (EUC-KR)
    | 'iso885910' // Nordic (ISO 8859-10)
    | 'iso885916' // Romanian (ISO 8859-16)
    | 'iso88599' // Turkish (ISO 8859-9)
    | 'windows1254' // Turkish (Windows 1254)
    | 'utf8' // Unicode (UTF-8)
    | 'utf16le' // Unicode (UTF-16 LE)
    | 'utf16be' // Unicode (UTF-16 BE)
    | 'windows1258' // Vietnamese (Windows 1258)
    | 'iso88591' // Western (ISO 8859-1)
    | 'iso88593' // Western (ISO 8859-3)
    | 'iso885915' // Western (ISO 8859-15)
    | 'macroman' // Western (Mac Roman)
    | 'windows1252'; // Western (Windows 1252)

export interface Invisibles {
    /**
     *  Character used to render newline characters (\n) when the `Show Invisibles`
     *  setting is enabled.
     */
    eol?: boolean | string | undefined;

    /**
     *  Character used to render leading and trailing space characters when the
     *  `Show Invisibles` setting is enabled.
     */
    space?: boolean | string | undefined;

    /**
     *  Character used to render hard tab characters (\t) when the `Show Invisibles`
     *  setting is enabled.
     */
    tab?: boolean | string | undefined;

    /**
     *  Character used to render carriage return characters (for Microsoft-style line
     *  endings) when the `Show Invisibles` setting is enabled.
     */
    cr?: boolean | string | undefined;
}

export interface TestRunnerParams {
    /** An array of paths to tests to run. Could be paths to files or directories. */
    testPaths: string[];

    /**
     *  A function that can be called to construct an instance of the atom global.
     *  No atom global will be explicitly assigned, but you can assign one in your
     *  runner if desired.
     */
    buildAtomEnvironment(options: BuildEnvironmentOptions): AtomEnvironment;

    /**
     *  A function that builds a default instance of the application delegate, suitable
     *  to be passed as the applicationDelegate parameter to buildAtomEnvironment.
     */
    buildDefaultApplicationDelegate(): object;

    /** An optional path to a log file to which test output should be logged. */
    logFile: string;

    /**
     *  A boolean indicating whether or not the tests are being run from the command
     *  line via atom --test.
     */
    headless: boolean;
}