let gui;
let params = {
  cellSize: 10, cellSizeMin: 2, cellSizeMax: 40,
  ticksPerFrame: 10, ticksPerFrameMin: 1, ticksPerFrameMax: 1000,
  asFastAsPossible: false,
  pauseAfter: false,
  stopAfter: false,
  randomizePercent: 0.1, randomizePercentMin: 0.01, randomizePercentMax: 1.0, randomizePercentStep: 0.01,
  runOutput: true,
  highlightActive: true,
  allowSemiQuine: true,
  allowReadingCode: true,
  allowWritingCode: false,
  debugPrint: false,
  debugSlow: false,
  debugStepButton: false,
};

const OPS = [
  // Do nothing
  {name: 'nop', f: (m) => {}},
  
  // Push the next value onto the stack
  {name: 'push', f: (m) => m.push(m.next()), nargs: 1},
  
  // Pop a value off the stack without doing anything with it
  {name: 'pop', f: (m) => m.pop()},
  
  // Duplicate the top of the stack
  {name: 'dup', f: (m) => { 
    let v = m.pop();
    m.push(v);
    m.push(v); 
  }},
  
  // Read d off the stack, rotate them c times and push them back
  {name: 'roll', f: (m) => {
    let d = m.pop();
    let c = m.pop();
    
    let temp = [];
    for (let i = 0; i < d; i++) {
      if (m.stack.length > 0) {
        temp.push(m.pop());
      }
    }
    
    for (let i = 0; i < c; i++) {
      temp.push(temp.shift());
    }
    
    for (let v in temp) {
      m.push(v);
    }
  }},
  
  // Write the top value on the stack to output (pops)
  {name: 'out', f: (m) => {
    let v = m.pop();
    if (params.debugPrint) {
      if (v < OPS.length) {
        let name = OPS[v].name;
        console.log(`OUTPUT: ${v} (${name})`);
      } else {
        console.log(`OUTPUT: ${v}`);
      }
    }
    m.out(v);
  }},
  
  // Basic math
  // Everything is unsigned byte arithmetic 
  {name: 'add', f: (m) => m.push(m.pop() + m.pop())},
  {name: 'sub', f: (m) => m.push(m.pop() - m.pop())},
  {name: 'mul', f: (m) => m.push(m.pop() * m.pop())},
  {name: 'div', f: (m) => m.push(m.pop() / (m.pop() || 1))},
  
  // Anything != 0 -> 0, 0 -> 1
  {name: 'not', f: (m) => m.push(m.pop() == 1 ? 0 : 1)},  
  
  // Pop two values, push 1 if the first is greater
  {name: 'greater', f: (m) => m.push(m.pop() > m.pop() ? 1 : 0)},
  
  // Skip the next command if the top of the stack is non-zero
  {name: 'skip', f: (m) => { 
    if (m.pop()) m.pc += 1; 
  }},
  
  // Jump forward/backward based on next arg
  {name: 'jump', f: (m) => m.pc += m.pop() - 1},
  {name: 'jumpback', f: (m) => m.pc -= m.pop() + 1},
  
  // And catch fire
  {name: 'halt', f: (m) => {
    while (m.output.length < m.code.length) {
      m.out(0);
    }
  }},
  
  // Read data about the current state of the machine
  {name: 'peek', f: (m) => m.push(m.code[m.pc + m.pop() - 1]), requireAllowRead: true},
  {name: 'peekback', f: (m) => m.push(m.code[m.pc - m.pop() + 1]), requireAllowRead: true},
  {name: 'pc', f: (m) => m.push(m.pc), requireAllowRead: true},
  
  // Allow self modifying code
  {name: 'poke', f: (m) => m.code[m.pc + m.pop() - 1] = m.pop(), requireAllowWrite: true},
  {name: 'pokeback', f: (m) => m.code[m.pc - m.pop() + 1] = m.pop(), requireAllowWrite: true},
];

// Represents our virtual machine
class VM {
  // Initialize a machine with no code but a given memory layout/size
  constructor(w, h) {
    this.w = w;
    this.h = h;
    this.reset();
  }
  
  // Reset everything in this VM that could change
  reset() {
    this.message = "";  // Debugging message
    this.code = [];    // The code to run 
    this.output = [];  // Output generated so far
    this.stack = [];   // Current stack
    this.pc = 0;       // Program counter
    
    // How long it's been since last output (used to detect infinitish loops)
    this.ticksSinceOutput = 0;
    
    // Highlight which parts of memory are actually used when running the program
    // You can get a 'free' quine by setting anything in the non active set to the output
    // Since it's not run anyways
    this.activeMemory = new Set();
    
    // Track how many times we've done this...
    evaluations += 1;
  }
  
  push(v) {
    v = floor(v);
    while (v < 0) v += 256;
    this.stack.push(v % 256);
  }
  
  pop() {
    if (this.stack.length == 0) {
      return 0;
    } else {
      return this.stack.pop();
    }
  }
  
  next() {
    let v = this.code[this.pc % this.code.length];
    this.activeMemory.add(this.pc);
    this.pc += 1;
    return v;
  }
  
  out(v) {
    this.ticksSinceOutput = 0;
    this.output.push(v);
  }
  
  randomize() {
    let previousCode = this.code || [];
    
    this.reset();
    
    for (let i = 0; i < this.w * this.h; i++) {
      if (i < previousCode.length && random() > params.randomizePercent) {
        this.code.push(previousCode[i]);
      } else {
        // My valid solution requires a `push 22` and we only have 21 opcodes :smile:
        this.code.push(floor(random() * Math.max(OPS.length, 32)));
      }      
    }
  }
  
  step() {
    this.ticksSinceOutput += 1;
    
    let debug_pc = this.pc;
    
    let v = this.next();
    let op = OPS[v];
    
    let debug_name = op == undefined ? `[${v}]` : op.name;
    if (params.debugPrint && debug_name != 'nop') {
      if (op.nargs) {
        let args = [];
        for (let i = 0; i < op.nargs; i++) {
          args.push(this.code[this.pc + i]);
        }
        console.log(`${debug_pc}: ${debug_name} ${args}`);
      } else {
        console.log(`${debug_pc}: ${debug_name}`);
      }
    }
    
    let canRun = true;
    if (op == undefined) {
      // nop invalid commands (can happen if we poke funny things into memory)
    } else if (!params.allowReadingCode && op.requireAllowRead) {
      // reading your own code could be considered quine-cheating :)
    } else if (!params.allowWritingCode && op.requireAllowWrite) {
      // writing self modifying code is generally a bad idea
      // but oh, it can do some wacky things
    } else {
      // hey, those all passed! we can actually do something!
      op.f(this);
    }
    
    // Force PC back into bounds
    while (this.pc < 0) this.pc += this.code.length;
    this.pc = this.pc % this.code.length;
  }
  
  draw() {
    background("white");
    
    // My program
    let draw = (data, xOffset) => {
      for (let cellX = 0; cellX < this.w; cellX++) {
        for (let cellY = 0; cellY < this.h; cellY++) {
          let i = cellX + cellY * this.w
          if (i >= data.length) {
            break;
          }
          
          let v = data[i];
          let hue = 360 * ((v - 1) % OPS.length) / OPS.length;
          
          noStroke();

          if (v == 0) {
            fill(0, 100, 0);
          } else if (!params.highlightActive || this.activeMemory.has(i)) {
            fill(hue, 100, 100);
          } else {
            fill(hue, 50, 100);
          }
          
          rect(
            xOffset + cellX * params.cellSize,
            cellY * params.cellSize,
            params.cellSize,
            params.cellSize,
          );
        }
      }
    }
    
    draw(this.code, 0, true);
    draw(this.output, this.w * params.cellSize);
    
    // PC
    stroke("black");
    noFill();
    rect(
      this.pc % this.w * params.cellSize,
      floor(this.pc / this.w) * params.cellSize,
      params.cellSize,
      params.cellSize,
    );

    // Debug
    fill("black");
    if (this.message) {
      text(`[${evaluations}] ${this.message}`, 8, this.h * params.cellSize + 16);
    } else {
      text(`[${evaluations}] ${this.stack}`, 8, this.h * params.cellSize + 16);
    }
    
    // Borders
    stroke("black");
    strokeWeight(1);
    noFill();
    rect(
      0,
      0,
      this.w * params.cellSize,
      this.h * params.cellSize
    );
    
    rect(
      this.w * params.cellSize,
      0,
      this.w * params.cellSize,
      this.h * params.cellSize
    );
  }
}

function setup() {
  createCanvas(400, 400);
  noStroke();
  colorMode(HSB, 360, 100, 100, 100);

  gui = createGuiPanel("params");
  gui.addObject(params);
  gui.setPosition(420, 0);
  
  inputBox = createElement('textarea');
  inputBox.elt.style.width = '380px';
  inputBox.elt.style.height = '200px';
  
  createElement('br')
  let loadSource = createButton("Load source");
  loadSource.mousePressed(() => {
    params.stopAfter = true;
    noLoop();

    currentVM.reset();
    while (currentVM.code.length < currentVM.w * currentVM.h) {
      currentVM.code.push(0);
    }
    
    let address = 0;
    for (let line of inputBox.elt.value.split("\n")) {
      if (line.trim() == "" || line[0] == '#') {
        continue;
      }
      
      // If we have an address, update it
      let hasAddress = line.split(" ")[0].endsWith(':');
      if (hasAddress) {
        address = parseInt(line.slice(0, 4));
      }
      
      for (let arg of line.split(" ").slice(hasAddress ? 1 : 0)) {
        if (arg == "" || arg[0] == '#' || arg[0] == ';') {
          break;
        }
        
        let asNumber = parseInt(arg);
        if (isNaN(asNumber)) {
          // Opcode (I hope)
          let found = false;
          for (let i = 0; i < OPS.length; i++) {
            if (OPS[i].name == arg) {
              currentVM.code[address] = i;
              found = true;
              break;
            }
          }
          
          if (!found) {
            console.warn("Undefine op: " + arg);
          }
        } else {
          currentVM.code[address] = asNumber;
        }
        
        address += 1;
      }
    }
    
    if (params.debugPrint) {
      console.log("Loaded source:", currentVM.code);
    }
    
    currentVM.draw();
  
    if (!params.debugStepButton) {
      loop();
    }
  });
  
  if (params.debugStepButton) {
    let step = createButton("Step");
    step.mousePressed(() => {
      noLoop();
      currentVM.step();
      currentVM.draw();
    });
    noLoop();
  }

  createElement('br')
}

let inputBox;
let lastCellSize;
let currentVM; 
let evaluations = 0;

function draw() {
  // If we don't have a machine, initialize it
  // If we do, but the size changed, re-initialize it
  if (currentVM == undefined || lastCellSize != params.cellSize) {
    lastCellSize = params.cellSize;
    currentVM = new VM(
      width / params.cellSize / 2,
      height / params.cellSize - 2,
    );
    
    currentVM.code = [];
    for (let i = 0; i < currentVM.w * currentVM.h; i++) {
      currentVM.code.push(0);
    }
  }
  
  // Iterate the VM
  for (let i = 0; i < params.ticksPerFrame; i++) {
    if (params.asFastAsPossible) {
      i = 0; // lol
    }
    currentVM.step();
    
    // If we have (at least) enough output, halt 
    // Check for a quine (code == output)
    if (currentVM.output.length >= currentVM.code.length) {
      let previousCode = currentVM.code;
      let newCode = currentVM.output.slice(0, currentVM.code.length);
      
      let isQuine = true;
      let isSemiQuine = true;

      for (let i = 0; i < previousCode.length; i++) {
        if (previousCode[i] != newCode[i]) {
          isQuine = false;
          if (currentVM.activeMemory.has(i)) {
            isSemiQuine = false;
          }
          
          if (params.allowSemiQuine && !currentVM.activeMemory.has(i)) {
            continue;
          } else {
            break;
          }
        }
      }
      
      if (isQuine || isSemiQuine) {
        if (!isQuine) {
          currentVM.message = "(SEMI) QUINE FOUND!";
        } else {
          currentVM.message = "QUINE FOUND!";
        }
        
        let source = '';
        for (let i = 0; i < previousCode.length; i++) {
          let op = OPS[previousCode[i]];
          if (op == undefined || op.name == 'nop') {
            continue;
          }
      
          let index = i.toString().padStart(4, '0');
          source += `${index}: ${op.name}`;
          
          if (op.nargs) {
            for (let j = 0; j < op.nargs; j++) {
              source += ` ${previousCode[++i]}`;
            }
          }
          source += '\n';
        }
        inputBox.elt.value = source;
        
        currentVM.draw();
        
        noLoop();
        return;
      }
     
      // If we made it this far, we don't have a quine so update to next output
      // And let's do it again
      currentVM.message = "output complete";
      currentVM.draw();
      
      currentVM.reset();
      if (params.runOutput) {
        currentVM.code = newCode;
      } else {
        currentVM.code = previousCode;
        currentVM.randomize();
      }
      
      if (params.pauseAfter || params.stopAfter) {
        noLoop();
        if (!params.stopAfter) {
          setTimeout(loop, 1000);  
        }
      }
      
      return;
    }
    
    // Possible infinite loop
    // Or at least taking annoyingly long, so kill it
    if (currentVM.ticksSinceOutput >= currentVM.w * currentVM.h) {
      currentVM.message = "timed out";
      while (currentVM.output.length < currentVM.code.length) {
        currentVM.out(0);
      }
      currentVM.draw();
      
      currentVM.randomize();
      
      if (params.pauseAfter || params.stopAfter) {
        noLoop();
        if (!params.stopAfter) {
          setTimeout(loop, 1000);  
        }
      }
      
      return;
    }    
  }
  
  currentVM.draw();
  if (params.debugSlow) {
    frameRate(1);
  }
}