const { resolve } = require("path");
const del = require("del");
const fs = require('fs');

const gulp = require('gulp');
const concat = require("gulp-concat");
const juicerLoader = require("./plugin/juicer-loader");
const cleanCss = require("./plugin/clean-css");
const themeLess = require('./plugin/theme-less');
const autoprefixer = require("gulp-autoprefixer");
const replace = require("gulp-replace");
const pump = require("pump");
const uglify = require('gulp-uglify');
const eventStream = require("event-stream");
const gif = require("gulp-if");
const order = require("gulp-order");
const rev = require("gulp-rev");
const less = require("gulp-less");
const rename = require('gulp-rename');
const amdOptimize = require("amd-optimize");
const livereload = require('gulp-livereload');
const _u = require("./common/util");

const env = _u.args("env");
const isprod = env == 'prod'; // 生产环境 默认为开发环境

const dir = _u.args("dir");
const baseUrl = resolve(__dirname, dir);

const mod = _u.args('mod') || "main";
const base = require("./config/base")(baseUrl);
let config = require(`./config/${mod}`)(baseUrl);

config = Object.assign({}, base, config);
const src = Object.assign({}, base.src, config.src);
const output = Object.assign({}, base.output, config.output);

let amdConfig = require(src.amdConfig);

// 清空output文件夹
const clean = type => {
    return del(config.clean[type] || [], { force: true });
}
gulp.task('clean-css', () => {
    return clean("css");
});

gulp.task('clean-js', () => {
    return clean("js");
});

gulp.task("clean-html", () => {
    return clean("html");
});

// 文件的md5映射
const manifest = {};

const replaceManifest = type => {
    return replace(/^{[.\s\S]*}$/g, match => {
        const paths = amdConfig.paths;
        const isHtml = type == "html";
        let path = "", m = "";
        let typeFloder = isHtml ? "template" : type;
        let suffix = isHtml ? ".html" : ""; // 由于html文件的加载使用require-text, 所以需要添加文件类型后缀如.html

        match = JSON.parse(match);

        typeFloder = mod != "main" ? `${typeFloder}/${mod}` : typeFloder;

        Object.keys(match).forEach(key => {
            m = match[key].replace(`.${type}`, "");
            match[`${typeFloder}/${key.replace(`.${type}`, "")}${suffix}`] = `${typeFloder}/${m}${suffix}`;
            delete match[key];
        });

        Object.keys(paths).forEach(key => {
            path = paths[key];

            if (match[path]) {
                manifest[key] = _u.getMd5(match[path]);
            }
        });

        return JSON.stringify(match);
    });
};

const cleanOptions = { compatibility: 'ie8', rebase: false };
const prefixerOptions = {
    browsers: ["ie >= 8", "Firefox >= 20", "last 3 Chrome versions", "iOS >= 7", "Android >= 4"],
    cascade: false
};

// 压缩css
gulp.task("minify-css", ['clean-css'], cb => {
    pump([
        gulp.src(src.css),
        gif(isprod, cleanCss(cleanOptions)),
        autoprefixer(prefixerOptions),
        gulp.dest(output.css),
        rev(),
        rev.manifest(),
        replaceManifest("css"),
        gulp.dest(output.css)
    ], cb);
});

const hasThemeLess = src.less && src.theme && output.theme;
const themes = [];

// 输出主题相关的文件 如theme/*.less, variables
gulp.task("theme-less-output", ["minify-css"], cb => {
    if (!hasThemeLess) return cb();

    pump([
        gulp.src(src.theme),
        gulp.dest(output.theme),
        gulp.src(src.variables),
        gulp.dest(output.less),
    ], cb);
});

// 输出less 主题相关的文件 如果a.less => a-xxx.less, a-xl.less
gulp.task("less-loader", ['theme-less-output'], cb => {
    if (!hasThemeLess) return cb();

    const files = fs.readdirSync(config.themePath);
    const themePaths = files.map(f => resolve(config.themePath, f));
    const len = themePaths.length;
    let i = 0;

    themePaths.forEach((themePath, i) => {
        const themeName = themePath.replace(/.*theme-(.*?)\.less/g, '$1');

        themes.push(themeName);

        pump([
            gulp.src(src.less),
            themeLess({
                path: themePath,
                variables: src.variables
            }),
            rename(path => path.basename += `-${themeName}`),
            less(),
            gif(isprod, cleanCss(cleanOptions)),
            autoprefixer(prefixerOptions),
            gulp.dest(output.css),
            rev(),
            rev.manifest(),
            replace(/"(.*?-.{10})\./g, match => {
                const [key, value] = match.split(':');
                const cssName = key.replace(/.*\/(.*?)-(.*?)\.css"$/g, '$1');
                const md5 = value.replace(/.*(.{10})\.$/, '$1');
                
                // 只取第一个主题的md5
                if(~cssName.indexOf('.css') || i) return;
                
                manifest[cssName + '_css'] = md5;
            }),
        ], () => {
            if (++i === len) {
                cb();
            }
        })
    });
});

// 压缩js并输出md5
gulp.task("minify-js", ['clean-js'], cb => {
    pump([
        gulp.src(src.js),
        juicerLoader({
            base: `${baseUrl}/template`,
            match: fpath => {
                const regExp = /([\\\/])js\1(component|service)\1(.*?)_wev8\.js/g;
                const matches = fpath.match(regExp);

                if (!matches) return null;

                let mode = matches[0].replace(regExp, "$3");
                let template = mode + '_html';

                if (~mode.indexOf('service')) {
                    mode = 'service/' + mode;
                    template = template.replace('service', 'mService').replace(/\./g, '/');
                }

                return [mode, template];
            }
        }),
        gif(isprod, uglify()),
        gulp.dest(output.js),
        rev(),
        rev.manifest(),
        replaceManifest('js'),
        gulp.dest(output.js)
    ], cb);
});

// 压缩html
gulp.task("minify-html", ['clean-html'], cb => {
    pump([
        gulp.src(src.html),
        gulp.dest(output.html),
        rev(),
        rev.manifest(),
        replaceManifest("html"),
        gulp.dest(output.html)
    ], cb);
});

gulp.task("minify", ['less-loader', 'minify-js', 'minify-html']);

// amd 模块化 optimize
let modules = config.modules;

// 替换amdConfig中的manifest
gulp.task("replace-amdConfig", ["minify"], cb => {
    pump([
        gulp.src(src.amdConfig),
        replace(/var[\s\S]manifest={};/g, match => {
            // loader版本每次打包必定为改动，且与amdConfig合并
            // 故不将其版本号放入manifest，以避免main_demo和main_export的改动
            const m = {...manifest};

            delete m.loader;

            return `var manifest=${JSON.stringify(m)};`;
        }),
        uglify(),
        gulp.dest(output.js),
        rev(),
        rev.manifest(),
        setMd5Mapping("amdConfig")
    ], cb);
});

var md5Mapping = {}; // 模块合并后生成的新md5映射

// 输出主要的模块css
gulp.task("css-optimize", ["minify"], cb => {
    if (!config.cssOptimize) return cb();

    const {includes, mainCss} = config.cssOptimize;
    const len = themes.length;

    themes.forEach((themeName, i) => {
        const modCss = `${config.name}-${themeName}.css`;
        const paths = [
            ...includes,
            mainCss(themeName)
        ];

        pump([
            gulp.src(paths),
            concat(modCss),
            gulp.dest(output.css),
            rev(),
            rev.manifest(),
            gif(themeName === config.defaultTheme, setMd5Mapping(`${config.name}_css`))
        ], () => {
            if (i + 1 === len) {
                cb();
            }
        });
    });
});

// 移动建模设计器需要用的css
gulp.task('css-exports', ["css-optimize"], cb => {
    const expts = config.exports;

    if (!(expts && expts.css)) return cb();

    let len = 0;

    expts.css.forEach((exportCss) => {
        pump([
            gulp.src(exportCss.css),
            concat(exportCss.name),
            replace(/.*/g, (css) => {
                return _u.scopeCss(css, exportCss.parent)
            }),
            gulp.dest(output.css)
        ], () => {
            len++;

            if (expts.css.length === len) {
                cb();
            }
        });
    })
});

gulp.task("amd-optimize", ['replace-amdConfig'], cb => {
    amdConfig.baseUrl = output.path;

    modules.forEach((mod, index) => {
        const filename = getFileName(mod.name);
        const isMainOrExport = mod.name === 'main' || mod.name === 'main_export';
        const mergeArr = [
            !isMainOrExport && gulp.src(output.amdConfig), // main, main_export模块中amdConfig与loader合并
            gulp.src(output.path)
                .pipe(amdOptimize(mod.name, amdConfig))
                .pipe(concat(filename))
                .pipe(rev())
                .pipe(rev.manifest())
                .pipe(setMd5Mapping(mod.name))
                .pipe(amdOptimize(mod.name, amdConfig))
                .pipe(concat(filename))
        ].filter(Boolean);

        mod.external && mergeArr.push(gulp.src(mod.external).pipe(concat("combine.js")));

        pump([
            eventStream.merge.apply(null, mergeArr),
            order(["**/amdConfig.js", "**/config.js", filename, "**/combine.js"]),
            concat(filename),
            gif(isprod, uglify()),
            gulp.dest(mod.output)
        ], () => {
            index === modules.length - 1 && cb();
        });
    });
});

gulp.task("optimize-loader", ["amd-optimize"], cb => {
    if (mod !== 'main') return cb();

    let streams = [[
        gulp.src([`${output.js}/loader.js`, output.amdConfig]),
        concat("loader.js"),
        gulp.dest(output.js),
        rev(),
        rev.manifest(),
        setMd5Mapping('loader')
    ]];

    if (isprod) {
        streams.push([
            gulp.src([`${output.js}/main_export/loader.js`, output.amdConfig]),
            concat("loader.js"),
            gulp.dest(`${output.js}/main_export`)
        ]);
    }

    let index = 0;

    streams.forEach((stream, i) => {
        pump(stream, () => {
            index++;
            if (index === streams.length) {
                cb();
            }
        });
    });
});

// 打包require.js
gulp.task("optimize-require-and-clean", ["optimize-loader", 'css-optimize', 'css-exports'], cb => {
    pump([
        gulp.src([base.require.src].concat(config.require.plugins)),
        concat("require.min_wev8.js"),
        uglify(),
        gulp.dest(base.require.path),
        rev(),
        rev.manifest(),
        setMd5Mapping('require')
    ], () => {
        let arr = config.del || [];
        // amd5
        arr.push.apply(config.del, [
            `${output.js}/rev-manifest.json`,
            `${output.html}/rev-manifest.json`,
            `${output.css}/rev-manifest.json`,
        ]);

        if (!isexport) {
            arr.push(`${output.js}/main_export`);
        }
        del(arr, { force: true });
        cb();
    });
});

function setMd5Mapping(modName) {
    return replace(/-(.{10})\./g, match => {
        match = match.replace(/-(.{10})\./g, "$1");
        md5Mapping[modName] = match;
    });
}

function getFileName(modName) {
    var fileName = amdConfig.paths[modName].replace(/.*\/(.*?)$/, "$1");

    return fileName + ".js";
}

const { regExp, files } = config.replace;
const comCss = regExp.css.split("|");
const comCssReg = new RegExp(`href=[\'\"][^\'|\"]*?(${regExp.css})[^\'|\"]*?[\'\"]`, "g");
const comJs = ["require"].concat(regExp.js.split("|"));
const comJsReg = new RegExp(`(require\.min|${regExp.js})[^,\'\"]*?\.js[\\s\\S]*?[\'\"]`, "g");

// 替换文件的md5后缀
gulp.task('replace-files-md5', ['optimize-require-and-clean'], cb => {
    files.forEach((file, index) => {
        pump([
            gulp.src(file.src),
            replace(comJsReg, match => {
                match = match.replace(/['"]/g, '"'); // 统一分号

                comJs.every(jsMod => {
                    if (!~match.indexOf(jsMod)) return true;

                    jsMod = jsMod.replace("_wev8", "");

                    let isIgnore = ~["require", "main", "loader"].indexOf(jsMod);
                    let v = md5Mapping[jsMod];

                    if (!v) {
                        v = manifest[jsMod];
                    } else if (!isIgnore) { // 依赖amdConfig
                        v += md5Mapping.amdConfig || "";
                    }

                    if (~match.indexOf("?v=")) {
                        match = match.replace(/v=(.*?)(['"])/g, "v=" + v + "$2");
                    } else {
                        match += "?v=" + v;
                    }

                    return false;
                });
                return match;
            }),
            replace(comCssReg, match => {
                let last = match.lastIndexOf(".css") + ".css".length;

                match = match.replace(/['"]/g, '"'); // 统一分号

                comCss.every(cssMod => {
                    if (!~match.indexOf(cssMod)) return true;

                    cssMod += "_css";
                    match = `${match.slice(0, last)}?v=${md5Mapping[cssMod] || manifest[cssMod]}"`;
                    return false;
                });

                return match;
            }),
            gulp.dest(file.output)
        ], () => {
            if (index == files.length - 1) {
                cb();
            }
        });
    });
});

// 开发环境下 监听文件变化
gulp.task('watch', function () {
    livereload.listen();
    const themeFolders = [];

    if (hasThemeLess) {
        themeFolders.push([src.less, src.theme, src.variables]);
    }
    
    gulp.watch([src.css, src.js, src.html, ...themeFolders], ['replace-files-md5']);
});

const taskList = isprod ? ["build"] : ["build", "watch"];
const isexport = isprod && _u.args("export") === "true";
const ispwa = _u.args("pwa") === "true";
const _export = require("./module/export")(baseUrl, output);
const _pwa = require("./module/pwa")(baseUrl, output);
const others = [];

if (isexport) {
    _export.regsiter();
    others.push("export");
}

if (ispwa) {
    _pwa.regsiter({
        getMd5Mapping: () => {
            return Object.assign({}, manifest, md5Mapping);
        },
        getPaths: () => {
            return amdConfig.paths;
        }
    });
    others.push("pwa");
}

const { DEFAULT_REL_BUILD_TASK } = require("./common/constants");

gulp.task("_others", others);
gulp.task(DEFAULT_REL_BUILD_TASK, ["replace-files-md5"]);
gulp.task("build", [DEFAULT_REL_BUILD_TASK, "_others"]);
gulp.task('default', taskList);