/**
 * Bootstrap procedure for Gibble Lisp
 *
 *  Copyright (C) 2017 Mike Gerwitz
 *
 *  This file is part of Gibble.
 *
 *  Gibble is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Affero General Public License as
 *  published by the Free Software Foundation, either version 3 of the
 *  License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU Affero General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Ideally, the user should be able to bootstrap Gibble Lisp with nothing
 * more than what they already have installed on their computer, in the
 * environment that Gibble was designed to run in---the web
 * browser.  Node.js was used during official development, but that is a
 * large system that should not be a necessary dependency---it should be
 * needed only for convenience.
 *
 * To run this process on a local development environment using Node.js, see
 * `../bootstrap.js'.  To run in your web browser, see `../bootstrap.html'.
 */

'use strict';


/**
 * Bootstrap procedure for Gibble Lisp
 *
 * This abstracts the bootstrap process in such a way that it can be run in
 * any JavaScript environment.  Notably, we need to support not only Node.js
 * (which is convenient for development and automation), but also a web
 * browser, which allows users to bootstrap using only their runtime
 * environment and no additional tools.
 *
 * Prebirth and every compiler thereafter are designed to be able to be run
 * from the command line, accepting source code on standard input.  Such a
 * concept does not exist in a browser environment, and therefore cannot
 * exist here; there is an awkward abstraction to work around that.
 */
class Bootstrap
{
    /**
     * Initialize bootstrap process
     *
     * The file loader `getf' must accept a path to a file to load and
     * return a Promise representing the contents of that file.  The logger
     * function `logf' must accept a string message and, as an optional
     * argument an Error.  `prebirth' should be `Prebirth' from
     * `prebirth.js'.
     *
     * @param {function(string):Promise} getf    file loader
     * @param {function(string,Error=}} logf     logger
     * @param {Prebirth}                prebirth Prebirth
     */
    constructor( getf, logf, prebirth )
    {
        this._getf     = getf;
        this._logf     = logf;
        this._prebirth = prebirth;
    }


    /**
     * Perform bootstrapping process
     *
     * This compiles each of the phases of Gibble beginning with
     * Prebirth.  This will evolve in complexity as we continue to move
     * forward.  Each step of the process is self-verifying.
     *
     * There is currently no final result from this method other than
     * log output and an indication of success or failure; that'll change as
     * we get further along and will produce the final compiler.
     *
     * @return {undefined} nothing yet.
     */
    bootstrap()
    {
        this._strout( 'header' );

        this._loadPaths( [
            [ "birth.scm",      "Birth" ],
            [ "libprebirth.js", "libprebirth" ],
        ] )
            .then( ( [ scm, lib ] ) =>
            {
                this._strout( 'prebirthDesc' );

                return [
                    this._prebirth.compile( scm, lib ),
                    scm,
                    lib
                ];
            } )
            .then( ( [ birthjs, scm, lib ] ) =>
            {
                this._strout( 'prebirthComplete', birthjs.length );
                this._strout( 'birthCompiled' );
                this._strout( 'birthSelfCompiling' );

                const birth = new Function(
                    'let __fsinit = this.__fsinit;' +
                    'let birthout = "";\n' +
                    'const console = { log: str => birthout = str + "\\n" };\n' +
                    birthjs +
                    "return birthout;"
                );

                const birthout = birth.call( {
                    __fsinit: {  // stub fs
                        "/dev/stdin":     scm,
                        "libprebirth.js": lib,
                    },
                } );

                if ( birthout === '' ) {
                   throw Error( "Self-compilation yielded no output" );
                }

                this._strout( 'birthVerify' );

                if ( birthout !== birthjs ) {
                    this._strout( 'birthVerifyFail' );

                    throw Error(
                        "Birth self-compilation output does not match Prebirth!"
                    );
                }

                this._strout( 'birthVerifyOk' );

                return birthout;
            } )
            .catch( e => this._error( e ) )
            .then( status =>
                this._log( "=> " + this._doneMessage( status ) )
            );
    }


    /**
     * Produce a promise for the file contents of each of `path'
     *
     * See also `#_loadPath'.
     *
     * @param {Array<string>} paths file paths
     *
     * @return {Promise} resolved with file contents or failure
     */
    _loadPaths( paths )
    {
        return Promise.all(
            paths.map( ( [ path, desc ] ) =>
                this._loadPath( path, desc )
            )
        );
    }


    /**
     * Produce a promise for the file contents of `path'
     *
     * This action is logged with the description `desc' and the length of
     * the result.
     *
     * This uses the loader function provided via the constructor, which
     * must return a Promise.
     *
     * @param {string} path file path
     * @param {string} desc file description for logging
     *
     * @return {Promise} promise of string file contents
     */
    _loadPath( path, desc )
    {
        this._strout( 'loadingf', desc, path );

        return this._getf( path )
            .then( data =>
            {
                this._strout( 'loadedf', path, data.length );

                return data;
            } );
    }


    /**
     * Promise to log a string identified by `id'
     *
     * All given arguments in `args' will be passed to the function handling
     * that identifier.
     *
     * @param {string} id   string identifier (see `_strmap')
     * @param {Array}  args string arguments
     *
     * @return {Promise}
     */
    _strout( id, ...args )
    {
        return Promise.resolve(
            this._log( this._str.apply( this, arguments ) )
        );
    }


    /**
     * Generate a string identified by `id'
     *
     * All given arguments in `args' will be passed to the function handling
     * that identifier.
     *
     * @param {string} id   string identifier (see `_strmap')
     * @param {Array}  args string arguments
     *
     * @return {string} generated string
     */
    _str( id, ...args )
    {
        const strf = Bootstrap._strmap[ id ];

        if ( strf === undefined ) {
           throw Error( `Unknown strmap '${id}'` );
        }

        return strf.apply( null, args );
    }


    /**
     * Log string using logger function
     *
     * @param {string} str string to log
     *
     * @return {undefined}
     */
    _log( str )
    {
        this._logf( str );
    }


    /**
     * Log error using logger function
     *
     * `e.message' will be used as the log string, with `e' itself being
     * passed as the second argument to the logger function.
     *
     * @param {Error} e error
     *
     * @return {boolean} false
     */
    _error( e )
    {
        const str = this._str( 'fatal', e );

        this._logf( str, e );

        return false;
    }


    /**
     * Return either success or failure message given `status'
     *
     * @param {boolean} status success/failure indicator
     *
     * @return {string} success/failure message
     */
    _doneMessage( status )
    {
        return ( status === false )
            ? this._str( 'fail' )
            : this._str( 'ok' );
    }
}


/**
 * Output strings in an easily accessible map
 *
 * This both keeps the code a bit more easily comprehensible by removing
 * large strings from procedural logic, and allows for future localization.
 *
 * We can do better once we get to a localization stage---Error messages
 * aren't part of this map, for example.
 *
 * @type {string}
 */
Bootstrap._strmap = {
    header: () =>
        "    _   _    \n" +
        " ,--0---0--. \n" +
        "|           |\n" +
        "|           |\n" +
        " `---------' \n",

    loadingf: ( desc, path ) =>
        `Loading ${desc} from ${path}...`,

    loadedf: ( path, len ) =>
        `Loaded ${path} (len=${len}).`,

    prebirthDesc: () =>
        "\n" +
        "Prebirth is a very basic Lisp dialect with a compiler\n" +
        "implemented in ECMAScript.  Birth is the same\n" +
        "compiler, but re-implemented in Prebirth Lisp.\n",

    prebirthComplete: ( len ) =>
        `[prebirth] Compilation complete (len=${len}).`,

    birthCompiled: () =>
        "\n" +
        "Birth has been compiled with Prebirth.  Since Birth is\n" +
        "a re-implementation of Prebirth, it can now be used\n" +
        "to compile itself.\n",

    birthSelfCompiling: () =>
        "[birth] Self-compiling Birth...",

    birthVerify: () =>
        "[birth] Verifying self-compilation output...",

    birthVerifyFail: () =>
        "\n" +
        "The self-compilation of Birth yielded output\n" +
        "that differs from Prebirth's compilation of Birth.\n" +
        "This verification step is a self-test to ensure\n" +
        "consistency between the two implementations.\n\n" +
        "Unfortunately, to fix this, you need to hack\n" +
        "Prebirth and/or Birth.  Please report a bug!",

    birthVerifyOk: () =>
        "[birth] Birth output matches that of Prebirth.",

    fatal: ( e ) =>
        "\n\n!!! " + e.toString() + "\n\n" +
        "Something has gone terribly wrong!\n" +
        "See the console for a stack trace.\n\n",

    ok: () =>
        "Bootstrap successful!",

    fail: () =>
        "Bootstrap failed.",
};


// for use in a CommonJS (e.g. Node.js) environment
if ( typeof module !== 'undefined' ) {
    module.exports = Bootstrap;
}