.emanate

"use strict";
//sudo emanate --miner --miner-debug

//const KASPA_DEFAULT_BRANCH = 'v0.11.7-dev'; //'master';
const KASPA_DEFAULT_BRANCH = 'master';
const MINER_DEFAULT_BRANCH = 'main';

const E = new Emanator(__dirname, {
    type : argv.includes('build') || flags.innosetup ? 'NODE+NWJS' : 'UTIL',
    guid : 'c1072045-6d98-44d8-9aa5-e9be6c79bd01',
    group : 'Kaspa',
    ident : 'kdx',
    suffix : flags.full ? '-dev' : '',
    title : 'KDX',
    banner : 'KDX',
    git : 'git@github.com:aspectron/kdx',
    author : "ASPECTRON Inc.",
    url : "http://aspectron.com",
    //archive : true,
    folder : true,
    standalone : true,
    production: true,
    //DMG: true,
    nwjs : { version : '0.55.0' },
    resources : 'resources/setup',

    manifest : (manifest) => {
        if(E.flags['with-perfmon'] && !E.flags['no-perfmon']) {
            if(E.PLATFORM != 'macos') {
                Object.assign(manifest.dependencies,{
                    "@aspectron/process-list": "*",
                })
            }
        }

//        if(E.PLATFORM == 'macos')
//            manifest.files.push('apps');

        return manifest;
    },
})

E.flags['with-perfmon'] = true;

if(E.flags.miner){
    E.flags.nonpm = true;
    E.options.nonpm = true;
}

E.aux_dmg_files = async (root) => {
    if(fs.existsSync(path.join(E.BUILD,'apps')))
        await E.copy(path.join(E.BUILD,'apps'),path.join(root,'apps'));

    //    E.copy(process.argv[0], root);
}



const go = await E.modules.go('go1.16.0');
const cargo = await E.modules.cargo('1.59.0');
const git = await E.modules.git();
const gcc = await E.modules.gcc();
const npm = await E.modules.npm({ production : true });




const kaspad = E.task('kaspad', ['origin'], async () => {

    //return true;
    if(E.PLATFORM == 'windows') {
        process.env.PATH = ['C:\\TDM-GCC-64\\bin', ...process.env.PATH.split(';')].join(';');
    }

    let dest = path.join(go.SRC,'github.com/kaspanet/');
    if((E.flags.reset || E.flags.clean) && fs.existsSync(dest))
        await E.emptyDir(dest);

    const branch = E.flags['branch'] || KASPA_DEFAULT_BRANCH || 'master';
    
    console.log('branch:',branch);
    
    //const repos = { };
    const repos = [`kaspad:${branch}`];
    if(E.flags['with-extras']) {
        repos.push(`txgen:${branch}`,`kasparov:${KASPA_DEFAULT_BRANCH}`);
    }

    console.log("REPOS:".brightMagenta,repos);

    for(const repo of repos) {
        let [name, git_branch] = repo.split(':');
        console.log(`git clone https://github.com/kaspanet/${name} branch: ${git_branch || 'master'}`.brightYellow);
        await git.clone(`https://github.com/kaspanet/${name}`,dest, {branch : git_branch || 'master'});
    }

    let targets = [
        'kaspad',
        ...fs.readdirSync(path.join(dest,'kaspad/cmd')).map(f => `kaspad/cmd/${f}`),
    ];


    let rename = {}
    console.log('Starting target processing...')
    let folders = []

    for(let target of targets) {
        let folder = path.join(dest,target);
        console.log('builing',folder);
        await go.build(folder);
        console.log('done',folder);
        folders.push(folder);
    }

    folders.forEach((folder) => {
        let file = path.basename(folder);
        let name = `${E.title} ${file}`;
        let dest = rename[file] || file;
        file += E.PLATFORM_BINARY_EXTENSION;
        dest += E.PLATFORM_BINARY_EXTENSION;

        if(!fs.existsSync(path.join(folder,file))) {
            console.log(`Unable to locate source file: ${path.join(folder,file)}`);
            console.log(`...giving up`);
            process.exit(1);
        }
        console.log("E.copy:", path.join(folder,file)," -> ",path.join(E.BIN,dest))
        E.copy(path.join(folder,file),path.join(E.BIN,dest));
        E.registerFirewallRule({ name, file : dest, binary : true });
    })

    //E.copy(path.join(dest,'kasparov','database','migrations'),path.join(E.BIN,'database','migrations'));
});

const miner = E.task('miner', ['origin'], async () => {

    //return true;
    if(E.PLATFORM == 'windows') {
        process.env.PATH = ['C:\\TDM-GCC-64\\bin', ...process.env.PATH.split(';')].join(';');
    }

    let account = 'aspectron';//'tmrlvi';

    let dest = path.join(cargo.SRCGITHUB, account);
    if((E.flags.reset || E.flags.clean) && fs.existsSync(dest))
        await E.emptyDir(dest);

    const branch = E.flags['miner-branch'] || MINER_DEFAULT_BRANCH || 'main';
    
    console.log('miner branch:', branch);
    console.log('miner dest:', dest);
    
    //const repos = { };
    const repos = [`kaspa-miner:${branch}`];
    console.log("REPOS:".brightMagenta,repos);

    for(const repo of repos) {
        let [name, git_branch] = repo.split(':');
        console.log(`git clone https://github.com/${account}/${name} branch: ${git_branch || 'master'}`.brightYellow);
        await git.clone(`https://github.com/${account}/${name}`, dest, {branch : git_branch || 'master'});
    }

    let minerDest = path.join(dest, "kaspa-miner");
    console.log('Starting miner build processing...')

    let release = !E.flags['miner-debug'];
    let args = {
        release,
        p:['kaspa-miner']
    }

//    if(E.PLATFORM != 'macos'){
//        args.p.push('kaspacuda', 'kaspaopencl');
//        if(E.flags['miner-overclock'])
//            args.features = "default,kaspacuda/overclock";
//    }

    await cargo.build(minerDest, args);
    
    let targetFolder = path.join(minerDest, 'target', release?'release':'debug');

    let file = 'kaspa-miner';
    let name = `${E.title} ${file}`;
    

    file += E.PLATFORM_BINARY_EXTENSION;
    let rename = "gpuminer"+E.PLATFORM_BINARY_EXTENSION;

    let files = new Map();
    files.set(file, rename)

//    if(E.PLATFORM == 'windows'){
//        files.set('kaspacuda.dll', 0)
//        files.set('kaspaopencl.dll', 0)
//    }else if(E.PLATFORM == 'linux'){
//        files.set('kaspacuda.so', 0)
//        files.set('kaspaopencl.so', 0)
//    }

    files.forEach((destName, srcName)=>{
        if(!destName)
            destName = srcName;

        let src = path.join(targetFolder, srcName);
        let dest = path.join(E.BIN, destName);

        //console.log("src", src)
        //console.log("dest", dest)
        
        if(!fs.existsSync(src)) {
            console.log(`Unable to locate source file: ${src}`);
            console.log(`...giving up`);
            process.exit(1);
        }
        
        console.log("E.copy:", src, " -> ", dest)
        E.copy(src, dest);
        E.registerFirewallRule({ name, file : destName, binary : true });
    })


    //E.copy(path.join(dest,'kasparov','database','migrations'),path.join(E.BIN,'database','migrations'));
});

E.task('remote', ['origin'], async () => {

    let files = (E.manifest.files||[]).map(f=>{
        // console.log(E.REPO,'->',E.BUILD, f);
        return E.copy(path.join(E.REPO,f), path.join(E.BUILD, f));
    })
    E.log(`copying ${files.length} items...`);
    await Promise.all(files);

    fs.writeFileSync(path.join(E.BUILD,'i18n.lock'),'');
    console.log(`i18n.lock`);
})

if(!E.flags.miner){
    const aux_deps = E.flags.auxiliary ? ['kaspad','remote'] : ['kaspad', 'miner']
    E.task('done', aux_deps, async () => {
    })
}

E.task('aptitude', null, async () => {
    if(E.PLATFORM != 'linux')
        return;
})

E.flags.docker && E.task('docker', null, async () => {

    E.manifest_read();

    const relay = ['no-cache'];
    const args = ['-s','docker','build'].concat(relay.map(k=>E.flags[k]?`--${k}`:null)).filter(v=>v);
    args.push('-t',`kdx:latest`,'.');
    const ts0 = Date.now();
    await E.utils.spawn('sudo', args, { cwd : __dirname, stdio: 'inherit' });
    await E.utils.spawn('sudo',['docker','tag','kdx:latest',`kdx:${E.manifest.version}`], { cwd : __dirname, stdio: 'inherit' });
    console.log('Docker build complete at',new Date());
    const ts1 = Date.now();
    console.log('Docker build took'.brightBlue,`${((ts1-ts0)/1000/60).toFixed(1)}`.brightWhite,'minutes'.brightBlue)
});

if(E.flags.i18n){
    E.task('i18n', null, async () => {
        E.utils.sortAndSaveI18nFiles();
        E.utils.mergeI18nEntries2Data();
    })
}


if(E.flags['local-binaries'] || E.flags['kaspa'] || E.flags.miner) {
    E.BIN = path.join(E.appFolder,'bin', E.PLATFORM_ARCH);
    mkdirp.sync(E.BIN);
}


if(E.flags.link) {
    let list = ['flow-ux','flow-app','flow-utils','flow-rpc','flow-async'];
    while(list.length) {
        let ident = list.shift();
        await npm.link(`@aspectron/${ident}`, { cwd : __dirname, stdio : 'inherit' });
    }
}
else if(E.flags.docker) {
    E.runTask('docker');
}else if(E.flags.i18n) {
    E.runTask('i18n');
}else if(E.flags['kaspa']) {
    await kaspad();
}else if(E.flags.miner){
    await miner();
}
else if(E.flags['local-binaries']) {
    E.runTask('kaspad');
    E.runTask('aptitude');
}
else
    E.run();