"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.close = exports.run = exports.api = void 0;
const child_process = require("child_process");
const fs = require("fs-extra");
const path = require("path");
const exec_1 = require("./exec");
const korepath = require("./korepath");
const log = require("./log");
const Platform_1 = require("./Platform");
const ProjectFile_1 = require("./ProjectFile");
const AssetConverter_1 = require("./AssetConverter");
const HaxeCompiler_1 = require("./HaxeCompiler");
const ShaderCompiler_1 = require("./ShaderCompiler");
const DebugHtml5Exporter_1 = require("./Exporters/DebugHtml5Exporter");
const EmptyExporter_1 = require("./Exporters/EmptyExporter");
const FlashExporter_1 = require("./Exporters/FlashExporter");
const Html5Exporter_1 = require("./Exporters/Html5Exporter");
const Html5WorkerExporter_1 = require("./Exporters/Html5WorkerExporter");
const JavaExporter_1 = require("./Exporters/JavaExporter");
const KincExporter_1 = require("./Exporters/KincExporter");
const KincHLExporter_1 = require("./Exporters/KincHLExporter");
const KromExporter_1 = require("./Exporters/KromExporter");
const NodeExporter_1 = require("./Exporters/NodeExporter");
const PlayStationMobileExporter_1 = require("./Exporters/PlayStationMobileExporter");
const WpfExporter_1 = require("./Exporters/WpfExporter");
const HaxeProject_1 = require("./HaxeProject");
const Icon = require("./Icon");
let lastAssetConverter;
let lastShaderCompiler;
let lastHaxeCompiler;
function fixName(name) {
    name = name.replace(/[-@\ \.\/\\]/g, '_');
    if (name[0] === '0' || name[0] === '1' || name[0] === '2' || name[0] === '3' || name[0] === '4'
        || name[0] === '5' || name[0] === '6' || name[0] === '7' || name[0] === '8' || name[0] === '9') {
        name = '_' + name;
    }
    return name;
}
function safeName(name) {
    return name.replace(/[^A-z0-9\-\_]/g, '-');
}
function createKorefile(name, exporter, options, targetOptions, libraries, cdefines, cflags, cppflags, stackSize, version, id, korehl, icon) {
    let out = '';
    out += 'let fs = require(\'fs\');\n';
    out += 'let path = require(\'path\');\n';
    out += 'let project = new Project(\'' + name + '\');\n';
    if (version) {
        out += 'project.version = \'' + version + '\';\n';
    }
    if (id) {
        out += 'project.id = \'' + id + '\';\n';
    }
    if (icon != null)
        out += 'project.icon = \'' + icon + '\';\n';
    for (let cdefine of cdefines) {
        out += 'project.addDefine(\'' + cdefine + '\');\n';
    }
    for (let cppflag of cppflags) {
        out += 'project.addCppFlag(\'' + cppflag + '\');\n';
    }
    for (let cflag of cflags) {
        out += 'project.addCFlag(\'' + cflag + '\');\n';
    }
    out += 'project.addDefine(\'HXCPP_API_LEVEL=400\');\n';
    out += 'project.addDefine(\'HXCPP_DEBUG\', \'Debug\');\n';
    if (!options.slowgc) {
        out += 'project.addDefine(\'HXCPP_GC_GENERATIONAL\');\n';
    }
    if (targetOptions) {
        let koreTargetOptions = {};
        for (let option in targetOptions) {
            koreTargetOptions[option] = targetOptions[option];
        }
        out += 'project.targetOptions = ' + JSON.stringify(koreTargetOptions) + ';\n';
    }
    out += 'project.setDebugDir(\'' + path.relative(options.from, path.join(options.to, exporter.sysdir())).replace(/\\/g, '/') + '\');\n';
    let buildpath = path.relative(options.from, path.join(options.to, exporter.sysdir() + '-build')).replace(/\\/g, '/');
    if (buildpath.startsWith('..'))
        buildpath = path.resolve(path.join(options.from.toString(), buildpath));
    out += 'await project.addProject(\'' + path.join(options.kha, 'Kinc').replace(/\\/g, '/') + '\');\n';
    out += 'await project.addProject(\'' + buildpath.replace(/\\/g, '/') + '\');\n';
    if (korehl)
        out += 'await project.addProject(\'' + path.join(options.kha, 'Backends', 'Kinc-HL').replace(/\\/g, '/') + '\');\n';
    else
        out += 'await project.addProject(\'' + path.join(options.kha, 'Backends', 'Kinc-hxcpp').replace(/\\/g, '/') + '\');\n';
    for (let lib of libraries) {
        let libPath = lib.libpath.replace(/\\/g, '/');
        out += 'if (fs.existsSync(path.join(\'' + libPath + '\', \'kfile.js\')) || fs.existsSync(path.join(\'' + libPath + '\', \'kincfile.js\')) || fs.existsSync(path.join(\'' + libPath + '\', \'korefile.js\'))) {\n';
        out += '\tawait project.addProject(\'' + libPath + '\');\n';
        out += '}\n';
    }
    if (stackSize) {
        out += 'project.stackSize = ' + stackSize + ';\n';
    }
    out += 'project.flatten();\n';
    out += 'resolve(project);\n';
    return out;
}
function runKmake(options) {
    return new Promise((resolve, reject) => {
        const child = child_process.spawn(path.join(korepath.get(), 'kmake' + (0, exec_1.sys)()), options);
        child.stdout.on('data', (data) => {
            const str = data.toString();
            log.info(str, false);
        });
        child.stderr.on('data', (data) => {
            const str = data.toString();
            log.error(str, false);
        });
        child.on('error', (err) => {
            log.error('Could not start kmake.');
            reject();
        });
        child.on('close', (code) => {
            if (code === 0) {
                resolve();
            }
            else {
                reject();
            }
        });
    });
}
async function exportProjectFiles(name, resourceDir, options, exporter, kore, korehl, icon, libraries, targetOptions, defines, cdefines, cflags, cppflags, stackSize, version, id) {
    if (options.haxe !== '') {
        let haxeOptions = exporter.haxeOptions(name, targetOptions, defines);
        haxeOptions.defines.push('kha');
        haxeOptions.defines.push('kha_version=1810');
        haxeOptions.safeName = safeName(haxeOptions.name);
        haxeOptions.defines.push('kha_project_name=' + haxeOptions.name);
        if (options.livereload)
            haxeOptions.defines.push('kha_live_reload');
        if (options.debug && haxeOptions.parameters.indexOf('-debug') < 0) {
            haxeOptions.parameters.push('-debug');
        }
        (0, HaxeProject_1.writeHaxeProject)(options.to, !options.noproject, haxeOptions);
        if (!options.nohaxe) {
            let compiler = new HaxeCompiler_1.HaxeCompiler(options.to, haxeOptions.to, haxeOptions.realto, resourceDir, options.haxe, 'project-' + exporter.sysdir() + '.hxml', haxeOptions.sources, exporter.sysdir(), options.watchport, options.livereload, options.port);
            lastHaxeCompiler = compiler;
            try {
                await compiler.run(options.watch);
            }
            catch (error) {
                return Promise.reject(error);
            }
        }
        for (let callback of ProjectFile_1.Callbacks.postHaxeCompilation) {
            callback();
        }
        await exporter.export(name, targetOptions, haxeOptions);
    }
    let buildDir = path.join(options.to, exporter.sysdir() + '-build');
    if (options.haxe !== '' && kore && !options.noproject) {
        // If target is a Kore project, generate additional project folders here.
        // generate the kincfile.js
        fs.copySync(path.join(__dirname, '..', 'Data', 'hxcpp', 'kfile.js'), path.join(buildDir, 'kfile.js'), { overwrite: true });
        fs.writeFileSync(path.join(options.to, 'kfile.js'), createKorefile(name, exporter, options, targetOptions, libraries, cdefines, cflags, cppflags, stackSize, version, id, false, icon));
        // Similar to khamake.js -> main.js -> run(...)
        // We now do kincmake.js -> main.js -> run(...)
        // This will create additional project folders for the target,
        // e.g. 'build/pi-build'
        try {
            const kmakeOptions = ['--from', options.from, '--to', buildDir, '--kfile', path.resolve(options.to, 'kfile.js'), '-t', koreplatform(options.target), '--noshaders',
                '--graphics', options.graphics, '--arch', options.arch, '--audio', options.audio, '--vr', options.vr, '-v', options.visualstudio
            ];
            if (options.nosigning) {
                kmakeOptions.push('--nosigning');
            }
            if (options.debug) {
                kmakeOptions.push('--debug');
            }
            if (options.run) {
                kmakeOptions.push('--run');
            }
            if (options.compile) {
                kmakeOptions.push('--compile');
            }
            await runKmake(kmakeOptions);
            for (let callback of ProjectFile_1.Callbacks.postCppCompilation) {
                callback();
            }
            log.info('Done.');
            return name;
        }
        catch (error) {
            if (error) {
                log.error('Error: ' + error);
            }
            else {
                log.error('Error.');
            }
            process.exit(1);
            return name;
        }
    }
    else if (options.haxe !== '' && korehl && !options.noproject) {
        fs.copySync(path.join(__dirname, '..', 'Data', 'hl', 'kore_sources.c'), path.join(buildDir, 'kore_sources.c'), { overwrite: true });
        fs.copySync(path.join(__dirname, '..', 'Data', 'hl', 'kfile.js'), path.join(buildDir, 'kfile.js'), { overwrite: true });
        fs.writeFileSync(path.join(options.to, 'kfile.js'), createKorefile(name, exporter, options, targetOptions, libraries, cdefines, cflags, cppflags, stackSize, version, id, korehl, icon));
        try {
            const kmakeOptions = ['--from', options.from, '--to', buildDir, '--kfile', path.resolve(options.to, 'kfile.js'), '-t', koreplatform(options.target), '--noshaders',
                '--graphics', options.graphics, '--arch', options.arch, '--audio', options.audio, '--vr', options.vr, '-v', options.visualstudio
            ];
            if (options.nosigning) {
                kmakeOptions.push('--nosigning');
            }
            if (options.debug) {
                kmakeOptions.push('--debug');
            }
            if (options.run) {
                kmakeOptions.push('--run');
            }
            if (options.compile) {
                kmakeOptions.push('--compile');
            }
            await runKmake(kmakeOptions);
            for (let callback of ProjectFile_1.Callbacks.postCppCompilation) {
                callback();
            }
            log.info('Done.');
            return name;
        }
        catch (error) {
            if (error) {
                log.error('Error: ' + error);
            }
            else {
                log.error('Error.');
            }
            process.exit(1);
            return name;
        }
    }
    else {
        // If target is not a Kore project, e.g. HTML5, finish building here.
        log.info('Done.');
        return name;
    }
}
function checkKorePlatform(platform) {
    return platform === 'windows'
        || platform === 'windowsapp'
        || platform === 'ios'
        || platform === 'osx'
        || platform === 'android'
        || platform === 'linux'
        || platform === 'emscripten'
        || platform === 'pi'
        || platform === 'tvos'
        || platform === 'ps4'
        || platform === 'xboxone'
        || platform === 'switch'
        || platform === 'xboxscarlett'
        || platform === 'ps5'
        || platform === 'freebsd';
}
function koreplatform(platform) {
    if (platform.endsWith('-hl'))
        return platform.substr(0, platform.length - '-hl'.length);
    else
        return platform;
}
let kore = false;
let korehl = false;
async function exportKhaProject(options) {
    log.info('Creating Kha project.');
    let project = null;
    let foundProjectFile = false;
    // get the khafile.js and load the config code,
    // then create the project config object, which contains stuff
    // like project name, assets paths, sources path, library path...
    if (fs.existsSync(path.join(options.from, options.projectfile))) {
        try {
            project = await (0, ProjectFile_1.loadProject)(options.from, options.projectfile, options.target);
        }
        catch (x) {
            log.error(x);
            throw 'Loading the projectfile failed.';
        }
        foundProjectFile = true;
    }
    if (!foundProjectFile) {
        throw 'No khafile found.';
    }
    let temp = path.join(options.to, 'temp');
    fs.ensureDirSync(temp);
    let exporter = null;
    let target = options.target.toLowerCase();
    let baseTarget = target;
    let customTarget = null;
    if (project.customTargets.get(options.target)) {
        customTarget = project.customTargets.get(options.target);
        baseTarget = customTarget.baseTarget;
    }
    switch (baseTarget) {
        case Platform_1.Platform.Krom:
            exporter = new KromExporter_1.KromExporter(options);
            break;
        case Platform_1.Platform.Flash:
            exporter = new FlashExporter_1.FlashExporter(options);
            break;
        case Platform_1.Platform.HTML5:
            exporter = new Html5Exporter_1.Html5Exporter(options);
            break;
        case Platform_1.Platform.HTML5Worker:
            exporter = new Html5WorkerExporter_1.Html5WorkerExporter(options);
            break;
        case Platform_1.Platform.DebugHTML5:
            exporter = new DebugHtml5Exporter_1.DebugHtml5Exporter(options);
            break;
        case Platform_1.Platform.WPF:
            exporter = new WpfExporter_1.WpfExporter(options);
            break;
        case Platform_1.Platform.Java:
            exporter = new JavaExporter_1.JavaExporter(options);
            break;
        case Platform_1.Platform.PlayStationMobile:
            exporter = new PlayStationMobileExporter_1.PlayStationMobileExporter(options);
            break;
        case Platform_1.Platform.Node:
            exporter = new NodeExporter_1.NodeExporter(options);
            break;
        case Platform_1.Platform.Empty:
            exporter = new EmptyExporter_1.EmptyExporter(options);
            break;
        default:
            if (baseTarget.endsWith('-hl')) {
                korehl = true;
                options.target = koreplatform(baseTarget);
                if (!checkKorePlatform(options.target)) {
                    log.error(`Unknown platform: ${target} (baseTarget=$${baseTarget})`);
                    return Promise.reject('');
                }
                exporter = new KincHLExporter_1.KincHLExporter(options);
            }
            else {
                kore = true;
                options.target = koreplatform(baseTarget);
                if (!checkKorePlatform(options.target)) {
                    log.error(`Unknown platform: ${target} (baseTarget=$${baseTarget})`);
                    return Promise.reject('');
                }
                exporter = new KincExporter_1.KincExporter(options);
            }
            break;
    }
    exporter.setSystemDirectory(target);
    let buildDir = path.join(options.to, exporter.sysdir() + '-build');
    // Create the target build folder
    // e.g. 'build/pi'
    fs.ensureDirSync(path.join(options.to, exporter.sysdir()));
    let defaultWindowOptions = {
        width: 800,
        height: 600
    };
    let windowOptions = project.windowOptions ? project.windowOptions : defaultWindowOptions;
    exporter.setName(project.name);
    exporter.setWidthAndHeight('width' in windowOptions ? windowOptions.width : defaultWindowOptions.width, 'height' in windowOptions ? windowOptions.height : defaultWindowOptions.height);
    for (let source of project.sources) {
        exporter.addSourceDirectory(source);
    }
    for (let library of project.libraries) {
        exporter.addLibrary(library);
    }
    exporter.parameters = exporter.parameters.concat(project.parameters);
    project.scriptdir = options.kha;
    if (baseTarget !== Platform_1.Platform.Java && baseTarget !== Platform_1.Platform.WPF) {
        project.addShaders('Sources/Shaders/**', {});
    }
    for (let callback of ProjectFile_1.Callbacks.preAssetConversion) {
        callback();
    }
    let assetConverter = new AssetConverter_1.AssetConverter(exporter, options, project.assetMatchers);
    lastAssetConverter = assetConverter;
    let assets = await assetConverter.run(options.watch, temp);
    if ((target === Platform_1.Platform.DebugHTML5 && process.platform === 'win32') || target === Platform_1.Platform.HTML5) {
        Icon.exportIco(project.icon, path.join(options.to, exporter.sysdir(), 'favicon.ico'), options.from, options);
    }
    else if (target === Platform_1.Platform.DebugHTML5) {
        Icon.exportPng(project.icon, path.join(options.to, exporter.sysdir(), 'favicon.png'), 256, 256, 0xffffffff, true, options.from, options);
    }
    let shaderDir = path.join(options.to, exporter.sysdir() + '-resources');
    for (let callback of ProjectFile_1.Callbacks.preShaderCompilation) {
        callback();
    }
    fs.ensureDirSync(shaderDir);
    let oldResources = null;
    let recompileAllShaders = false;
    try {
        oldResources = JSON.parse(fs.readFileSync(path.join(options.to, exporter.sysdir() + '-resources', 'files.json'), 'utf8'));
        for (let file of oldResources.files) {
            if (file.type === 'shader') {
                if (!file.files || file.files.length === 0) {
                    recompileAllShaders = true;
                    break;
                }
            }
        }
    }
    catch (error) {
    }
    let exportedShaders = [];
    if (!options.noshaders) {
        if (fs.existsSync(path.join(options.from, 'Backends'))) {
            let libdirs = fs.readdirSync(path.join(options.from, 'Backends'));
            for (let ld in libdirs) {
                let libdir = path.join(options.from, 'Backends', libdirs[ld]);
                if (fs.statSync(libdir).isDirectory()) {
                    let exe = path.join(libdir, 'krafix', 'krafix-' + options.target + '.exe');
                    if (fs.existsSync(exe)) {
                        options.krafix = exe;
                    }
                }
            }
        }
        let shaderCompiler = new ShaderCompiler_1.ShaderCompiler(exporter, baseTarget, options.krafix, shaderDir, temp, buildDir, options, project.shaderMatchers);
        lastShaderCompiler = shaderCompiler;
        try {
            if (baseTarget !== Platform_1.Platform.Java && baseTarget !== Platform_1.Platform.WPF) {
                exportedShaders = await shaderCompiler.run(options.watch, recompileAllShaders);
            }
        }
        catch (err) {
            return Promise.reject(err);
        }
    }
    function findShader(name) {
        let fallback = {};
        fallback.files = [];
        fallback.inputs = [];
        fallback.outputs = [];
        fallback.uniforms = [];
        fallback.types = [];
        try {
            for (let file of oldResources.files) {
                if (file.type === 'shader' && file.name === fixName(name)) {
                    return file;
                }
            }
        }
        catch (error) {
            return fallback;
        }
        return fallback;
    }
    let files = [];
    for (let asset of assets) {
        let file = {
            name: fixName(asset.name),
            files: asset.files,
            file_sizes: asset.file_sizes,
            type: asset.type
        };
        if (file.type === 'image') {
            file.original_width = asset.original_width;
            file.original_height = asset.original_height;
            if (asset.readable)
                file.readable = asset.readable;
        }
        files.push(file);
    }
    for (let shader of exportedShaders) {
        if (shader.noembed)
            continue;
        let oldShader = findShader(shader.name);
        files.push({
            name: fixName(shader.name),
            files: shader.files === null ? oldShader.files : shader.files,
            file_sizes: [1],
            type: 'shader',
            inputs: shader.inputs === null ? oldShader.inputs : shader.inputs,
            outputs: shader.outputs === null ? oldShader.outputs : shader.outputs,
            uniforms: shader.uniforms === null ? oldShader.uniforms : shader.uniforms,
            types: shader.types === null ? oldShader.types : shader.types
        });
    }
    // Sort to prevent files.json from changing between makes when no files have changed.
    files.sort(function (a, b) {
        if (a.name > b.name)
            return 1;
        if (a.name < b.name)
            return -1;
        return 0;
    });
    function secondPass() {
        // First pass is for main project files. Second pass is for shaders.
        // Will try to look for the folder, e.g. 'build/Shaders'.
        // if it exists, export files similar to other a
        let hxslDir = path.join('build', 'Shaders');
        /** if (fs.existsSync(hxslDir) && fs.readdirSync(hxslDir).length > 0) {
            addShaders(exporter, platform, project, from, to.resolve(exporter.sysdir() + '-resources'), temp, from.resolve(Paths.get(hxslDir)), krafix);
            if (foundProjectFile) {
                fs.outputFileSync(to.resolve(Paths.get(exporter.sysdir() + '-resources', 'files.json')).toString(), JSON.stringify({ files: files }, null, '\t'), { encoding: 'utf8' });
                log.info('Assets done.');
                exportProjectFiles(name, from, to, options, exporter, platform, khaDirectory, haxeDirectory, kore, project.libraries, project.targetOptions, callback);
            }
            else {
                exportProjectFiles(name, from, to, options, exporter, platform, khaDirectory, haxeDirectory, kore, project.libraries, project.targetOptions, callback);
            }
        }*/
    }
    if (foundProjectFile) {
        fs.outputFileSync(path.join(options.to, exporter.sysdir() + '-resources', 'files.json'), JSON.stringify({ files: files }, null, '\t'));
    }
    for (let callback of ProjectFile_1.Callbacks.preHaxeCompilation) {
        callback();
    }
    return await exportProjectFiles(project.name, path.join(options.to, exporter.sysdir() + '-resources'), options, exporter, kore, korehl, project.icon, project.libraries, project.targetOptions, project.defines, project.cdefines, project.cflags, project.cppflags, project.stackSize, project.version, project.id);
}
function isKhaProject(directory, projectfile) {
    return fs.existsSync(path.join(directory, 'Kha')) || fs.existsSync(path.join(directory, projectfile));
}
async function exportProject(options) {
    if (isKhaProject(options.from, options.projectfile)) {
        return await exportKhaProject(options);
    }
    else {
        log.error('Neither Kha directory nor project file (' + options.projectfile + ') found.');
        return 'Unknown';
    }
}
function runProject(options, name) {
    return new Promise((resolve, reject) => {
        log.info('Running...');
        let run = child_process.spawn(path.join(process.cwd(), options.to, 'linux-build', name), [], { cwd: path.join(process.cwd(), options.to, 'linux') });
        run.stdout.on('data', function (data) {
            log.info(data.toString());
        });
        run.stderr.on('data', function (data) {
            log.error(data.toString());
        });
        run.on('close', function (code) {
            resolve();
        });
    });
}
exports.api = 2;
function findKhaVersion(dir) {
    let p = path.join(dir, '.git');
    let hasGitInfo = false;
    if (fs.existsSync(p)) {
        let stat = fs.statSync(p);
        hasGitInfo = stat.isDirectory();
        // otherwise git might not utilize an in-place directory
        if (!hasGitInfo) {
            let contents = fs.readFileSync(p).toString('utf8', 0, 7);
            hasGitInfo = contents === 'gitdir:';
        }
    }
    if (hasGitInfo) {
        let gitVersion = 'git-error';
        try {
            const output = child_process.spawnSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8', cwd: dir }).output;
            for (const str of output) {
                if (str != null && str.length > 0) {
                    gitVersion = str.substr(0, 8);
                    break;
                }
            }
        }
        catch (error) {
        }
        let gitStatus = 'git-error';
        try {
            const output = child_process.spawnSync('git', ['status', '--porcelain'], { encoding: 'utf8', cwd: dir }).output;
            gitStatus = '';
            for (const str of output) {
                if (str != null && str.length > 0) {
                    gitStatus = str.trim();
                    break;
                }
            }
        }
        catch (error) {
        }
        if (gitStatus) {
            return gitVersion + ', ' + gitStatus.replace(/\n/g, ',');
        }
        else {
            return gitVersion;
        }
    }
    else {
        return '¯\\_(ツ)_/¯';
    }
}
async function run(options, loglog) {
    if (options.silent) {
        log.silent();
    }
    else {
        log.set(loglog);
    }
    if (options.quiet) {
        log.silent(true);
    }
    if (!options.kha) {
        let p = path.join(__dirname, '..', '..', '..');
        if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
            options.kha = p;
        }
    }
    else {
        options.kha = path.resolve(options.kha);
    }
    log.info('Using Kha (' + findKhaVersion(options.kha) + ') from ' + options.kha);
    if (options.parallelAssetConversion === undefined) {
        options.parallelAssetConversion = 0;
    }
    if (!options.haxe) {
        let haxepath = path.join(options.kha, 'Tools', (0, exec_1.sysdir)());
        if (fs.existsSync(haxepath) && fs.statSync(haxepath).isDirectory())
            options.haxe = haxepath;
    }
    if (!options.krafix) {
        let krafixpath = path.join(options.kha, 'Kinc', 'Tools', (0, exec_1.sysdir)(), 'krafix' + (0, exec_1.sys)());
        if (fs.existsSync(krafixpath))
            options.krafix = krafixpath;
    }
    if (!options.kraffiti) {
        const kraffitipath = path.join(options.kha, 'Kinc', 'Tools', (0, exec_1.sysdir)(), 'kraffiti' + (0, exec_1.sys)());
        if (fs.existsSync(kraffitipath))
            options.kraffiti = kraffitipath;
    }
    else {
        log.info('Using kraffiti from ' + options.kraffiti);
    }
    if (!options.ogg && options.ffmpeg) {
        options.ogg = options.ffmpeg + ' -nostdin -i {in} {out} -y';
    }
    if (!options.mp3 && options.ffmpeg) {
        options.mp3 = options.ffmpeg + ' -nostdin -i {in} {out}';
    }
    if (!options.ogg) {
        let oggpath = path.join(options.kha, 'Tools', (0, exec_1.sysdir)(), 'oggenc' + (0, exec_1.sys)());
        if (fs.existsSync(oggpath))
            options.ogg = oggpath + ' {in} -o {out} --quiet';
    }
    if (!options.mp3) {
        let lamepath = path.join(options.kha, 'Tools', (0, exec_1.sysdir)(), 'lame' + (0, exec_1.sys)());
        if (fs.existsSync(lamepath))
            options.mp3 = lamepath + ' {in} {out}';
    }
    // if (!options.kravur) {
    //     let kravurpath = path.join(options.kha, 'Tools', 'kravur', 'kravur' + sys());
    //     if (fs.existsSync(kravurpath)) options.kravur = kravurpath + ' {in} {size} {out}';
    // }
    if (!options.aac && options.ffmpeg) {
        options.aac = options.ffmpeg + ' -nostdin -i {in} {out}';
    }
    if (!options.h264 && options.ffmpeg) {
        options.h264 = options.ffmpeg + ' -nostdin -i {in} {out}';
    }
    if (!options.webm && options.ffmpeg) {
        options.webm = options.ffmpeg + ' -nostdin -i {in} {out}';
    }
    if (!options.wmv && options.ffmpeg) {
        options.wmv = options.ffmpeg + ' -nostdin -i {in} {out}';
    }
    if (!options.theora && options.ffmpeg) {
        options.theora = options.ffmpeg + ' -nostdin -i {in} {out}';
    }
    if (options.target === 'emscripten') {
        console.log();
        console.log('Please note that the html5 target\n'
            + 'is usually a better choice.\n'
            + 'In particular the html5 target usually runs faster\n'
            + 'than the emscripten target. That is because\n'
            + 'Haxe and JavaScript are similar in many ways and\n'
            + 'therefore the html5 target can make direct use of\n'
            + 'all of the optimizations in modern JavaScript\n'
            + 'runtimes. The emscripten target on the other hand\n'
            + 'has to provide its own garbage collector and many\n'
            + 'other performance critical pieces of infrastructure.');
        console.log();
    }
    let name = '';
    try {
        name = await exportProject(options);
    }
    catch (err) {
        for (let callback of ProjectFile_1.Callbacks.onFailure) {
            callback(err);
        }
        throw err;
    }
    for (let callback of ProjectFile_1.Callbacks.postBuild) {
        callback();
    }
    if ((options.target === Platform_1.Platform.Linux || options.target === Platform_1.Platform.FreeBSD) && options.run) {
        await runProject(options, name);
    }
    return name;
}
exports.run = run;
function close() {
    if (lastAssetConverter)
        lastAssetConverter.close();
    if (lastShaderCompiler)
        lastShaderCompiler.close();
    if (lastHaxeCompiler)
        lastHaxeCompiler.close();
}
exports.close = close;
//# sourceMappingURL=main.js.map