#! /usr/bin/env node
// -*- js -*-

"use strict";

var UglifyJS = require("../tools/node");
var sys = require("util");
var optimist = require("optimist");
var fs = require("fs");
var acorn;
var ARGS = optimist
    .usage("$0 input1.js [input2.js ...] [options]\n\
Use a single dash to read input from the standard input.\
\n\n\
NOTE: by default there is no mangling/compression.\n\
Without [options] it will simply parse input files and dump the AST\n\
with whitespace and comments discarded.  To achieve compression and\n\
mangling you need to use `-c` and `-m`.\
")
    .describe("source-map", "Specify an output file where to generate source map.")
    .describe("source-map-root", "The path to the original source to be included in the source map.")
    .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
    .describe("p", "Skip prefix for original filenames that appear in source maps. \
For example -p 3 will drop 3 directories from file names and ensure they are relative paths.")
    .describe("o", "Output file (default STDOUT).")
    .describe("b", "Beautify output/specify output options.")
    .describe("m", "Mangle names/pass mangler options.")
    .describe("r", "Reserved names to exclude from mangling.")
    .describe("c", "Enable compressor/pass compressor options. \
Pass options like -c hoist_vars=false,if_return=false. \
Use -c with no argument to use the default compression options.")
    .describe("d", "Global definitions")

    .describe("comments", "Preserve copyright comments in the output. \
By default this works like Google Closure, keeping JSDoc-style comments that contain \"@license\" or \"@preserve\". \
You can optionally pass one of the following arguments to this flag:\n\
- \"all\" to keep all comments\n\
- a valid JS regexp (needs to start with a slash) to keep only comments that match.\n\
\
Note that currently not *all* comments can be kept when compression is on, \
because of dead code removal or cascading statements into sequences.")

    .describe("stats", "Display operations run time on STDERR.")
    .describe("acorn", "Use Acorn for parsing.")
    .describe("spidermonkey", "Assume input fles are SpiderMonkey AST format (as JSON).")
    .describe("self", "Build itself (UglifyJS2) as a library (implies --wrap=UglifyJS --export-all)")
    .describe("wrap", "Embed everything in a big function, making the “exports” and “global” variables available. \
You need to pass an argument to this option to specify the name that your module will take when included in, say, a browser.")
    .describe("export-all", "Only used when --wrap, this tells UglifyJS to add code to automatically export all globals.")
    .describe("v", "Verbose")

    .alias("p", "prefix")
    .alias("o", "output")
    .alias("v", "verbose")
    .alias("b", "beautify")
    .alias("m", "mangle")
    .alias("c", "compress")
    .alias("d", "define")
    .alias("r", "reserved")

    .string("source-map")
    .string("source-map-root")
    .string("b")
    .string("m")
    .string("c")
    .string("d")
    .string("comments")
    .string("wrap")
    .boolean("export-all")
    .boolean("self")
    .boolean("v")
    .boolean("stats")
    .boolean("acorn")
    .boolean("spidermonkey")

    .wrap(80)

    .argv
;

if (ARGS.h || ARGS.help) {
    sys.puts(optimist.help());
    process.exit(0);
}

if (ARGS.acorn) {
    acorn = require("acorn");
}

normalize(ARGS);

var COMPRESS = getOptions("c");
var MANGLE = getOptions("m");
var BEAUTIFY = getOptions("b");

if (COMPRESS && ARGS.d) {
    COMPRESS.global_defs = getOptions("d");
}

if (MANGLE && ARGS.r) {
    MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
}

var OUTPUT_OPTIONS = {
    beautify: BEAUTIFY ? true : false
};

if (BEAUTIFY)
    UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY);

if (ARGS.comments) {
    if (/^\//.test(ARGS.comments)) {
        OUTPUT_OPTIONS.comments = new Function("return(" + ARGS.comments + ")")();
    } else if (ARGS.comments == "all") {
        OUTPUT_OPTIONS.comments = true;
    } else {
        OUTPUT_OPTIONS.comments = function(node, comment) {
            var text = comment.value;
            var type = comment.type;
            if (type == "comment2") {
                // multiline comment
                return text.indexOf("@preserve") >= 0
                    || text.indexOf("@license") >= 0;
            }
        }
    }
}

var files = ARGS._.slice();

if (ARGS.self) {
    if (files.length > 0) {
        sys.error("WARN: Ignoring input files since --self was passed");
    }
    files = UglifyJS.FILES;
    if (!ARGS.wrap) ARGS.wrap = "UglifyJS";
    ARGS.export_all = true;
}

var ORIG_MAP = ARGS.in_source_map;

if (ORIG_MAP) {
    ORIG_MAP = JSON.parse(fs.readFileSync(ORIG_MAP));
    if (files.length == 0) {
        sys.error("INFO: Using file from the input source map: " + ORIG_MAP.file);
        files = [ ORIG_MAP.file ];
    }
    if (ARGS.source_map_root == null) {
        ARGS.source_map_root = ORIG_MAP.sourceRoot;
    }
}

if (files.length == 0) {
    files = [ "-" ];
}

if (files.indexOf("-") >= 0 && ARGS.source_map) {
    sys.error("ERROR: Source map doesn't work with input from STDIN");
    process.exit(1);
}

if (files.filter(function(el){ return el == "-" }).length > 1) {
    sys.error("ERROR: Can read a single file from STDIN (two or more dashes specified)");
    process.exit(1);
}

var STATS = {};
var OUTPUT_FILE = ARGS.o;
var TOPLEVEL = null;

var SOURCE_MAP = ARGS.source_map ? UglifyJS.SourceMap({
    file: OUTPUT_FILE,
    root: ARGS.source_map_root,
    orig: ORIG_MAP,
}) : null;

OUTPUT_OPTIONS.source_map = SOURCE_MAP;

try {
    var output = UglifyJS.OutputStream(OUTPUT_OPTIONS);
    var compressor = COMPRESS && UglifyJS.Compressor(COMPRESS);
} catch(ex) {
    if (ex instanceof UglifyJS.DefaultsError) {
        sys.error(ex.msg);
        sys.error("Supported options:");
        sys.error(sys.inspect(ex.defs));
        process.exit(1);
    }
}

files.forEach(function(file) {
    var code = read_whole_file(file);
    if (ARGS.p != null) {
        file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/");
    }
    time_it("parse", function(){
        if (ARGS.spidermonkey) {
            var program = JSON.parse(code);
            if (!TOPLEVEL) TOPLEVEL = program;
            else TOPLEVEL.body = TOPLEVEL.body.concat(program.body);
        }
        else if (ARGS.acorn) {
            TOPLEVEL = acorn.parse(code, {
                locations     : true,
                trackComments : true,
                sourceFile    : file,
                program       : TOPLEVEL
            });
        }
        else {
            TOPLEVEL = UglifyJS.parse(code, {
                filename: file,
                toplevel: TOPLEVEL
            });
        };
    });
});

if (ARGS.acorn || ARGS.spidermonkey) time_it("convert_ast", function(){
    TOPLEVEL = UglifyJS.AST_Node.from_mozilla_ast(TOPLEVEL);
});

if (ARGS.wrap) {
    TOPLEVEL = TOPLEVEL.wrap_commonjs(ARGS.wrap, ARGS.export_all);
}

var SCOPE_IS_NEEDED = COMPRESS || MANGLE;

if (SCOPE_IS_NEEDED) {
    time_it("scope", function(){
        TOPLEVEL.figure_out_scope();
    });
}

if (COMPRESS) {
    time_it("squeeze", function(){
        TOPLEVEL = TOPLEVEL.transform(compressor);
    });
}

if (SCOPE_IS_NEEDED) {
    time_it("scope", function(){
        TOPLEVEL.figure_out_scope();
        if (MANGLE) {
            TOPLEVEL.compute_char_frequency();
            UglifyJS.base54.sort();
        }
    });
}

if (MANGLE) time_it("mangle", function(){
    TOPLEVEL.mangle_names(MANGLE);
});
time_it("generate", function(){
    TOPLEVEL.print(output);
});

output = output.get();

if (SOURCE_MAP) {
    fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
    output += "\n//@ sourceMappingURL=" + ARGS.source_map;
}

if (OUTPUT_FILE) {
    fs.writeFileSync(OUTPUT_FILE, output, "utf8");
} else {
    sys.print(output);
    sys.error("\n");
}

if (ARGS.stats) {
    sys.error(UglifyJS.string_template("Timing information (compressed {count} files):", {
        count: files.length
    }));
    for (var i in STATS) if (STATS.hasOwnProperty(i)) {
        sys.error(UglifyJS.string_template("- {name}: {time}s", {
            name: i,
            time: (STATS[i] / 1000).toFixed(3)
        }));
    }
}

/* -----[ functions ]----- */

function normalize(o) {
    for (var i in o) if (o.hasOwnProperty(i) && /-/.test(i)) {
        o[i.replace(/-/g, "_")] = o[i];
        delete o[i];
    }
}

function getOptions(x) {
    x = ARGS[x];
    if (!x) return null;
    var ret = {};
    if (x !== true) {
        x.replace(/^\s+|\s+$/g).split(/\s*,+\s*/).forEach(function(opt){
            var a = opt.split(/\s*[=:]\s*/);
            ret[a[0]] = a.length > 1 ? new Function("return(" + a[1] + ")")() : true;
        });
        normalize(ret);
    }
    return ret;
}

function read_whole_file(filename) {
    if (filename == "-") {
        // XXX: this sucks.  How does one read the whole STDIN
        // synchronously?
        filename = "/dev/stdin";
    }
    try {
        return fs.readFileSync(filename, "utf8");
    } catch(ex) {
        sys.error("ERROR: can't read file: " + filename);
        process.exit(1);
    }
}

function time_it(name, cont) {
    var t1 = new Date().getTime();
    var ret = cont();
    if (ARGS.stats) {
        var spent = new Date().getTime() - t1;
        if (STATS[name]) STATS[name] += spent;
        else STATS[name] = spent;
    }
    return ret;
}