function inspectApp(args: Array<string>): void {
    var parser = new argparse.ArgumentParser({
        prog: "meminsight inspect",
        addHelp: true,
        description: "inspect results of a previous profiling run"
    });
    parser.addArgument(['path'], { help:"directory of instrumented app" });
    var parsed = parser.parseArgs(args);
    var appPath = parsed.path;

    console.log("inspecting previous run of app " + appPath);
    if (!fs.existsSync(appPath)) {
        console.error("path " + appPath + " does not exist");
        process.exit(1);
    }
    // in order to inspect, we must have a staleness.json and
    // enhanced-trace file present
    var stalenessTrace = path.join(appPath, 'staleness-trace');
    if (!fs.existsSync(stalenessTrace)) {
        console.error("no staleness trace from previous run present; exiting");
        process.exit(1);
    }
    // OK, we have the files.  run the GUI server
    var cliArgs = [
        path.join(__dirname, '..', 'lib', 'gui', 'guiServer.js'),
        appPath
    ];
    runNodeProg(cliArgs, "inspect of app ");
}

function instrumentApp(args: Array<string>): void {
    var parser = new argparse.ArgumentParser({
        prog: "meminsight instrument",
        addHelp: true,
        description: "instrument a local application"
    });
    parser.addArgument(['--outputDir'], { help:"directory in which to place instrumented files and traces.  " +
    "We create a new sub-directory for our output.", defaultValue: "/tmp" });
    parser.addArgument(['--only_include'], { help:"list of path prefixes specifying which sub-directories should be instrumented, separated by path.delimiter"});
    parser.addArgument(['path'], { help:"directory of app to instrument" });
    var parsed = parser.parseArgs(args);
    var appPath = parsed.path;
    var outputDir = parsed.outputDir;

    console.log("instrumenting app " + appPath);
    if (!fs.existsSync(appPath)) {
        console.error("path " + appPath + " does not exist");
        process.exit(1);
    }
    var cliArgs = [
        path.join(__dirname, 'memTraceDriver.js'),
        '--justGenerate',
        '--verbose',
        '--outputDir',
        outputDir
    ];
    if (parsed.only_include) {
        cliArgs.push('--only_include', parsed.only_include);
    }
    cliArgs.push(appPath);
    runNodeProg(cliArgs, "instrumentation");
}

/**
 * run memory analysis on node script using on-the-fly instrumentation
 * @param args
 */
function instAndRunNodeScript(args: Array<string>): void {
    var parser = new argparse.ArgumentParser({
        prog: "meminsight nodeinstrun",
        addHelp: true,
        description: "instrument a node.js script as it runs and collect profiling results"
    });
    parser.addArgument(['script'], { help: "path of script to run, relative to appPath"});
    parser.addArgument(['scriptArgs'], {
        help: "command-line arguments to pass to script",
        nargs: argparse.Const.REMAINDER
    });
    var parsed = parser.parseArgs(args);
    var script = path.resolve(parsed.script);
    var scriptArgs = parsed.scriptArgs;
    // dump traces in same directory as the instrumented script
    // TODO make this configurable
    var appPath = path.dirname(script);
    var curDir = process.cwd();
    process.chdir(appPath);
    console.log("running node.js script " + script);
    var loggingAnalysisArgs = [
        onTheFlyDriver,
        '--inlineIID',
        '--analysis',
        loggingAnalysis,
        '--initParam',
        'syncFS:true',
        '--astHandlerModule',
        path.join(__dirname, '..', 'lib', 'analysis', 'freeVarsAstHandler.js'),
        script].concat(scriptArgs);
    runNodeProg(loggingAnalysisArgs, "run of script ", (code: number) => {
        if (code !== 0) {
            console.log("run of script failed");
            return;
        }
        console.log("run of script complete");
        // run the lifetime analysis
        var javaProc = lifetimeAnalysis.runLifetimeAnalysisOnTrace(path.join(appPath,'mem-trace'));
        javaProc.stdout.on("data", (chunk : any) => {
            console.log(chunk.toString());
        });
        javaProc.stderr.on("data", (chunk : any) => {
            console.error(chunk.toString());
        });
        javaProc.on("exit", () => {
            console.log("done with lifetime analysis");
        });

    });

}

function runApp(args: Array<string>): void {
    var parser = new argparse.ArgumentParser({
        prog: "meminsight run",
        addHelp: true,
        description: "run an instrumented web app and collect profiling results"
    });
    parser.addArgument(['path'], { help:"directory of instrumented app" });
    var parsed = parser.parseArgs(args);
    var appPath = parsed.path;
    console.log("running app " + appPath);
    if (!fs.existsSync(appPath)) {
        console.error("path " + appPath + " does not exist");
        process.exit(1);
    }
    var cliArgs = [
        path.join(__dirname, '..', 'lib', 'server', 'server.js'),
        appPath
    ];
    runNodeProg(cliArgs, "run of app ");
}

var javaProc : cp.ChildProcess;
var outputStream: fs.WriteStream;


/**
 * utility function used by the websocket server.
 * currently does nothing
 */
function originIsAllowed(origin: string) {
    // put logic here to detect whether the specified origin is allowed.
    return true;
}

var argparse = require('argparse');
var parser = new argparse.ArgumentParser({
    addHelp: true,
    description: "Integrated server for memory profiler"
});
parser.addArgument(['--proxy'], { help: "run as a proxy server, instrumenting code on-the-fly", action:'storeTrue' });
parser.addArgument(['--proxyOutput'], { help: "in proxy server mode, directory under which to store instrumented code", defaultValue: '/tmp/proxyOut' });
parser.addArgument(['--noHTTPServer'], { help: "don't start up a local HTTP server", action: 'storeTrue'});
parser.addArgument(['--outputFile'], { help: "name for output file for memory trace (default mem-trace in app directory)" });
parser.addArgument(['app'], { help: "the app to serve.  in proxy mode, the app should be uninstrumented.", nargs: 1});
var args: { proxy: string; proxyOutput: string; noHTTPServer: string; app: Array<string>; outputFile: string; } = parser.parseArgs();

var app = args.app[0];

// default to app directory; we'll change it in proxy server mode
var outputDir = app;

/**
 * create a fresh directory in which to dump instrumented scripts

    });
  }
  // tslint:disable-next-line:no-empty
  catch (ex) {}

  if (ret !== undefined) {
    return ret;
  }

  throw new Fatal(`cannot parse ${name}`);
}

const parser = new ArgumentParser({
  addHelp: true,
  description: "Generates a JSON file suitable for using as the " +
    "``metadata`` option for a generic Meta object. The input file must " +
    "be a JSON file in the format produced by TEI's odd2json.xsl " +
    "transformation.",
});

parser.addArgument(["input"],
                   { help: "Input file." });

parser.addArgument(["output"], {
  help: "Output file. If absent, outputs to stdout.",
  nargs: "?",
});

parser.addArgument(["--tei"], {
  help: "Treat the input as a TEI JSON file produced by TEI's odd2json.xsl.",
  action: "storeTrue",

// near copy of each of the tests from https://github.com/nodeca/argparse/tree/master/examples

import {ArgumentParser, RawDescriptionHelpFormatter} from 'argparse';
var args: any;

var simpleExample = new ArgumentParser({
  version: '0.0.1',
  addHelp: true,
  description: 'Argparse example',
});
simpleExample.addArgument(
  ['-f', '--foo'],
  {
    help: 'foo bar',
  }
);
simpleExample.addArgument(
  ['-b', '--bar'],
  {
    help: 'bar foo',
  }
);

simpleExample.printHelp();
console.log('-----------');

args = simpleExample.parseArgs('-f 1 -b2'.split(' '));
console.dir(args);
console.log('-----------');
args = simpleExample.parseArgs('-f=3 --bar=4'.split(' '));

///<reference path='../lib/ts-declarations/jalangi.d.ts' />
///<reference path='../lib/ts-declarations/mkdirp.d.ts' />
///<reference path='../lib/ts-declarations/wrench.d.ts' />

/**
 * Created by m.sridharan on 6/16/14.
 */

import mkdirp = require('mkdirp');
import path = require('path');
import fs = require('fs');
import memTracer = require('../lib/analysis/memTraceAPI');
import Q = require('q');
var argparse = require('argparse');
var parser = new argparse.ArgumentParser({
    addHelp: true,
    description: "Command-line utility to generate memory trace"
});
parser.addArgument(['--debugFun'], { help: "function name for debug logging" });
parser.addArgument(['--only_include'], { help:"list of path prefixes specifying which sub-directories should be instrumented, separated by path.delimiter"});
parser.addArgument(['--syncAjax'], { help: "use synchronous AJAX calls for logging", action:'storeTrue' });
parser.addArgument(['--outputDir'], { help:"directory in which to place instrumented files and traces.  " +
                                           "We create a new sub-directory for our output.", required:true });
parser.addArgument(['--justGenerate'], { help: "just instrument and generate metadata, but don't produce mem-trace", action: 'storeTrue'});
parser.addArgument(['--verbose'], { help: "print verbose output", action:'storeTrue'});
parser.addArgument(['inputFile'], { help:"Either a JavaScript file or an HTML app directory with an index.html file" });
var args = parser.parseArgs();
var outputDir:string = args.outputDir;

var jsFile: boolean = !fs.statSync(args.inputFile).isDirectory();
var promise : Q.Promise<any>, trueOutputDir: string;
if (jsFile) {

module.exports.parseArgs = function() {
  const parser = new ArgumentParser({
    version: pjson.version,
    addHelp: true,
    description: 'BitGo-Express'
  });

  parser.addArgument(['-p', '--port'], {
    defaultValue: 3080,
    type: 'int',
    help: 'Port to listen on'
  });

  parser.addArgument(['-b', '--bind'], {
    defaultValue: 'localhost',
    help: 'Bind to given address to listen for connections (default: localhost)'
  });

  parser.addArgument(['-e', '--env'], {
    defaultValue: 'test',
    help: 'BitGo environment to proxy against (prod, test)'
  });

  parser.addArgument(['-d', '--debug'], {
    action: 'appendConst',
    dest: 'debugnamespace',
    constant: 'bitgo:express',
    help: 'Enable basic debug logging for incoming requests'
  });

  parser.addArgument(['-D', '--debugnamespace'], {
    action: 'append',
    help: 'Enable a specific debugging namespace for more fine-grained debug output. May be given more than once.'
  });

  parser.addArgument(['-k', '--keypath'], {
    help: 'Path to the SSL Key file (required if running production)'
  });

  parser.addArgument(['-c', '--crtpath'], {
    help: 'Path to the SSL Crt file (required if running production)'
  });

  parser.addArgument( ['-u', '--customrooturi'], {
    defaultValue: process.env.BITGO_CUSTOM_ROOT_URI,
    help: 'Force custom root BitGo URI (e.g. https://test.bitgo.com)'
  });

  parser.addArgument(['-n', '--custombitcoinnetwork'], {
    defaultValue: process.env.BITGO_CUSTOM_BITCOIN_NETWORK,
    help: 'Force custom bitcoin network (e.g. testnet)'
  });

  parser.addArgument(['-l', '--logfile'], {
    help: 'Filepath to write the access log'
  });

  parser.addArgument(['--disablessl'], {
    action: 'storeTrue',
    help: 'Allow running against production in non-SSL mode (at your own risk!)'
  });

  parser.addArgument(['--disableproxy'], {
    action: 'storeTrue',
    help: 'disable the proxy, not routing any non-express routes'
  });

  parser.addArgument(['--disableenvcheck'], {
    action: 'storeTrue',
    defaultValue: true, // BG-9584: temporarily disable env check while we give users time to react to change in runtime behavior
    help: 'disable checking for proper NODE_ENV when running in prod environment'
  });

  parser.addArgument(['-t', '--timeout'], {
    defaultValue: (process.env.BITGO_TIMEOUT as any) * 1000 || DEFAULT_TIMEOUT,
    help: 'Proxy server timeout in milliseconds'
  });

  return parser.parseArgs();
};

export function parseArgs(args?: string[]):
    {appDir: string, runtimeImage: string} {
  const parsedArgs = PARSER.parseArgs(args);
  return {
    appDir: parsedArgs.app_dir[0],
    runtimeImage: parsedArgs.runtime_image[0]
  };
}