#!/usr/bin/env node

var commander = require("commander");
var sourceMap = require("source-map");
var readdir   = require("fs-readdir-recursive");
var mkdirp    = require("mkdirp");
var path      = require("path");
var util      = require("../lib/6to5/util");
var to5       = require("../lib/6to5");
var fs        = require("fs");
var _         = require("lodash");

commander.option("-t, --source-maps-inline", "Append sourceMappingURL comment to bottom of code");
commander.option("-s, --source-maps", "Save source map alongside the compiled code when using --out-file and --out-dir flags");
commander.option("-f, --filename [filename]", "Filename to use when reading from stdin - this will be used in source-maps, errors etc [stdin]", "stdin");
//commander.option("-w, --watch", "Watch, only works with --out-dir");

var list = function (val) {
  return val ? val.split(",") : [];
};

commander.option("-w, --whitelist [whitelist]", "Whitelist", list);
commander.option("-b, --blacklist [blacklist]", "Blacklist", list);
commander.option("-o, --out-file [out]", "Compile all input files into a single file");
commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");

var pkg = require("../package.json");
commander.version(pkg.version);
commander.usage("[options] <files ...>");
commander.parse(process.argv);

//

var errors = [];

var filenames = commander.args;

_.each(filenames, function (filename) {
  if (!fs.existsSync(filename)) {
    errors.push(filename + " doesn't exist");
  }
});

if (commander.outDir && !filenames.length) {
  errors.push("filenames required for --out-dir");
}

if (commander.outFile && commander.outDir) {
  errors.push("cannot have --out-file and --out-dir");
}

if (errors.length) {
  console.error(errors.join(". "));
  process.exit(2);
}

//

var readdirFilter = function (filename) {
  return readdir(filename).filter(util.canCompile);
};

var mainOpts = {
  sourceMapName: commander.outFile,
  blacklist:     commander.blacklist,
  whitelist:     commander.whitelist,
  sourceMap:     commander.sourceMaps || commander.sourceMapsInline
};

var data = [];

var transform = function (filename, code, to) {
  var opts = _.extend({ filename: filename }, mainOpts);
  if (to) opts.sourceMapName = to;

  var result = to5.transform(code, opts);
  result.filename = filename;
  result.actual = code;
  return result;
};

var compile = function (filename, to) {
  var code = fs.readFileSync(filename, "utf8");
  return transform(filename, code, to);
};

if (commander.outDir) {
  if (commander.sourceMapsInline) {
    mainOpts.sourceMap = "inline";
  }

  var write = function (src, relative) {
    var dest = path.join(commander.outDir, relative);

    var data = compile(src, dest);

    var up = path.normalize(dest + "/..");
    mkdirp.sync(up);

    if (commander.sourceMaps) {
      fs.writeFileSync(dest + ".map", JSON.stringify(data.map));
    }

    fs.writeFileSync(dest, data.code);

    console.log(src + " -> " + dest);
  };

  var handle = function (filename) {
    var stat = fs.statSync(filename);

    if (stat.isDirectory(filename)) {
      var dirname = filename;

      _.each(readdirFilter(dirname), function (filename) {
        write(path.join(dirname, filename), filename);
      });
    } else {
      write(filename, filename);
    }
  };

  _.each(filenames, handle);
} else {
  var results = [];

  var finish = function () {
    var map = new sourceMap.SourceMapGenerator({
      file: commander.outFile || "stdout"
    });

    var code = "";
    var offset = 0;

    _.each(results, function (result) {
      var filename = result.filename;
      code += result.code + "\n";

      if (result.map) {
        var consumer = new sourceMap.SourceMapConsumer(result.map);

        map._sources.add(filename);
        map.setSourceContent(filename, result.actual);

        consumer.eachMapping(function (mapping) {
          map._mappings.push({
            generatedLine: mapping.generatedLine + offset,
            generatedColumn: mapping.generatedColumn,
            originalLine: mapping.originalLine,
            originalColumn: mapping.originalColumn,
            source: filename
          });
        });

        offset = code.split("\n").length;
      }
    });

    if (commander.sourceMapsInline || (!commander.outFile && commander.sourceMaps)) {
      code += "\n" + util.sourceMapToComment(map);
    }

    if (commander.outFile) {
      if (commander.sourceMaps) {
        fs.writeFileSync(commander.outFile + ".map", JSON.stringify(map));
      }

      fs.writeFileSync(commander.outFile, code);
    } else {
      console.log(code);
    }
  };

  if (filenames.length) {
    var _filenames = filenames;
    filenames = [];

    _.each(_filenames, function (filename) {
      var stat = fs.statSync(filename);
      if (stat.isDirectory()) {
        var dirname = filename;

        _.each(readdirFilter(filename), function (filename) {
          filenames.push(path.join(dirname, filename));
        });
      } else {
        filenames.push(filename);
      }
    });

    _.each(filenames, function (filename) {
      results.push(compile(filename));
    });

    finish();
  } else {
    var code = "";

    process.stdin.setEncoding("utf8");

    process.stdin.on("readable", function () {
      var chunk = process.stdin.read();
      if (chunk !== null) code += chunk;
    });

    process.stdin.on("end", function() {
      results.push(transform(commander.filename, code));
      finish();
    });
  }
}