// # Example
// ```javascript
// Dos(canvas).ready((fs, main) => {
//     fs.extract("digger.zip").then(() => {
//         main(["-c", "DIGGER.COM"])
//     });
// });
// ```
// Dos function is entry point that provides emulation layer.
// As emulation layer js-dos uses [DosBox ported to emscripten](https://github.com/dreamlayers/em-dosbox/#compiling).

// # Dos

import openCache from "./js-dos-cache";
import { DosCommandInterface } from "./js-dos-ci";
import { DosFS } from "./js-dos-fs";
import { Host } from "./js-dos-host";
import { DosModule } from "./js-dos-module";
import { DosOptions } from "./js-dos-options";

import Gamepad from "./controller/gamepad";
import Move from "./controller/move";
import Qwerty from "./controller/qwerty";

// When you call `Dos(canvas, options)` js-dos behind the scene will download
// dosbox and prepare it to start. This function will return `Promise<DosReadyPromise>`
// that will be resolved when dosbox is ready. In case of error promise
// will be rejected.
//
// * `canvas`: HTMLCanvasElement - this canvas element is used as window for dosbox
// * `options`: [DosOptions](https://js-dos.com/6.22/docs/api/generate.html?page=js-dos-options) -
// optional configuration object
export type DosFactory = (canvas: HTMLCanvasElement, options?: DosOptions) => DosReadyPromise;
const Dos: DosFactory = (canvas: HTMLCanvasElement, options?: DosOptions) => {
    const promise = new Promise<DosRuntime>((resolve, reject) => {
        const module = new DosModule(canvas, resolve);

        if (!options) {
            options = {};
        }

        if (!options.onerror) {
            options.onerror = (message: string) => {
                /* tslint:disable:no-console */
                console.error(message);
                /* tslint:enable:no-console */
            };
        }

        Object.assign(module, options);

        // ### Error handling
        // Error handling should support both ways:
        //
        // * Through rejecting of promise
        // * Fire onerror function of DosOptions object

        const onerror = module.onerror;
        module.onerror = (message: string) => {
            reject(message);

            const fn = () => {
                if (onerror) {
                    onerror(message);
                    module.onerror = onerror;
                } else {
                    module.onerror = module.error;
                }
            };

            setTimeout(fn, 1);
        };

        module.resolve();
        if (!module.isValid) {
            return;
        }

        openCache(module, (cache) => {
            // See [Host](https://js-dos.com/6.22/docs/api/generate.html?page=js-dos-host)
            // to understand resolving of emulation layer (dosbox).
            Host.resolveDosBox(module.wdosboxUrl as string, cache, module);
        });

    });

// ### DosReadyPromise
// Is a Promise object with additional method ready.
// Method `ready` is just a wrapper over `then` method that
// split resolved object into meaningful parts.

    const dosReadyPromise = (promise as unknown) as DosReadyPromise;
    dosReadyPromise.ready = (onready) => {
        dosReadyPromise.then((runtime: DosRuntime) => {
            onready(runtime.fs, runtime.main);
        });
        return dosReadyPromise;
    };
    return dosReadyPromise;
};

export default Dos;

export type DosMainFn = (args?: string[]) => Promise<DosCommandInterface>;

// Plain promise will be resolved with `DosRuntime` interface, that
// includes:
//
// * `fs`: [DosFS](https://js-dos.com/6.22/docs/api/generate.html?page=js-dos-fs) -
// API for working with dosbox filesystem
// * `main`: DosMainFn - a function that you should call to actuall start
// dosbox. It's like a main function in C++, or shell command line. This function
// will return Promise of [DosCommandInterface](https://js-dos.com/6.22/docs/api/generate.html?page=js-dos-ci).
// You can use it to control runned dosbox.
export interface DosRuntime {
    fs: DosFS;
    main: DosMainFn;
}

export interface DosReadyPromise extends Promise<DosRuntime> {
    // `onready` - callback that receive DosRuntime splitted by fields
    ready: (onready: (fs: DosFS, main: DosMainFn) => void) => Promise<DosRuntime>;
}

(window as any).Dos = Dos;
(window as any).DosController = {
    Qwerty,
    Move,
    Gamepad,
};