var util = require("util");
var fs = require("fs");
var spawn = require("child_process").spawn;
var path = require("path");
var fileExtensionPattern;
var startChildProcess;
var noRestartOn = null;
var debug = true;
var verbose = false;
var ignoredPaths = {};
var forceWatchFlag = false;
var instantKillFlag = false;
var interactive = true;
var log = console.log;

exports.run = run;

function run (args) {
  var arg, next, watch, ignore, pidFilePath, program, extensions, executor, poll_interval, debugFlag, debugBrkFlag, debugBrkFlagArg, harmony;
  while (arg = args.shift()) {
    if (arg === "--help" || arg === "-h" || arg === "-?") {
      return help();
    } else if (arg === "--quiet" || arg === "-q") {
      debug = false;
      log = function(){};
    } else if (arg === "--harmony") {
      harmony = true;
    } else if (arg === "--verbose" || arg === "-V") {
      verbose = true;
    } else if (arg === "--watch" || arg === "-w") {
      watch = args.shift();
    } else if (arg == "--non-interactive" || arg === "-t") {
      interactive = false;
    } else if (arg === "--ignore" || arg === "-i") {
      ignore = args.shift();
    } else if (arg === "--save-pid" || arg === "-pid") {
      pidFilePath = args.shift();
    } else if (arg === "--poll-interval" || arg === "-p") {
      poll_interval = parseInt(args.shift());
    } else if (arg === "--extensions" || arg === "-e") {
      extensions = args.shift();
    } else if (arg === "--exec" || arg === "-x") {
      executor = args.shift();
    } else if (arg === "--no-restart-on" || arg === "-n") {
      noRestartOn = args.shift();
    } else if (arg === "--debug") {
      debugFlag = true;
    } else if (arg.indexOf('--debug-brk')>=0) {
      debugBrkFlag = true;
      debugBrkFlagArg = arg;
    } else if (arg === "--force-watch") {
      forceWatchFlag = true;
    } else if (arg === "--instant-kill" || arg === "-k") {
      instantKillFlag = true;
    } else if (arg === "--") {
      program = args;
      break;
    } else if (arg[0] != "-" && !args.length) {
      // Assume last arg is the program
      program = [arg];
    }
  }
  if (!program) {
    return help();
  }
  if (!watch) {
    watch = ".";
  }
  if (!poll_interval) {
    poll_interval = 1000;
  }

  var programExt = program.join(" ").match(/.*\.(\S*)/);
  programExt = programExt && programExt[1];

  if (!extensions) {
    // If no extensions passed try to guess from the program
    extensions = "node,js";
    if (programExt && extensions.indexOf(programExt) == -1) {
      // Support coffee and litcoffee extensions
      if(programExt === "coffee" || programExt === "litcoffee") {
        extensions += ",coffee,litcoffee";
      } else {
        extensions += "," + programExt;
      }
    }
  }
  fileExtensionPattern = new RegExp("^.*\.(" + extensions.replace(/,/g, "|") + ")$");

  if (!executor) {
    executor = (programExt === "coffee" || programExt === "litcoffee") ? "coffee" : "node";
  }

  if (debugFlag) {
    program.unshift("--debug");
  }
  if (debugBrkFlag) {
    program.unshift(debugBrkFlagArg);
  }
  if (harmony) {
    program.unshift("--harmony");
  }
  if (executor === "coffee" && (debugFlag || debugBrkFlag)) {
    // coffee does not understand debug or debug-brk, make coffee pass options to node
    program.unshift("--nodejs")
  }
  if (pidFilePath) {
    var pid = process.pid;
    //
    // verify if we have write access
    //
    canWrite(pidFilePath, function(err) {
      if ( err ) {
        log("Continuing...");
      } else {
        fs.writeFileSync(pidFilePath, pid + '\n');
      }
    });
  }

  var deletePidFile = function(){
    fs.exists(pidFilePath, function (exists) {
      if ( exists ) {
        log("Removing pid file")
        fs.unlinkSync(pidFilePath);
      } else {
        log("No pid file to remove...");
      }
      process.exit();
    });
  };

  try {
    // Pass kill signals through to child
    [ "SIGTERM", "SIGINT", "SIGHUP", "SIGQUIT" ].forEach( function(signal) {
      process.on(signal, function () {
        var child = exports.child;
        if (child) {
          log("Received "+signal+", killing child...");
          child.kill(signal);
        }
        if (pidFilePath){
          deletePidFile();
        } else {
          process.exit();
        }
      });
    });
  } catch(e) {
    // Windows doesn't support signals yet, so they simply don't get this handling.
    // https://github.com/joyent/node/issues/1553
  }

  log("")
  log("Running node-supervisor with");
  log("  program '" + program.join(" ") + "'");
  log("  --watch '" + watch + "'");
  if (!interactive) {
    log("  --non-interactive");
  }
  if (ignore) {
    log("  --ignore '" + ignore + "'");
  }
  if (pidFilePath){
    log("  --save-pid '" + pidFilePath + "'");
  }
  log("  --extensions '" + extensions + "'");
  log("  --exec '" + executor + "'");
  log("");

  // store the call to startProgramm in startChildProcess
  // in order to call it later
  startChildProcess = function() { startProgram(program, executor); };

  // if we have a program, then run it, and restart when it crashes.
  // if we have a watch folder, then watch the folder for changes and restart the prog
  startChildProcess();

  // If interaction has not been disabled, start the CLI
  if(interactive) {

    //
    // Read input from stdin
    //
    var stdin = process.stdin;

    stdin.setEncoding( 'utf8' );
    stdin.on('readable', function() {
      var chunk = process.stdin.read();
      //
      // Restart process when user inputs rs
      //
      if (chunk !== null && chunk === "rs\n") {
  //      process.stdout.write('data: ' + chunk);
        crash();
      }
    });
  }

  if (ignore) {
    var ignoreItems = ignore.split(',');
    ignoreItems.forEach(function (ignoreItem) {
      ignoreItem = path.resolve(ignoreItem);
      ignoredPaths[ignoreItem] = true;
      log("Ignoring directory '" + ignoreItem + "'.");
    });
  }

  var watchItems = watch.split(',');
  watchItems.forEach(function (watchItem) {
    watchItem = path.resolve(watchItem);

    if ( ! ignoredPaths[watchItem] ) {
      log("Watching directory '" + watchItem + "' for changes.");
      if(interactive) {
        log("Press rs for restarting the process.");
      }
      findAllWatchFiles(watchItem, function(f) {
        watchGivenFile( f, poll_interval );
      });
    }
  });
};

// function print (m, n) { console.log(m+(!n?"\n":"")); return print; }
function print (m, n) { console.log(m); return print; }

function help () {
  print
    ("")
    ("Node Supervisor is used to restart programs when they crash.")
    ("It can also be used to restart programs when a *.js file changes.")
    ("")
    ("Usage:")
    ("  supervisor [options] <program>")
    ("  supervisor [options] -- <program> [args ...]")
    ("")
    ("Required:")
    ("  <program>")
    ("    The program to run.")
    ("")
    ("Options:")
    ("  -w|--watch <watchItems>")
    ("    A comma-delimited list of folders or js files to watch for changes.")
    ("    When a change to a js file occurs, reload the program")
    ("    Default is '.'")
    ("")
    ("  -i|--ignore <ignoreItems>")
    ("    A comma-delimited list of folders to ignore for changes.")
    ("    No default")
    ("")
    ("  -p|--poll-interval <milliseconds>")
    ("    How often to poll watched files for changes.")
    ("    Defaults to Node default.")
    ("")
    ("  -e|--extensions <extensions>")
    ("    Specific file extensions to watch in addition to defaults.")
    ("    Used when --watch option includes folders")
    ("    Default is 'node,js'")
    ("")
    ("  -x|--exec <executable>")
    ("    The executable that runs the specified program.")
    ("    Default is 'node'")
    ("")
    ("  --debug")
    ("    Start node with --debug flag.")
    ("")
    ("  --debug-brk[=port]")
    ("    Start node with --debug-brk[=port] flag.")
    ("")
    ("  --harmony")
    ("    Start node with --harmony flag.")
    ("")
    ("  -n|--no-restart-on error|exit")
    ("    Don't automatically restart the supervised program if it ends.")
    ("    Supervisor will wait for a change in the source files.")
    ("    If \"error\", an exit code of 0 will still restart.")
    ("    If \"exit\", no restart regardless of exit code.")
    ("")
    ("  -t|--non-interactive")
    ("    Dissable interactive capacity")
    ("    With this option, supervisor won't listen to stdin")
    ("")
    ("  -k|--instant-kill")
    ("    Dissable interactive capacity")
    ("    With this option, supervisor won't listen to stdin")
    ("")
    ("  --force-watch")
    ("    Use fs.watch instead of fs.watchFile.")
    ("    This may be useful if you see a high cpu load on a windows machine.")
    ("")
    ("  -h|--help|-?")
    ("    Display these usage instructions.")
    ("")
    ("  -q|--quiet")
    ("    Suppress DEBUG messages")
    ("")
    ("  -V|--verbose")
    ("    Show extra DEBUG messages")
    ("")
    ("Options available after start:")
    ("rs - restart process.")
    ("     Useful for restarting supervisor eaven if no file has changed.")
    ("")
    ("Examples:")
    ("  supervisor myapp.js")
    ("  supervisor myapp.coffee")
    ("  supervisor -w scripts -e myext -x myrunner myapp")
    ("  supervisor -- server.js -h host -p port")
    ("");
};

function startProgram (prog, exec) {
  log("Starting child process with '" + exec + " " + prog.join(" ") + "'");
  crash_queued = false;
  var child = exports.child = spawn(exec, prog, {stdio: 'inherit'});
  // Support for Windows ".cmd" files
  // On Windows 8.1, spawn can't launch apps without the .cmd extention
  // If already retried, let the app crash ... :'(
  if (process.platform === "win32" && exec.indexOf('.cmd') == -1) {
    child.on('error', function (err) {
      if (err.code === "ENOENT")
        return startProgram(prog, exec + ".cmd");
    });
  }
  if (child.stdout) {
    // node < 0.8 doesn't understand the 'inherit' option, so pass through manually
    child.stdout.addListener("data", function (chunk) { chunk && console.log(chunk); });
    child.stderr.addListener("data", function (chunk) { chunk && console.error(chunk); });
  }
  child.addListener("exit", function (code) {
    if (!crash_queued) {
      log("Program " + exec + " " + prog.join(" ") + " exited with code " + code + "\n");
      exports.child = null;
      if (noRestartOn == "exit" || noRestartOn == "error" && code !== 0) return;
    }
    startProgram(prog, exec);
  });
}

var timer = null, mtime = null; crash_queued = false;
function crash () {

  if (crash_queued)
    return;

  crash_queued = true;
  var child = exports.child;
  setTimeout(function() {
    if (child) {
      if (instantKillFlag) {
        log("crashing child with SIGKILL");
        process.kill(child.pid, "SIGKILL");
      } else {
        log("crashing child");
        process.kill(child.pid);
      }
    } else {
      log("restarting child");
      startChildProcess();
    }
  }, 50);
}

function crashWin (event, filename) {
  var shouldCrash = true;
  if( event === 'change' ) {
    if (filename) {
      filename = path.resolve(filename);
      Object.keys(ignoredPaths).forEach(function (ignorePath) {
        if ( filename.indexOf(ignorePath + '\\') === 0 || filename === ignorePath) {
          shouldCrash = false;
        }
      });
    }
    if (shouldCrash)
      crash();
  }
}

function crashOther (oldStat, newStat) {
  // we only care about modification time, not access time.
  if ( newStat.mtime.getTime() !== oldStat.mtime.getTime() )
    crash();
}
/**
 * Determine if a file can be written
 */
function canWrite(path, callback) {
  fs.open(path, "w", function (err, fd) {
    if (err) {
      if (err.code === "EISDIR") {
        log("Can't open " + path + ". It's a directory.");
      }
      if (err.code === "EACCESS") {
        log("Can't open " + path + ". No access.");
      } else {
        log("Can't open " + path + ".");
      }
      return callback(err);
    }
    fs.close(fd, function (err) {
      if (err) return callback(err);
      callback(null, true);
    });
  });
};


var nodeVersion = process.version.split(".");
var isWindowsWithoutWatchFile = process.platform === 'win32' && parseInt(nodeVersion[1]) <= 6;
function watchGivenFile (watch, poll_interval) {
  if (isWindowsWithoutWatchFile || forceWatchFlag)
    fs.watch(watch, { persistent: true, interval: poll_interval }, crashWin);
  else
    fs.watchFile(watch, { persistent: true, interval: poll_interval }, crashOther);
  if (verbose)
    log("watching file '" + watch + "'");
}

var findAllWatchFiles = function(dir, callback) {
  dir = path.resolve(dir);
  if (ignoredPaths[dir])
    return;
  fs.stat(dir, function(err, stats){
    if (err) {
      console.error('Error retrieving stats for file: ' + dir);
    } else {
      if (stats.isDirectory()) {
        if (isWindowsWithoutWatchFile || forceWatchFlag) callback(dir);
        fs.readdir(dir, function(err, fileNames) {
          if(err) {
            console.error('Error reading path: ' + dir);
          }
          else {
            fileNames.forEach(function (fileName) {
              findAllWatchFiles(path.join(dir, fileName), callback);
            });
          }
        });
      } else {
        if ((!isWindowsWithoutWatchFile || !forceWatchFlag) && dir.match(fileExtensionPattern)) {
          callback(dir);
        }
      }
    }
  });
};