const minimatch  = require( "minimatch" );
const _          = require( "lodash" );
const process    = require( "process" );
const auto       = require( "auto-builder" );
const fsp        = require( "fs-promise" );
const path       = require( "path" );
const babel      = require( "babel-core" );
const globby     = require( "globby" );
const winston    = require( "winston" );
const browserify = require( "browserify" );
const pug        = require( "pug" );

async function bundlePug( src, tgt ) {
    winston.info( `compiling ${src} to ${tgt} @ html` );
    var code = pug.render( await fsp.readFile( src ), { filename : src, basedir : process.cwd() } );
    await fsp.writeFile( tgt, code );
}

async function compileJSXToES8( src, tgt ) {
    winston.info( `compiling ${src} @ JSX to ${tgt} @ ES8` );
    var code = babel.transform( await fsp.readFile( src ), {
        plugins : [ "transform-react-jsx" ]
    } ).code;
    await fsp.writeFile( tgt, code );
}

async function compileES8ToES7( src, tgt ) {
    winston.info( `compiling ${src} @ ES8 to ${tgt} @ ES7` );
    var code = babel.transform( await fsp.readFile( src ), {
        presets : [ require.resolve( "babel-preset-es2017" ) ]
    } ).code;
    await fsp.writeFile( tgt, code );
}

async function compileES7ToES5( src, tgt ) {
    winston.info( `compiling ${src} @ ES7 to ${tgt} @ ES5` );
    var code = babel.transform( await fsp.readFile( src ), {
        presets : [ require.resolve( "babel-preset-es2016" ) ]
    } ).code;
    code = babel.transform( code, {
        presets : [ require.resolve( "babel-preset-es2015" ) ],
        plugins : [ [ require.resolve( "babel-plugin-transform-runtime" ), { regenerator : true } ] ]
    } ).code;
    await fsp.writeFile( tgt, code );
}

async function bundleJS( src, tgt ) {
    winston.info( `bundling (using browserify) ${src} to ${tgt}` );
    var code = await new Promise( function( rs, rj ) {
        var b = browserify();
        b.add( path.resolve( src ) );
        b.bundle( (e,r) => e ? rj( e ) : rs( r.toString( "utf8" ) ) );
    });
    await fsp.writeFile( tgt, code );
}

async function copy( src, tgt ) {
    winston.info( `copying ${src} to ${tgt}` );
    await fsp.copy( src, tgt );
}

function rename( p, fn ) {
    var ext  = path.extname( p );
    var base = path.basename( p, ext );
    var dir  = path.dirname( p );
    return fn( dir, base, ext );
}

async function build() {

    var make     = {};
    var list     = await globby( [ "*.*", "www/**/*.*", "lib/**/*.*" ] );
    var grpDirs  = _.groupBy( list, x => path.dirname( x ) );

    for( let f of list ) {

        let es8 = rename( f, (d,b,_e) => path.join( "dist", d, b + ".js.es8" ) );
        // if the file is already a vanilla js file, just copy the file to its es8 destination
        if( path.extname( f ) === ".js" )
            make[ es8 ] = {
                dependencies : [ f ],
                recipe : () => copy( f, es8 )
            };
        // otherwise apply jsx pre-processor to convert to es8
        else if( path.extname( f ) === ".jsx" )
            make[ es8 ] = {
                dependencies : [ f ],
                recipe : () => compileJSXToES8( f, es8 )
            };

        // are we dealing with a js-type file
        if( path.extname( f ) === ".jsx" || path.extname( f ) === ".js" ) {
            // we will necessarily need to compile down to es7
            let es7 = rename( f, (d,b,_e) => path.join( "dist", d, b + ".js.es7" ) );
            make[ es7 ] = {
                dependencies : [ es8 ],
                recipe : () => compileES8ToES7( es8, es7 )
            };
            // if its a front-end file compile further to es5
            let tgt = rename( f, (d,b,_e) => path.join( "dist", d, b + ".js" ) );
            if( minimatch( f, "www/**/*.*" ) ) {
                let es5 = rename( f, (d,b,_e) => path.join( "dist", d, b + ".js.es5" ) );
                make[ es5 ] = {
                    dependencies : [ es7 ],
                    recipe : () => compileES7ToES5( es7, es5 )
                };
                // if its *not* an index file, then copy it to .js and be done
                if( path.basename( f ) !== "index.js" ) {
                    make[ tgt ] = {
                        dependencies : [ es5 ],
                        recipe : () => copy( es5, tgt )
                    };
                }
                // else it needs to be bundled
                else {
                    // gather all dependencies (all other directory-local js files and any js files in the global lib directory)
                    let allDeps = _.chain( grpDirs[ path.dirname( f ) ].concat( grpDirs[ "www/js" ] || [] ) )
                        .filter( x => ( path.extname( x ) === ".js" || path.extname( x ) === ".jsx" ) && x !== f )
                        .map( x => rename( x, (d,b,_e) => path.join( "dist", d, b + ".js" ) ) )
                        .value();
                    make[ tgt ] = {
                        dependencies : [ es5 ].concat( allDeps ),
                        recipe       : () => bundleJS( es5, tgt )
                    };
                }
            // otherwise just copy the back-end file over
            } else {
                make[ tgt ] = {
                    dependencies : [ es7 ],
                    recipe : () => copy( es7, tgt )
                };
            }
        // otherwise we're not dealing with a js file
        } else {

            if( path.extname( f ) === ".pug" ) {
                let tgt = rename( f, (d,b,_e) => path.join( "dist", d, b + ".html" ) );
                let allDeps = _.chain( grpDirs[ path.dirname( f ) ].concat( grpDirs[ "www/include" ] || [] ).concat( grpDirs[ "www/css" ] || [] ) )
                    .filter( x => path.extname( x ) === ".pug" || path.extname( x ) === ".css" )
                    .value();
                make[ tgt ] = {
                    dependencies : allDeps,
                    recipe       : () => bundlePug( f, tgt )
                };
            } else {
                let tgt = path.join( "dist", f );
                make[ tgt ] = {
                    dependencies : [ f ],
                    recipe       : () => copy( f, tgt )
                };
            }

        }

    }

    make[ "dist/build" ] = { dependencies : Object.keys(make) };
    var runner = auto( make );
    await runner( "dist/build" );

}

build()
    .then( () => winston.info( "BUILD SUCCEEDED" ) )
    .catch( (e) => winston.error( "BUILD FAILED", e ) );