const os = require('os');
const fs = require('fs');
const path = require('path');
const tmp = require('tmp-file');
const exec = require('./exec');
const through = require('through2');
const Sdk = require('./sdk');
const Vinyl = require('vinyl');
const PluginError = require('plugin-error');
const colors = require('ansi-colors');
const log = require('fancy-log');
const vfs = require('vinyl-fs');
const rmdir = require('rmdir');


class Haxe extends Sdk {

    getBin(name) {
        if (Sdk.System.isWindows) {
            return `${this.binPath}/${name}.exe`;
        } else if (Sdk.System.isLinux) {
            const binPath = `${this.binPath}/${name}`;
            fs.chmodSync(binPath, 0o755);
            return binPath;
        }
        throw `Unsupported OS: ${os.type()}`;
    }

    get binPath() {
        return `${this.path}`;
    }

    get haxeBin() {
        return this.getBin('haxe');
    }

    get haxelibBin() {
        return this.getBin('haxelib');
    }

    constructor(version) {
        super(Haxe.ID, version || Haxe.VERSION);
    }

    get prepared() {
        try {
            return fs.existsSync(this.haxeBin);
        } catch (e) {
            return false;
        }
    }

    activate() {
        process.env.HAXE_VERSION = this.version;
        process.env.HAXE_STD_PATH = `${this.binPath}/std`;
        process.env.HAXE_HOME = this.binPath;
        process.env.PATH = `${process.env.PATH}:${this.binPath}`;
    }

    prepare() {
        return super.prepare().then(() => this.activate());
    }

    get link() {
        if (Sdk.System.isWindows) {
            return `https://github.com/HaxeFoundation/haxe/releases/download/${this.version}/haxe-${this.version}-win.zip`;
        } else if (Sdk.System.isLinux) {
            let arch = Sdk.System.archInt;
            return `https://github.com/HaxeFoundation/haxe/releases/download/${this.version}/haxe-${this.version}-linux${arch}.tar.gz`;
        }
    }

    haxe(args) {
        return exec('.', [this.haxeBin].concat(args).join(' '));
    }

    haxelib(args) {
        const haxelibBin = this.haxelibBin;
        //return exec(this.binPath, [path.basename(haxelibBin)].concat(args).join(' '));
        return exec('.', [haxelibBin].concat(args).join(' '));
    }

    install(packages) {
        let promise = this.haxelib(['setup', `${this.path}/lib`]);
        const next = (args) => () => {
            log(this.tag, colors.cyan('haxelib', 'install'), colors.magenta(args[1]));
            return this.haxelib(args);
        };

        if (!Array.isArray(packages)) {
            packages = Object.entries(packages).map(([k, v]) => ({name: k, version: v}));
        }

        for (let pack of packages) {
            const args = [];
            let version = null;
            if (typeof pack === 'string') {
                args.push('install', pack);
            } else if (typeof pack === 'object') {
                version = pack.version;
                if (version.substr(0, 3) === 'git') {
                    pack.git = version;
                    version = null;
                }
                if (pack.git) {
                    args.push('git', pack.name, pack.git);
                    if (pack.branch) args.push(pack.branch);
                } else {
                    args.push('install', pack.name);
                    if (version) args.push(version);
                }
                args.push('--always');
            }
            let path = `${this.path}/lib/${args[1]}`;
            if (version) {
                path += `/${version.replace(/\./g, ',')}`;
            } else if (pack.git) {
                path += '/git';
            }
            if (!fs.existsSync(path)) {
                promise = promise.then(next(args));
            }
        }
        return promise;
    }

    upgrade() {
        let promise = this.haxelib(['setup', `${this.path}/lib`]);
        promise = promise.then(() => this.haxelib(['upgrade', '--always']));
        return promise;
    }

    /**
     *
     * @param params
     * @returns {*}
     *
     * {
     *     command: 'build',
     *     platform: 'flash',
     *     version: '1.0.0',
     *     lib: {},
     *     values: {},
     *     macro: [],
     *     outputFile: 'out.swf',
     * }
     */
    openfl(params) {
        params = Object.assign({
            version: null,
            lib: [],
            cp: [],
            main: null,
            values: {},
            macro: [],
            debug: false,
        }, params);

        const files = [];
        let stream = null;

        const bufferContents = (file, enc, callback) => {
            // ToDo: check file not stream
            files.push(file);
            callback();
        };

        const endStream = (callback) => {
            log(this.tag, colors.cyan(`openfl ${params.command} ${params.platform}`));
            const args = ['-cwd', files[0].path, 'run', 'openfl', params.command, params.platform];
            // lib
            let lib = params.lib;
            if (!Array.isArray(lib)) {
                lib = Object.entries(lib).map(([k, v]) => `${k}:${v.split('@')[0]}`);
            }
            for (const item of lib) {
                args.push(`--haxelib="${item}"`);
            }
            // cp
            for (const item of params.cp) {
                args.push(`--source="${item}"`);
            }
            if (params.main) {
                args.push(`--app-main="${params.main}"`);
            }
            // macro
            for (const macro of params.macro) {
                args.push(`--haxeflag="--macro ${macro}"`);
            }
            for (let key of Object.keys(params.values)) {
                const value = params.values[key];
                if (value === true) {
                    args.push(`-D${key}`);
                } else if (value) {
                    args.push(`-D${key}="${value}"`);
                }
            }
            const buildDir = path.join(os.tmpdir(), 'build');
            args.push(`--app-path="${buildDir}"`);
            if (params.outputFile) {
                args.push(`--app-file="${params.outputFile}"`);
            }
            if (params.version) args.push(`--meta-version=${params.version}`);
            if (params.debug) {
                args.push('-debug');
            }
            const target = `${buildDir}/${params.platform}/bin`;
            rmdir(target);
            this.haxelib(args).then(() => {
                vfs.src(`${target}/**/*`).pipe(through.obj((file, enc, cb) => {
                    stream.push(file);
                    cb();
                }, (cb) => {
                    callback();
                    cb();
                }));
                //callback();
            }).catch((error) => {
                stream.emit('error', new PluginError({plugin: this.name, message: error}));
                callback();
            });
        };

        return stream = through.obj(bufferContents, endStream);
    }

    /**
     *
     * @param params
     *
     * {
     *      platform: 'neko',
     *      version: '1.0.0',
     *      values: {},
     *      macro: [],
     *      lib: [],
     *      src: [],
     *      main: 'Main.hx',
     *      outputFile: 'out.n',
     *      debug: false,
     * }
     */
    build(params) {
        params = Object.assign({
            version: null,
            values: {},
            lib: [],
            macro: [],
            debug: false,
        }, params);

        const files = [];
        let stream = null;

        const bufferContents = (file, enc, callback) => {
            // ToDo: check file not stream
            files.push(file);
            callback();
        };

        const endStream = (callback) => {
            log(this.tag, colors.cyan("haxe", params.platform), '=>', colors.magenta(params.outputFile));
            const args = [];
            // main
            args.push('-main', params.main);
            // lib
            let lib = params.lib;
            if (!Array.isArray(lib)) {
                lib = Object.entries(lib).map(([k, v]) => `${k}:${v.split('@')[0]}`);
            }
            for (const item of lib) {
                args.push('-lib', item);
            }
            // cp
            for (const cp of params.cp) {
                args.push('-cp', cp);
            }
            // macro
            for (const macro of params.macro) {
                args.push('--macro', `"${macro}"`);
            }
            for (let key of Object.keys(params.values)) {
                const value = params.values[key];
                if (value === true) {
                    args.push(`-D ${key}`);
                } else if (value) {
                    args.push(`-D ${key}="${value}"`);
                }
            }
            const tmpFile = tmp.generateFile();
            args.push(`-${params.platform}`, tmpFile.path);
            if (params.debug) {
                args.push('-debug');
            }
            //console.log('haxe', args.join(' '));
            this.haxe(args).then(() => {
                const out = new Vinyl({
                    path: params.outputFile,
                    //contents: fs.createReadStream(tmpFile.path),
                    contents: fs.readFileSync(tmpFile.path),
                });
                stream.push(out);
                callback();
            }).catch((error) => {
                stream.emit('error', new PluginError({plugin: this.name, message: error}));
                callback();
            });
        };

        return stream = through.obj(bufferContents, endStream);
    }
}

Haxe.ID = 'haxe';

Haxe.VERSION_3_4_0 = '3.4.0';
Haxe.VERSION_3_4_2 = '3.4.2';
Haxe.VERSION_3_4_3 = '3.4.3';
Haxe.VERSION_3_4_7 = '3.4.7';
Haxe.VERSION_3 = Haxe.VERSION_3_4_7;
Haxe.VERSION = Haxe.VERSION_3;

module.exports = Haxe;