// Generated by CoffeeScript 2.3.1
(function() {
  var check_resources, copy_between_systems, current_emulator, downloadKernel, el, files, i, install_package, j, len, len1, load_environment, log, ref, ref1, run_project;

  require.config({
    paths: {
      'z80e': '../tools/z80e'
    },
    shim: {
      '../tools/kpack': {
        exports: 'exports'
      },
      '../tools/genkfs': {
        exports: 'exports'
      },
      '../tools/scas': {
        exports: 'exports'
      },
      'z80e': {
        exports: 'exports'
      }
    }
  });

  window.toolchain = {
    kpack: null,
    genkfs: null,
    scas: null,
    z80e: null,
    ide_emu: null,
    kernel_rom: null
  };

  files = [];

  log = function(text) {
    var i, len, log_el, log_els, results;
    log_els = document.querySelectorAll('.tool-log');
    console.log(text);
    results = [];
    for (i = 0, len = log_els.length; i < len; i++) {
      log_el = log_els[i];
      if (log_el.innerHTML === '') {
        log_el.innerHTML += text;
      } else {
        log_el.innerHTML += '\n' + text;
      }
      results.push(log_el.scrollTop = log_el.scrollHeight);
    }
    return results;
  };

  window.ide_log = log;

  copy_between_systems = function(fs1, fs2, from, to, encoding) {
    var f, fs1p, fs2p, i, len, ref, results, s;
    ref = fs1.readdir(from);
    results = [];
    for (i = 0, len = ref.length; i < len; i++) {
      f = ref[i];
      if (f === '.' || f === '..') {
        continue;
      }
      fs1p = from + '/' + f;
      fs2p = to + '/' + f;
      s = fs1.stat(fs1p);
      log(`Writing ${fs1p} to ${fs2p}`);
      if (fs1.isDir(s.mode)) {
        try {
          fs2.mkdir(fs2p);
        } catch (error) {

        }
        // pass
        results.push(copy_between_systems(fs1, fs2, fs1p, fs2p, encoding));
      } else {
        results.push(fs2.writeFile(fs2p, fs1.readFile(fs1p, {
          encoding: encoding
        }), {
          encoding: encoding
        }));
      }
    }
    return results;
  };

  install_package = function(repo, name, callback) {
    var full_name, xhr;
    full_name = repo + '/' + name;
    log("Downloading " + full_name);
    xhr = new XMLHttpRequest();
    xhr.open('GET', "https://packages.knightos.org/" + full_name + "/download");
    xhr.responseType = 'arraybuffer';
    xhr.onload = function() {
      var data, file_name;
      log("Installing " + full_name);
      file_name = '/packages/' + repo + '-' + name + '.pkg';
      data = new Uint8Array(xhr.response);
      toolchain.kpack.FS.writeFile(file_name, data, {
        encoding: 'binary'
      });
      toolchain.kpack.Module.callMain(['-e', file_name, '/pkgroot']);
      copy_between_systems(toolchain.kpack.FS, toolchain.scas.FS, "/pkgroot/include", "/include", "utf8");
      copy_between_systems(toolchain.kpack.FS, toolchain.genkfs.FS, "/pkgroot", "/root", "binary");
      log("Package installed.");
      if (callback != null) {
        return callback();
      }
    };
    return xhr.send();
  };

  current_emulator = null;

  load_environment = function() {
    var callback, packages;
    toolchain.genkfs.FS.writeFile("/kernel.rom", toolchain.kernel_rom, {
      encoding: 'binary'
    });
    toolchain.genkfs.FS.mkdir("/root");
    toolchain.genkfs.FS.mkdir("/root/bin");
    toolchain.genkfs.FS.mkdir("/root/etc");
    toolchain.genkfs.FS.mkdir("/root/home");
    toolchain.genkfs.FS.mkdir("/root/lib");
    toolchain.genkfs.FS.mkdir("/root/share");
    toolchain.genkfs.FS.mkdir("/root/var");
    toolchain.kpack.FS.mkdir("/packages");
    toolchain.kpack.FS.mkdir("/pkgroot");
    toolchain.kpack.FS.mkdir("/pkgroot/include");
    toolchain.scas.FS.mkdir("/include");
    packages = 0;
    callback = function() {
      var b, i, len, ref, results;
      packages++;
      if (packages === 2) {
        log("Ready to go!");
      }
      ref = document.querySelectorAll('.run-button');
      results = [];
      for (i = 0, len = ref.length; i < len; i++) {
        b = ref[i];
        results.push(b.style.display = 'inline');
      }
      return results;
    };
    install_package('core', 'init', callback);
    return install_package('core', 'kernel-headers', callback);
  };

  run_project = function(main) {
    var executable, ret, rom;
    // Assemble
    window.toolchain.scas.FS.writeFile('/main.asm', main);
    log("Calling assembler...");
    ret = window.toolchain.scas.Module.callMain(['/main.asm', '-I/include/', '-o', 'executable']);
    if (ret !== 0) {
      return ret;
    }
    log("Assembly done!");
    // Build filesystem
    executable = window.toolchain.scas.FS.readFile("/executable", {
      encoding: 'binary'
    });
    window.toolchain.genkfs.FS.writeFile("/root/bin/executable", executable, {
      encoding: 'binary'
    });
    window.toolchain.genkfs.FS.writeFile("/root/etc/inittab", "/bin/executable");
    window.toolchain.genkfs.FS.writeFile("/kernel.rom", new Uint8Array(toolchain.kernel_rom), {
      encoding: 'binary'
    });
    window.toolchain.genkfs.Module.callMain(["/kernel.rom", "/root"]);
    rom = window.toolchain.genkfs.FS.readFile("/kernel.rom", {
      encoding: 'binary'
    });
    log("Loading your program into the emulator!");
    if (current_emulator !== null) {
      current_emulator.cleanup();
    }
    current_emulator = new toolchain.ide_emu(document.querySelectorAll('.emulator-screen'));
    current_emulator.load_rom(rom.buffer);
    return 0;
  };

  check_resources = function() {
    var i, len, prop, ref;
    ref = Object.keys(window.toolchain);
    for (i = 0, len = ref.length; i < len; i++) {
      prop = ref[i];
      if (window.toolchain[prop] === null) {
        return;
      }
    }
    log("Ready.");
    return load_environment();
  };

  downloadKernel = function() {
    var rom;
    log("Downloading latest kernel...");
    rom = new XMLHttpRequest();
    rom.open('GET', 'https://mirror.drewdevault.com/KnightOS-TI84pSE.rom');
    rom.setRequestHeader("Accept", "application/octet-stream");
    rom.responseType = 'arraybuffer';
    rom.onload = function() {
      window.toolchain.kernel_rom = rom.response;
      log("Loaded kernel ROM.");
      return check_resources();
    };
    return rom.send();
  };

  downloadKernel();

  log("Downloading scas...");

  require(['../tools/scas'], function(scas) {
    log("Loaded scas.");
    window.toolchain.scas = scas;
    window.toolchain.scas.Module.preRun.pop()();
    return check_resources();
  });

  log("Downloading kpack...");

  require(['../tools/kpack'], function(kpack) {
    log("Loaded kpack.");
    window.toolchain.kpack = kpack;
    return check_resources();
  });

  log("Downloading genkfs...");

  require(['../tools/genkfs'], function(genkfs) {
    log("Loaded genkfs.");
    window.toolchain.genkfs = genkfs;
    return check_resources();
  });

  log("Downloading emulator bindings...");

  require(['ide_emu'], function(ide_emu) {
    log("Loaded emulator bindings.");
    window.toolchain.ide_emu = ide_emu;
    window.toolchain.z80e = require("z80e");
    return check_resources();
  });

  ref = document.querySelectorAll('.editor');
  for (i = 0, len = ref.length; i < len; i++) {
    el = ref[i];
    (function(el) {
      var button, editor, xhr;
      // Set up default editors
      editor = ace.edit(el);
      editor.setTheme("ace/theme/github");
      if (el.dataset.file.indexOf('.asm') === el.dataset.file.length - 4) {
        editor.getSession().setMode("ace/mode/assembly_x86");
      }
      files.push({
        name: el.dataset.file,
        editor: editor
      });
      xhr = new XMLHttpRequest();
      xhr.open('GET', el.dataset.source);
      xhr.onload = function() {
        editor.setValue(this.responseText);
        return editor.navigateFileStart();
      };
      xhr.send();
      button = document.createElement('button');
      button.className = 'run-button';
      button.style.display = 'none';
      button.addEventListener('click', function(e) {
        var ret;
        e.preventDefault();
        ret = run_project(editor.getValue());
        if (ret !== 0) {
          return alert("Assembler returned nonzero exit status, see log to the left");
        }
      });
      button.textContent = 'Run';
      return el.appendChild(button);
    })(el);
  }

  document.getElementById('install-package').addEventListener('click', function(e) {
    var p;
    e.preventDefault();
    p = document.getElementById('package-name').value.split('/');
    return install_package(p[0], p[1]);
  });

  ref1 = document.querySelectorAll('.install-package-button');
  for (j = 0, len1 = ref1.length; j < len1; j++) {
    el = ref1[j];
    (function(el) {
      return el.addEventListener('click', function() {
        var p;
        p = el.dataset.package.split('/');
        return install_package(p[0], p[1]);
      });
    })(el);
  }

  window.setInterval(function() {
    if (window.current_asic != null) {
      return document.getElementById('register-pc').textContent = '0x' + window.current_asic.cpu.registers.PC.toString(16).toUpperCase();
    } else {
      return document.getElementById('register-pc').textContent = '0x0000';
    }
  }, 100);

}).call(this);