#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Commander = require("commander");
const engine_1 = require("./engine");
const Case = require("../../case/src");
const Utils = require("../../util/src");
const pkg = require('../../../package.json');
Commander.version(`${pkg.version}`);
Commander
    .command('build')
    .description('编译工程')
    .option('-p, --path <v>', '目标工程路径')
    .option('-d, --dist <v>', '编译结果路径')
    .option('-a, --all <v>', '批量将同一文件夹下的所有Cube有效工程进行编译，编译结果将存放到每个工程的dist目录下')
    .action(cmd => {
    if (cmd.all) {
        engine_1.AntCube.pack.buildAllProjects(cmd.all).then(value => {
            Utils.Console.info(`all done!`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`${reason}`);
            process.exit(1);
        });
    }
    else {
        engine_1.AntCube.pack.buildProject(cmd.path, cmd.dist).then(value => {
            if (value.success) {
                Utils.Console.info('success');
                process.exit(0);
            }
            else {
                Utils.Console.error(`${value.message}`);
                process.exit(1);
            }
        }).catch(reason => {
            Utils.Console.error(`build project failure\n${reason.message}`);
            process.exit(1);
        });
    }
});
Commander
    .command('runcase')
    .description('执行用例')
    .option('-c, --case <v>', 'case所在工程根目录，支持将多个工程放置在同一个目录下批量处理')
    .option('-d, --device <v>', '运行case的设备ID')
    .option('-o, --output', '用例执行完成后保存用例结果')
    .option('-p, --portrait', '用例执行完成后保存基线信息')
    .option('-t, --tiny', '是否为小程序工程，不支持批量处理能力')
    .action(cmd => {
    Utils.Console.info(`***********
    用例工程(必要) : ${cmd.case}
    设备ID(必要) : ${cmd.device}
    保存用例结果 : ${cmd.output ? 'true' : 'false'}
    保存基线信息 : ${cmd.portrait ? 'true' : 'false'}
    导出到VSCode : ${cmd.vscode ? 'true' : 'false'}
        `);
    if (cmd.case && cmd.device) {
        let mode = Case.Mode.None;
        mode = cmd.output ? (mode | Case.Mode.Output) : mode;
        mode = cmd.portrait ? (mode | Case.Mode.Portrait) : mode;
        Case.iOS.run(cmd.case, mode, cmd.device, cmd.tiny).then(value => {
            Utils.Console.info(`用例执行完成`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`用例执行失败 : ${reason}`);
            process.exit(2);
        });
    }
    else {
        Utils.Console.error(`缺少必要参数`);
        process.exit(1);
    }
});
Commander
    .command('buildcase')
    .description('构建用例')
    .option('-b, --build <v>', 'case所在工程根目录，支持将多个工程放置在同一个目录下批量处理')
    .option('-t, --tiny', '是否为小程序工程，不支持批量处理能力')
    .action(cmd => {
    Utils.Console.info(`***********
    用例工程(必要) : ${cmd.build}
        `);
    if (!cmd.build) {
        Utils.Console.error(`缺少必要参数`);
        process.exit(2);
    }
    if (cmd.tiny) {
        Case.buildTinyCases(cmd.build).then(value => {
            Utils.Console.info(`用例构造完成`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`用例构建失败 : ${reason}`);
            process.exit(1);
        });
    }
    else {
        Case.buildCases(cmd.build).then(value => {
            Utils.Console.info(`用例构造完成`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`用例构建失败 : ${reason}`);
            process.exit(1);
        });
    }
});
Commander
    .command('installcase')
    .description('装载用例')
    .option('-i, --install-case <v>', 'case所在工程根目录，支持将多个工程放置在同一个目录下批量处理')
    .option('-I, --install-cube <v>', 'cubekit仓库根目录或者安装包路径')
    .option('-t, --tiny', '是否为小程序工程，不支持批量处理能力')
    .action(cmd => {
    Utils.Console.info(`***********
    用例工程(必要) : ${cmd.installCase}
    目标路径(必要) : ${cmd.installCube}
        `);
    if (!cmd.installCase || !cmd.installCube) {
        Utils.Console.error(`缺少必要参数`);
        process.exit(1);
    }
    Case.install(cmd.installCase, cmd.installCube, cmd.tiny).then(value => {
        Utils.Console.info(`用例导入完成`);
        process.exit(0);
    }).catch(reason => {
        Utils.Console.error(`用例导入失败 : ${reason}`);
        process.exit(2);
    });
});
Commander
    .command('pickcase')
    .description('提取用例执行结果到vscode，使用期需先连接vscode')
    .option('-d, --device <v>', '运行case的设备ID')
    .action(cmd => {
    if (!cmd.device) {
        Utils.Console.error(`缺少必要参数`);
        process.exit(1);
    }
    Case.iOS.pick(cmd.device).then(value => {
        Utils.Console.info(`已发送提取指令`);
        process.exit(0);
    }).catch(reason => {
        Utils.Console.error(`提取结果失败 : ${reason}`);
        process.exit(2);
    });
});
Commander
    .command('updatebaseline')
    .description('更新基线')
    .option('-b, --baseline <v>', '基线sql文件所在目录，支持将多个基线sql文件放置到同一个目录下批量执行')
    .option('-c, --cube <v>', 'cubekit仓库根目录或者安装包路径')
    .action(cmd => {
    Utils.Console.info(`***********
    基线目录(必要) : ${cmd.baseline}
    目标路径(必要) : ${cmd.cube}
        `);
    if (!cmd.baseline || !cmd.cube) {
        Utils.Console.error(`缺少必要参数`);
        process.exit(1);
    }
    Case.update4baseline(cmd.baseline, cmd.cube).then(value => {
        Utils.Console.info(`基线更新完成`);
        process.exit(0);
    }).catch(reason => {
        Utils.Console.error(`基线更新失败 : ${reason}`);
        process.exit(2);
    });
});
Commander
    .command('casereport')
    .description('用例执行结果报告')
    .option('-p, --path <v>', '用例结果文件路径')
    .action(cmd => {
    if (cmd.path) {
        Utils.Console.info(`开始处理 [${cmd.path}] ...`);
        Case.report(cmd.path).then(value => {
            Utils.Console.info(`提取报告完成，详情请查看桌面 RubikCaseReport.md 文件`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`提取报告失败 : ${reason}`);
            process.exit(1);
        });
    }
    else {
        Utils.Console.error(`缺少必要参数`);
        process.exit(2);
    }
});
Commander
    .command('caseclean')
    .description('清理工程目录内的.rcase用例文件')
    .option('-p, --path <v>', '待清理工程路径')
    .option('-t, --tiny', '是否为小程序工程')
    .action(cmd => {
    if (cmd.path) {
        Utils.Console.info(`开始清理 [${cmd.path}] ...`);
        Case.clean(cmd.pack, cmd.tiny).then(value => {
            Utils.Console.info(`清理完成`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`清理失败 : ${reason}`);
            process.exit(1);
        });
    }
    else {
        Utils.Console.error(`缺少必要参数`);
        process.exit(2);
    }
});
Commander
    .command('wpt')
    .description('整理WPT用例集')
    .option('-p, --path <v>', '文件夹路径')
    .action(cmd => {
    if (cmd.path) {
        Utils.Console.info(`开始处理 [${cmd.path}] ...`);
        Case.WPT.adapter(cmd.path).then(value => {
            Utils.Console.info(`适配完成`);
            process.exit(0);
        }).catch(reason => {
            Utils.Console.error(`适配失败 : ${reason}`);
            process.exit(1);
        });
    }
    else {
        Utils.Console.error(`缺少必要参数`);
        process.exit(2);
    }
});
Commander.parse(process.argv);
//# sourceMappingURL=cli.js.map