var io = use('io')
var util = use('util')

var dumpfolder = ".prosperon";

io.mkdir(dumpfolder)

var Cmdline = {};

Cmdline.cmds = [];
Cmdline.orders = {};
Cmdline.register_cmd = function (flag, fn, doc) {
  Cmdline.cmds.push({
    flag: flag,
    fn: fn,
    doc: doc,
  });
};

Cmdline.register_order = function (order, fn, doc, usage = "") {
  Cmdline.orders[order] = fn;
  fn.doc = doc;
  fn.usage = `${order} ${usage}`;
};

Cmdline.register_order(
  "makedoc",
  function() {
  var doc = use('doc')

  var gs = ['console', 'prosperon', 'actor', 'use']

  for (var g of gs)
    io.slurpwrite(`.src/docs/api/${g}.md`, doc.writeDocFile(globalThis[g], g))

  var coredocs = io.enumerate("scripts/modules", 0)
  coredocs = coredocs.filter(x => io.match("**/*.js", x)).map(x => x.name())

  var APIPATH = '.src/docs/api/modules/'

  for (var m of coredocs) {
    var u = use(m)
    var path = `${APIPATH}${m}.md`
    io.slurpwrite(path, doc.writeDocFile(u, m))
  }
  
  var TYPEPATH = '.src/docs/api/types/'
  for (var c in prosperon.c_types)
    io.slurpwrite(`${TYPEPATH}${c}.md`, doc.writeDocFile(prosperon.c_types[c], c))

  var DULLPATH = '.src/docs/dull/'
  var mixins = ['Object', 'String', 'Array', 'Map', 'WeakMap', 'Symbol','Set', 'WeakSet', 'ArrayBuffer', 'Function']
  for (var m of mixins) {
    var path = `${DULLPATH}${m}.md`
    io.slurpwrite(path, doc.writeDocFile(globalThis[m].prototype, m))
  }

  var dullgpath = '.src/docs/dull/globals/'
  var globals = ['Object', 'String', 'Array', 'Symbol', 'Number', 'Error','Function', 'Math']
  for (var m of globals) {
    var path = `${dullgpath}${m}.md`
    io.slurpwrite(path, doc.writeDocFile(globalThis[m], m))
  }
  "Make documentation."
})

Cmdline.register_order(
  "play",
  function (argv) {
   var app
   if (io.exists("main.js"))
     app = actor.spawn("main.js")
   else
     app = actor.spawn("nogame.js")

   var loop = use('loop')
   while(1) loop.step();
  },
  "Play the game present in this folder.",
);

Cmdline.register_order(
  "about",
  function (argv) {
    if (!argv[0]) {
      log.print("About your game");
      log.print(`Prosperon version ${prosperon.version}`);
      log.print(`Total entities ${ur._list.length}`);
    }
    switch (argv[0]) {
      case "entities":
        for (var i of ur._list) log.print(i);
        break;
    }
  },
  "Get information about this game.",
);

Cmdline.register_order(
  "api",
  function (obj) {
    var doc = use('doc')
    doc.write_modules()
    doc.write_c_types()
  },
  "Print the API for an object as markdown. Give it a file to save the output to.",
  "OBJECT",
);

Cmdline.register_order(
  "input",
  function (pawn) {
    use("editor.js");
    log.print(`## Input for ${pawn}`);
    eval(`log.print(input.print_md_kbm(${pawn}));`);
  },
  "Print input documentation for a given object as markdown. Give it a file to save the output to",
  "OBJECT ?FILE?",
);

Cmdline.print_order = function (fn) {
  if (typeof fn === "string") fn = Cmdline.orders[fn];

  if (!fn) return;
  log.print(`Usage: prosperon ${fn.usage}` + "\n");
  log.print(fn.doc + "\n");
};

function parse_args(argv)
{
  var args = {};
  for (var i = 0; i < argv.length; i++) {
    if (argv[i].startsWith("--")) {
      var key = argv[i].slice(2);
      if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
        args[key] = argv[i + 1];
        i++; // Skip the value
      } else {
        args[key] = true; // Flag without value
      }
    }
  }
  return args;
}

function unparse_args(args) {
  var argv = [];
  for (var key in args) {
    if (args.hasOwnProperty(key)) {
      argv.push("--" + key); // Add the flag with "--" prefix
      if (args[key] !== true) {
        argv.push(args[key]); // Add the value if it's not a boolean true flag
      }
    }
  }
  return argv;
}

Cmdline.register_order(
  "spawn",
  function(argv) {
    prosperon.args = parse_args(argv)
    if (!prosperon.args.cwd) prosperon.args.cwd = '.'
    io.mount(prosperon.args.cwd)
    
    // Store all remaining non-flag arguments
    var remaining_args = []
    var skip_next = false
    for (var i = 0; i < argv.length; i++) {
      if (skip_next) {
        skip_next = false
        continue
      }
      if (argv[i].startsWith("--")) {
        // Check if this flag has a value
        if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
          skip_next = true
        }
        continue
      }
      remaining_args.push(argv[i])
    }
    
    // Add remaining arguments to prosperon.args
    prosperon.args.remaining = remaining_args
      
    if (!prosperon.args.program)
      os.exit()
  },
  "Spawn a new prosperon actor.",
  "TOPIC"
);

Cmdline.register_order(
  "help",
  function (order) {
    if (!util.isEmpty(order)) {
      var orfn = Cmdline.orders[order];

      if (!orfn) {
        log.warn(`No command named ${order}.`);
        return;
      }

      Cmdline.print_order(orfn);
      return;
    }

    Cmdline.print_order("help");

    for (var cmd of Object.keys(Cmdline.orders).sort()) log.print(cmd + "\n");

    Cmdline.orders.version();
  },
  "Give help with a specific command.",
  "TOPIC",
);

Cmdline.register_order(
  "version",
  function () {
    log.print(`Prosperon version ${prosperon.version} [${prosperon.revision}]` + "\n");
  },
  "Display Prosperon info.",
);

function cmd_args(cmds) {
  // Remove the leading 'prosperon'
  cmds.shift();

  // If there are no arguments left, assume we want to spawn main.js
  if (!cmds[0]) {
    // => effectively do: prosperon spawn --program main.js
    cmds.unshift("main.js");
    cmds.unshift("--program");
    cmds.unshift("spawn");
  } else if (!Cmdline.orders[cmds[0]]) {
    // If the first token isn't a recognized command, treat it as either
    // a directory containing main.js, or a script to run directly.
    var arg0 = cmds.shift();
    if (io.is_directory(arg0)) {
      var script = cmds[0] ? cmds.shift() : "main.js";
      cmds.unshift(script);
      cmds.unshift("--program");
      cmds.unshift(arg0);
      cmds.unshift("--cwd");
    } else {
      cmds.unshift(arg0);
      cmds.unshift("--program");
    }
    cmds.unshift("spawn");
  }

  Cmdline.orders[cmds[0]](cmds.slice(1));
}

return {
  process: cmd_args,
  encode: parse_args,
  decode: unparse_args,
}