#!/usr/bin/env node

var mapshaper = require("../"),
    Node = mapshaper.Node,
    Utils = mapshaper.Utils,
    opts = mapshaper.getOpts(),
    inputList = opts.input_files;

mapshaper.LOGGING = true;
mapshaper.T.start("Start timing");

// need to use a callback if joining a file, because csv parser is asynchronous
if (opts.join_file) {
  mapshaper.importJoinTable(opts.join_file, opts, function(table) {
    opts.join_table = table;
    procFiles(inputList, opts);
  });
} else {
  procFiles(inputList, opts);
}

function procFiles(files, opts) {
  var mergedData, mergedName;
  if (opts.merge_files || opts.combine_files) {
    if (opts.merge_files) {
      mergedName = mapshaper.getMergedFileBase(files, "merged");
      mergedData = mapshaper.mergeFiles(files, opts);
    } else {
      mergedName = mapshaper.getMergedFileBase(files, "") || "combined";
      mergedData =  mapshaper.mergeFiles(files, opts, true);
    }
    if (!opts.output_file_base) {
      opts.output_file_base = mergedName;
    }
    procLayers(mergedData, opts);
  } else {
    Utils.forEach(files, function(ifile) {
      var fileOpts = Utils.extend({}, opts); // copy common options
      if (!fileOpts.output_file_base) {
        fileOpts.output_file_base = Node.getFileInfo(ifile).base;
      }
      var data = mapshaper.importFromFile(ifile, fileOpts);
      procLayers(data, fileOpts);
    });
  }
  mapshaper.T.stop("Total time");
}

function procLayers(importData, opts) {
  var arcData = importData.arcs,
      layers = importData.layers,
      bounds = arcData.getBounds();

  // Update input/output format with information found during importing
  // (command line info is insufficient to distinguish topojson and geojson)
  opts.input_format = opts.input_format || importData.info.input_format;
  opts.output_format = opts.output_format || opts.input_format;

  if (opts.join_table) {
    mapshaper.joinTableToLayers(layers, opts.join_table, opts.join_keys, opts.join_fields);
    // kludge to let join table be gc'd
    if (inputList.length == 1) opts.join_table = null;
  }

  if (!opts.input_format) error("Unknown input file format");

  if (opts.use_simplification) {
    mapshaper.simplifyPaths(arcData, opts.simplify_method, opts.force2D);

    if (opts.keep_shapes) {
      mapshaper.protectShapes(arcData, layers);
    }

    if (Utils.isNumber(opts.simplify_pct)) {
      arcData.setRetainedPct(opts.simplify_pct);
    } else if (opts.simplify_interval) {
      arcData.setRetainedInterval(opts.simplify_interval);
    }

    if (opts.repair) {
      var xxInfo = mapshaper.findAndRepairIntersections(arcData);
      mapshaper.cli.printRepairMessage(xxInfo, opts);
    }
  }

  if (opts.filter) {
    mapshaper.filterLayers(layers, arcData, opts.filter);
  }

  if (opts.expression) {
    mapshaper.evaluateLayers(layers, arcData, opts.expression);
  }

  /*
  // need to handle holes correctly before enabling this
  if (opts.explode) {
    mapshaper.explodeLayers(layers, arcData);
  }
  */

  if (opts.split) {
    layers = mapshaper.splitLayersOnField(layers, arcData, opts.split);
  }

  if (opts.subdivide) {
    layers = mapshaper.subdivideLayers(layers, arcData, opts.subdivide);
  }

  if (opts.dissolve) {
    layers = mapshaper.dissolveLayers(layers, arcData, opts.dissolve, opts);
  }

  if (opts.postfilter) {
    mapshaper.filterLayers(layers, arcData, opts.postfilter);
  }

  if (opts.innerlines) {
    layers = mapshaper.convertLayersToInnerLines(layers, arcData);
  } else if (opts.lines) {
    layers = mapshaper.convertLayersToTypedLines(layers, arcData, opts.lines);
  }

  // filter && merge arcs if outputting topojson and arcs may have changed
  // TODO: decide if this belongs here or in topojson output function
  if (opts.output_format == 'topojson' && (opts.innerlines || opts.dissolve)) {
    arcData = mapshaper.dissolveArcs(layers, arcData);
  }

  if (opts.recombine) {
    layers = [mapshaper.recombineLayers(layers)];
  }

  if (opts.split_rows && opts.split_cols) {
    if (layers.length != 1) error("Split-on-grid expects one layer");
    layers = mapshaper.splitOnGrid(layers[0], arcData, opts.split_rows, opts.split_cols);
    // TODO: find sensible way of generating topojson with multiple layer-objects
    // (e.g. --topojson-merge option
    opts.topojson_divide = true;
  }

  var exports = mapshaper.exportContent(layers, arcData, opts);

  // Copy prj file, if both importing and exporting as shapefile
  // TODO: move this elsewhere
  if (opts.output_format == 'shapefile' && opts.input_format == 'shapefile') {
    var prjFile = mapshaper.cli.replaceFileExtension(importData.info.input_files[0], 'prj'),
        shpFiles = Utils.filter(exports, function(o) {return o.extension == 'shp'});

    if (Node.fileExists(prjFile)) {
      Utils.forEach(shpFiles, function(o) {
        exports.push({
          content: Node.readFile(prjFile, 'utf-8'),
          extension: 'prj',
          filebase: o.filebase
        });
      });
    }
  }

  var paths = mapshaper.getOutputPaths(exports, opts.output_directory, opts.output_extension);
  Utils.forEach(exports, function(obj, i) {
    var path = paths[i];
    Node.writeFile(path, obj.content);
    console.log("Wrote " + path);
  });
}