'use strict';
var gulp = require('gulp');
var sass = require('gulp-sass');
var imagemin = require('gulp-imagemin');
var uglify = require('gulp-uglify');
var del = require('del');
var merge = require('merge-stream');
var htmlmin = require('gulp-htmlmin');
var inlinesource = require('gulp-inline-source');
var gettext = require('gulp-angular-gettext');
var sourcemaps = require('gulp-sourcemaps');
var rename = require('gulp-rename');
var htmlify = require('gulp-angular-htmlify');
var ngAnnotate = require('gulp-ng-annotate');
var debug = require('gulp-debug');
var changed = require('gulp-changed');
var RevAll = require('gulp-rev-all');
var karma = require('karma').server;
var gulpFilter = require('gulp-filter');
var minifyCSS = require('gulp-minify-css');
var fs = require('fs');
var notify = require('gulp-notify');
var templateCache = require('gulp-angular-templatecache');
var postcss = require('gulp-postcss');
var autoprefixer = require('autoprefixer-core');
var connect = require('gulp-connect');
var replace = require('gulp-replace');
var rollbar = require('gulp-rollbar');
var argv = require('yargs').argv;
var Q = require('q');
var map = require('map-stream');
var chmod = require('gulp-chmod');
var globExpand = require('glob-expand');

var es = require('event-stream');
var path = require('path');
var gutil = require('gulp-util');

var DEST = 'build';
var revisionFiles = true;
var minificationEnabled = true;
var sourceMapsEnabled = true;
var rollbarUpload = argv.upload;
minificationEnabled = rollbarUpload || minificationEnabled;
sourceMapsEnabled = rollbarUpload || sourceMapsEnabled;

var cachedTemplatesGlobs = [
    './src/app/partials/*.html',
    './src/app/modals/*.html',
];

var uglifySettings = {
    preserveLicenseComments: false,
    inline_script: true,
    warnings: false,
    mangle: { except:
        [
            '__require',
            'require',
            'define',
            'System.import',
            'System.require',
            'System',
            'FB',
            'ga',
            'Rollbar'
        ]},
    beautify: {
        quote_keys: true
    },
    compress: {
        sequences: true,
        dead_code: true,
        conditionals: true,
        booleans: true,
        unused: true,
        if_return: true,
        join_vars: true,
        drop_console: true
    }
};

var base = path.join(__dirname, 'src');
var jspm = require('jspm');
jspm.setPackagePath('.');
var builder = new jspm.Builder();

function getSystemJSPath(mod, path) {
    var parts = builder.loader.map[mod].split(':');
    var dir = builder.loader.paths[parts[0] + ':*'].split('*')[0] + parts[1];
    return base + '/' + dir + '/' + path || '';
}

function getSystemJSEntryPoint(mod) {
    var parts = builder.loader.map[mod].split(':');
    var dir = builder.loader.paths[parts[0] + ':*'].split('*')[0] + parts[1];
    return base + '/' + dir + '.js';
}

gulp.task('default', ['clean', 'dev'], function() {
  gulp.watch([
      './src/scss/**/*',
      './src/app/partials/*',
      './src/app/modals/*.html'],
    ['dev']);
});

function styles() {
    var stream = gulp.src('./src/scss/app.scss', {base: base})
        .pipe(sass({includePaths: [
            getSystemJSPath('foundation', 'scss'),
            getSystemJSPath('fontawesome', 'scss'),
            getSystemJSPath('spinkit', 'scss')
        ]}))
        .pipe(postcss([
            autoprefixer({
                browsers: ['last 2 version'],
                cascade: false
            })
        ]))
        .pipe(rename(function(path) {
            path.dirname = './css/';
        }));

    if (minificationEnabled) {
        stream = stream.pipe(minifyCSS({
            advanced: false,
            aggressiveMerging: false
        }));
    }

    return stream;
}
gulp.task('styles', styles);

function errFn(e){
    console.log('Error on', e, e.stack);
}

function scripts() {
    var sourceGlob = [
        'src/**/*.js',
        '!src/version.json',
        '!src/lib/**/*',
    ];

    var bundleStream = es.pause();
    bundleStream.pause();

    var commonBundlePromise = commonBundle(4);

    var primaryBundlesPromise = commonBundlePromise.then(proccessBundles, errFn);

    var secondaryBundlesPromise = commonBundlePromise
        .then(miniBundleTrees, errFn)
        .then(proccessBundles, errFn);

    Promise.all([primaryBundlesPromise, secondaryBundlesPromise]).then(function(result){
        var a = result[0];
        var b = result[1];

        function popOnStream(data){
            if(!data.fileName) {
                return;
            }
            var file = new gutil.File({
                path: path.join(base, data.fileName),
                base: base,
                contents: new Buffer(data.contents),
                sourceMap: data.sourceMap
            });
            bundleStream.write(file);
        }

        a.map(popOnStream);
        b.map(popOnStream);
        bundleStream.resume();
        bundleStream.emit('end');
    });

    var stream = merge(bundleStream, thirdPartySources());

    if (sourceMapsEnabled) {
        stream = stream.pipe(sourcemaps.init());
    }

    stream = stream.pipe(rename(function(sourcePath) {
        sourcePath.dirname = sourcePath.dirname.replace(__dirname, '');
    }));

    return stream;

    function commonBundle(minCount){
        var files = globExpand(sourceGlob);
        var counts = {};

        var agregateTree = {};

        var promises = files.map(function(filename_){
            var filename = filename_.replace(/^src\//, '');
            return builder.trace(filename).then(function(tree){
                agregateTree = builder.addTrees(agregateTree, tree);
                for(var key in tree){
                    counts[key] = (counts[key] || 0) + 1;
                }
            }, errFn);
        });

        return Promise.all(promises).then(function(){
            for(var key in counts){
                if(counts[key] < minCount){
                    delete agregateTree[key];
                }
            }

            // console.log('commonTree', agregateTree);

            // return cTree;
            return [{
                tree: agregateTree,
                fileName: 'shared-bundle.js'
            }];
        });
    }

    function proccessBundles(bundles) {
        var bstream = es.pause();
        bstream.pause;

        var bundlePromises = bundles.map(function(args) {
            return builder.bundle(args.tree, { sourceMaps: sourceMapsEnabled })
            .then(processBundle, errFn);

            function processBundle(bundle) {
                var data = {
                    fileName: args.fileName,
                    contents: bundle.source,
                };

                if (sourceMapsEnabled && bundle.sourceMap){
                    var sourceMap = JSON.parse(bundle.sourceMap);
                    sourceMap.sourcesContent = [];
                    sourceMap.file = data.fileName;
                    sourceMap.sourceRoot = '.';

                    for (var j = 0; j < sourceMap.sources.length; j++) {
                        var content = fs.readFileSync(path.join(base, sourceMap.sources[j]), 'utf8');
                        sourceMap.sourcesContent.push(content);
                    }

                    data.sourceMap = sourceMap;
                }
                return data;
            }
        });
        return Promise.all(bundlePromises);
    }


    function miniBundleTrees(cBundles){

        var bundledFiles = [];
        for (var key in cBundles[0].tree) {
            var p = cBundles[0].tree[key].path;
            bundledFiles.push('src/' + p);
        }

        var sourceGlob_ = JSON.parse(JSON.stringify(sourceGlob));

        for (var j = 0; j < bundledFiles.length; j++) {
            sourceGlob_.push('!' + bundledFiles[j]);
        }

        var files = globExpand(sourceGlob_);

        var promises = files.map(function(filename_){
            var filename = filename_.replace(/^src\//, '');
            return builder.trace(filename).then(function(tree){
                // console.log("filename", filename, filename_);
                var cTree = JSON.parse(JSON.stringify(cBundles[0].tree));
                // Always keep the file itself
                delete cTree[filename];
                var prunedTree = builder.subtractTrees(tree, cTree);
                // console.log('commonTree', Object.keys(cTree));
                // console.log('trace', Object.keys(prunedTree));
                return {
                    tree: prunedTree,
                    fileName: filename
                };
            }, errFn);
        });

        return Promise.all(promises);
    }


    function thirdPartySources(){

        var combined = merge();

        ['en', 'fr', 'de', 'af'].map(function mpr(lang) {
            combined.add(gulp.src(
                getSystemJSPath('angular-i18n', 'angular-locale_' + lang + '.js'),
                {base: base}));
        });

        combined.add(gulp.src(
            [getSystemJSPath('leaflet', '**/*.js'), '!**/src/**'],
            {base: base})
        );

        combined.add(gulp.src(
            [
                'src/lib/system-polyfills.js',
                getSystemJSPath('papaparse', '**/*.js'),
                getSystemJSEntryPoint('papaparse'),
            ],
            {base: base})
        );

        return combined;
    }
}

// Fonts
function fonts() {
    return merge(
        gulp.src([getSystemJSPath('fontawesome', 'fonts/*')])
            .pipe(rename({dirname: 'fonts'})),
        gulp.src(['./src/fonts/*'], {base: base})
    );
}

// Error pages
function errorPages() {
    return gulp.src(['./src/error_pages/*'], {base: base})
        .pipe(changed(DEST));
}

// Images
function images() {
    var filter = gulpFilter(['*', '!.svg']);

    return merge(
        gulp.src([
            './src/*.{png,jpg,gif}',
            './src/img/*.{png,jpg,gif,svg}',
            getSystemJSPath('leaflet', 'dist/images/*.png'),
        ], {base: base}),
        gulp.src([getSystemJSPath('leaflet', '')])
            .pipe(rename({dirname: 'css/images'}))
    )
    .pipe(filter)
    .pipe(imagemin({ optimizationLevel: 7, progressive: true, interlaced: true, pngquant: true }))
    .pipe(filter.restore());
}

// HTML
function html() {
    var sourceGlob = [
        './src/**/*.html',
        '!./src/lib/**/*.html'
    ];

    for (var j = 0; j < cachedTemplatesGlobs.length; j++) {
        sourceGlob.push('!' + cachedTemplatesGlobs[j]);
    }

    return gulp.src(sourceGlob, {base: base})
    .pipe(inlinesource({rootpath: 'src'}))
    .pipe(replace(
        'system-polyfills.js"></script>',
        '/lib/system-polyfills.js"><\' + \'/script>'
        ), {skipBinary: true})
    .pipe(htmlmin({
        minifyCSS: minificationEnabled,
        minifyJS: minificationEnabled && uglifySettings,
        collapseWhitespace: true,
        conservativeCollapse: true,
        keepClosingSlash: true,
        removeComments: true,
        processScripts: ['text/ng-template'],
    }))
    .pipe(htmlify({
        customPrefixes: ['ui-', 'bkm-']
    }))
    .pipe(rename(function(path) {
        path.dirname = path.dirname.replace(__dirname, '');
    }));
}

function templates() {
    return gulp.src(cachedTemplatesGlobs, {base: base})
        .pipe(templateCache(
            'app/templates.js',
            {
                moduleSystem: 'RequireJS',
                module: 'templates',
                standalone: true
            }
        ));
}

// Extract translations
function pot() {
    return gulp.src(['src/**/*.html', 'src/**/*.js', '!src/lib/**/*'])
        .pipe(gettext.extract('template.pot', {}));
}

// Compile translations
function translations() {
    return gulp.src('po/**/*.po')
        .pipe(gettext.compile({
            format: 'json'
        }))
        .pipe(rename({dirname: 'translations'}));
}

function other() {
    return gulp.src([
        'src/**/*.pdf',
        'src/**/*.ico',
        'src/**/*.csv',
        'src/**/*.txt',
        'src/**/*.manifest'
    ]);
}

gulp.task('buildTemplates', function(cb) {
    return templates().pipe(chmod(755)).pipe(gulp.dest('src'));
});

// Clean
gulp.task('clean', function(cb) {
    del([DEST], cb);
});

// Build
gulp.task('build', ['clean', 'buildTemplates'], function() {

    function annotator(contents, path){

        var moduleLoaderRegex = /(?:define|require|System\.register|System\.import|System\["require"\]|System\["import"\])\s*\(\s*(?:(?:['"][^'"]*['"]\s?,\s?)?(?:\[[^\]]*|(?:function))|(?:['"][^'"]*['"]\s?))/g;
        var safeShortSubList = [];
        var result;

        while (result = moduleLoaderRegex.exec(contents)) {
            if (!result) {
                continue;
            }
            safeShortSubList.push(result[0]);
        }

        var fragments = [{'contents': contents, path: path}];

        for (var i = 0; i < fragments.length; i++) {
            for (var j = 0; j < safeShortSubList.length; j++) {
                var parts = fragments[i].contents.split(safeShortSubList[j]);

                if (parts.length === 1) {
                    continue;
                }

                var args = [i, 1];

                for (var idx = 0; idx < parts.length; idx++) {
                    if (parts[idx]) {
                        args.push({'contents': parts[idx], path: path});
                    }

                    var isLast = (idx === parts.length - 1);
                    if (!isLast) {
                        args.push({'contents': safeShortSubList[j], path: path, 'safeShort': true});
                    }
                }

                // Nothing changed
                if (args.length < 4) {
                    continue;
                }

                Array.prototype.splice.apply(fragments, args);
            }
        }

        return fragments;
    }

    function replacer(fragment, replaceRegExp, newReference, referencedFile) {

        // If not a js reference or its safe to do extentionless subs
        if (!referencedFile.path.match(/.js$/) || fragment.safeShort) {
            // ok
        } else if (replaceRegExp.toString().match('\\(\\)')) {
            return;
        }

        fragment.contents = fragment.contents.replace(replaceRegExp, '$1' + newReference + '$3$4');
    }

    var revAll = new RevAll({
        fileNameVersion: 'version.json',
        dontRenameFile: [
            /fb\.html/,
            /^\/?home\.html/,
            /^\/?business-home\.html/,
            /app\/app\.html/,
            /redirect\.html/,
            /app\/app\.manifest/,
            /img\/email-footer-logo.png/,
            /img\/email-logo.png/,
        ],
        dontUpdateReference: [
            /fb\.html/,
            /^\/?home\.html/,
            /^\/?business-home\.html/,
            /app\/app\.html/,
            /redirect\.html/,
            /app\/app\.manifest/
        ],
        dontSearchFile: [
            /.*\.pdf/
        ],
        dontGlobal: [
            /lib\/.*\.(jpg|jpeg|gif|png)/,
            /lib\/angular-i18n\/.*/,
            /lib\/.*/,
            /fonts\/.*/,
            /img\/bookem-120.png/,
            /version\.json/,
            /favicon\.ico/,
            /robots\.txt/,
            /humans\.txt/,
            /css\/images\/*/,
        ],
        annotator: annotator,
        replacer: replacer
    });

    var script = scripts().pipe(ngAnnotate({
        add: true,
        single_quotes: true,
    }));

    if (minificationEnabled) {
        script = script.pipe(uglify(uglifySettings));
    }

    var revisioned = merge(
        images(),
        html(),
        fonts(),
        script,
        styles(),
        other()
        );

    if (revisionFiles) {
        revisioned = revisioned.pipe(revAll.revision());
    }

    var nonrevisoned = merge(
        errorPages(),
        translations(),
        pot()
    );

    var stream;

    if (revisionFiles) {
        stream = merge(
            revisioned.pipe(revAll.versionFile()),
            revisioned,
            nonrevisoned
        );
    } else {
        stream = merge(
            revisioned,
            nonrevisoned
        );
    }

    if (sourceMapsEnabled && !rollbarUpload) {
        stream = stream.pipe(sourcemaps.write('./maps'));
    }

    var ps = es.pause();
    ps.pause();
    var versionHash;
    var deferred = Q.defer();

    var mapStream = map(function(file, cb) {

        deferred.promise.then(function() {
            cb(null, file);
        });

        if (!versionHash && !revisionFiles) {
            versionHash = 'BOOKEM_VERSION_HASH_123456789123';
            mapStream.pipe(ps);
            ps.resume();
            deferred.resolve();
        } else if (!versionHash && revAll.revisioner.hashCombined){
            console.log('Version hash:', revAll.revisioner.hashCombined);
            versionHash = revAll.revisioner.hashCombined;

            var versionReplace = replace(
                'BOOKEM_VERSION_HASH_123456789123',
                versionHash,
                {skipBinary: true}
            );

            if (rollbarUpload) {
                var rb = rollbar({
                    accessToken: '625baa078f76474d8201da0bb41c4682',
                    version: versionHash,
                    sourceMappingURLPrefix: 'https://bookem.co.za'
                });

                mapStream
                    .pipe(versionReplace)
                    .pipe(rb)
                    .pipe(ps);
            } else {
                mapStream
                    .pipe(versionReplace)
                    .pipe(ps);
            }

            ps.resume();
            deferred.resolve();
        }
    });

    stream.pipe(mapStream);
    stream = ps;

    // stream = stream.pipe(debug({verbose: true}));

    stream = stream.pipe(chmod(755))
    .pipe(gulp.dest(DEST))
    .pipe(notify({
        onLast: true,
        message: 'Build complete'
    }));

    return stream.on('error', errFn);
});

// Develop
gulp.task('dev', function() {
    return merge(
        templates(),
        styles(),
        translations(),
        pot().pipe(rename({dirname: '../po'})),
        gulp.src([getSystemJSPath('fontawesome', 'fonts/*')]).pipe(rename({dirname: 'fonts'}))
    )
    // .pipe(debug({verbose: true}))
    .pipe(gulp.dest('src'))
    .pipe(notify({
        onLast: true,
        message: 'Build complete'
    }));
});


// Test
gulp.task('test', function (done) {
    karma.start({
        configFile: __dirname + '/test/configs/unit.conf.js',
        singleRun: true
    }, done);
});


gulp.task('connect', function() {
    connect.server({
        root: './src',
        livereload: true,
        fallback: './src/home.html'
    });
});