"use strict";

import { Platform } from "../baseplatform";
import { PLATFORMS, setKeyboardFromMap, AnimationTimer, RasterVideo, Keys, makeKeycodeMap } from "../emu";
import { SampleAudio } from "../audio";

var VERILOG_PRESETS = [
  {id:'clock_divider.v', name:'Clock Divider'},
  {id:'hvsync_generator.v', name:'Video Sync Generator'},
  {id:'test_hvsync.v', name:'Test Pattern'},
  {id:'7segment.v', name:'7-Segment Decoder'},
  {id:'digits10.v', name:'Bitmapped Digits'},
  {id:'scoreboard.v', name:'Scoreboard'},
  {id:'ball_absolute.v', name:'Ball Motion (absolute position)'},
  {id:'ball_slip_counter.v', name:'Ball Motion (slipping counter)'},
  {id:'paddles.v', name:'Paddle Inputs'},
  {id:'ball_paddle.v', name:'Brick Smash Game'},
  {id:'ram1.v', name:'RAM Text Display'},
  {id:'sprite_bitmap.v', name:'Sprite Bitmaps'},
  {id:'sprite_renderer.v', name:'Sprite Rendering'},
  {id:'racing_game.v', name:'Racing Game'},
  {id:'sprite_rotation.v', name:'Sprite Rotation'},
  {id:'tank.v', name:'Tank Game'},
  {id:'sound_generator.v', name:'Sound Generator'},
  {id:'lfsr.v', name:'Linear Feedback Shift Register'},
  {id:'starfield.v', name:'Scrolling Starfield'},
  {id:'cpu8.v', name:'Simple 8-Bit CPU'},
  {id:'racing_game_cpu.v', name:'Racing Game with CPU'},
  {id:'framebuffer.v', name:'Frame Buffer'},
  {id:'tile_renderer.v', name:'Tile Renderer'},
  {id:'sprite_scanline_renderer.v', name:'Sprite Scanline Renderer'},
  {id:'cpu16.v', name:'16-Bit CPU'},
  {id:'cpu_platform.v', name:'CPU Platform'},
  {id:'test2.asm', name:'16-bit ASM Game'},
];

var VERILOG_KEYCODE_MAP = makeKeycodeMap([
  [Keys.VK_LEFT, 0, 0x1],
  [Keys.VK_RIGHT, 0, 0x2],
  [Keys.VK_UP, 0, 0x4],
  [Keys.VK_DOWN, 0, 0x8],
  [Keys.VK_SPACE, 0, 0x10],
  [Keys.VK_SHIFT, 0, 0x20],
  [Keys.VK_A, 1, 0x1],
  [Keys.VK_D, 1, 0x2],
  [Keys.VK_W, 1, 0x4],
  [Keys.VK_S, 1, 0x8],
  [Keys.VK_Z, 1, 0x10],
  [Keys.VK_X, 1, 0x20],
  [Keys.VK_1, 2, 0x1],
  [Keys.VK_2, 2, 0x2],
  [Keys.VK_5, 2, 0x4],
  [Keys.VK_6, 2, 0x8],
  [Keys.VK_7, 2, 0x10],
]);

var vl_finished = false;
var vl_stopped = false;

// TODO: these have to be global

  var VL_UL = this.VL_UL = function(x) { return x|0; }
  var VL_ULL = this.VL_ULL = function(x) { return x|0; }
  var VL_TIME_Q = this.VL_TIME_Q = function() { return (new Date().getTime())|0; }

  /// Return true if data[bit] set
  var VL_BITISSET_I = this.VL_BITISSET_I = function(data,bit) { return (data & (VL_UL(1)<<VL_UL(bit))); }

  var VL_EXTENDSIGN_I = this.VL_EXTENDSIGN_I = function(lbits, lhs) { return (-((lhs)&(VL_UL(1)<<(lbits-1)))); }

  var VL_EXTEND_II = this.VL_EXTEND_II = function(obits,lbits,lhs) { return lhs; }

  var VL_EXTENDS_II = this.VL_EXTENDS_II = function(x,lbits,lhs) {
    return VL_EXTENDSIGN_I(lbits,lhs) | lhs;
  }

  var VL_EXTEND_II = this.VL_EXTEND_II = function(obits,lbits,lhs) { return lhs; }

  var VL_NEGATE_I = this.VL_NEGATE_I = function(x) { return -x; }

  var VL_LTS_III = this.VL_LTS_III = function(x,lbits,y,lhs,rhs) {
    return (VL_EXTENDS_II(x,lbits,lhs) < VL_EXTENDS_II(x,lbits,rhs)) ? 1 : 0; }

  var VL_GTS_III = this.VL_GTS_III = function(x,lbits,y,lhs,rhs) {
    return (VL_EXTENDS_II(x,lbits,lhs) > VL_EXTENDS_II(x,lbits,rhs)) ? 1 : 0; }

  var VL_LTES_III = this.VL_LTES_III = function(x,lbits,y,lhs,rhs) {
    return (VL_EXTENDS_II(x,lbits,lhs) <= VL_EXTENDS_II(x,lbits,rhs)) ? 1 : 0; }

  var VL_GTES_III = this.VL_GTES_III = function(x,lbits,y,lhs,rhs) {
    return (VL_EXTENDS_II(x,lbits,lhs) >= VL_EXTENDS_II(x,lbits,rhs)) ? 1 : 0; }

  var VL_MODDIV_III = this.VL_MODDIV_III = function(lbits,lhs,rhs) {
    return (((rhs)==0)?0:(lhs)%(rhs)); }

  var VL_MODDIVS_III = this.VL_MODDIVS_III = function(lbits,lhs,rhs) {
    return (((rhs)==0)?0:(lhs)%(rhs)); }

  var VL_REDXOR_32 = this.VL_REDXOR_32 = function(r) {
    r=(r^(r>>1)); r=(r^(r>>2)); r=(r^(r>>4)); r=(r^(r>>8)); r=(r^(r>>16));
    return r;
  }

  var VL_WRITEF = this.VL_WRITEF = console.log; // TODO: $write

  var vl_finish = this.vl_finish = function(filename,lineno,hier) {
    console.log("Finished at " + filename + ":" + lineno, hier);
    vl_finished = true;
  }
  var vl_stop = this.vl_stop = function(filename,lineno,hier) {
    console.log("Stopped at " + filename + ":" + lineno, hier);
    vl_stopped = true;
  }

  var VL_RAND_RESET_I = this.VL_RAND_RESET_I = function(bits) { return 0 | Math.floor(Math.random() * (1<<bits)); }

  var VL_RANDOM_I = this.VL_RANDOM_I = function(bits) { return 0 | Math.floor(Math.random() * (1<<bits)); }

//

function VerilatorBase() {

  //

  var totalTicks = 0;

  function vl_fatal(msg) {
    console.log(msg);
  }

  this.ticks = function() { return totalTicks; }
  this.setTicks = function(T) { totalTicks = T|0; }

  this.__reset = function() {
    if (this.reset !== undefined) {
      totalTicks = 0;
      this.reset = 0;
      this.tick2();
      this.reset = 1;
    }
  }

  this.__unreset = function() {
    if (this.reset !== undefined) {
      this.reset = 0;
    }
  }

  this.tick2 = function() {
    this.clk = 0;
    this.eval();
    this.clk = 1;
    this.eval();
  }

  var vlSymsp = this; //{TOPp:this};
  var maxVclockLoop = 1;

  this.eval = function() {
    // Initialize
    if (!vlSymsp.__Vm_didInit)
      this._eval_initial_loop(vlSymsp);
    // Evaluate till stable
    //VL_DEBUG_IF(VL_PRINTF("\n----TOP Evaluate Vmain::eval\n"); );
    var __VclockLoop = 0;
    var __Vchange=1;
    while (__Vchange) {
        //VL_DEBUG_IF(VL_PRINTF(" Clock loop\n"););
        vlSymsp.__Vm_activity = true;
        this._eval(vlSymsp);
        __Vchange = this._change_request(vlSymsp);
        if (++__VclockLoop > 100) { vl_fatal("Verilated model didn't converge"); }
    }
    if (__VclockLoop > maxVclockLoop) {
      maxVclockLoop = __VclockLoop;
      console.log("Graph took " + maxVclockLoop + " iterations to stabilize");
    }
    totalTicks++;
  }

  this._eval_initial_loop = function(vlSymsp) {
    vlSymsp.TOPp = this;
    vlSymsp.__Vm_didInit = true;
    this._eval_initial(vlSymsp);
    vlSymsp.__Vm_activity = true;
    var __VclockLoop = 0;
    var __Vchange=1;
    while (__Vchange) {
        this._eval_settle(vlSymsp);
        this._eval(vlSymsp);
        __Vchange = this._change_request(vlSymsp);
        if (++__VclockLoop > 100) { vl_fatal("Verilated model didn't DC converge"); }
    }
  }
}

var VerilogPlatform = function(mainElement, options) {
  var self = this;
  var video, audio;
  var useAudio = false;
  var videoWidth  = 292;
  var videoHeight = 256;
  var maxVideoLines = 262+40; // vertical hold
  var idata, timer, timerCallback;
  var gen;
  var cyclesPerFrame = (256+23+7+23)*262; // 4857480/60 Hz
  var current_output;
  var paddle_x = 0;
  var paddle_y = 0;
  var switches = [0,0,0];
  var inspect_obj, inspect_sym;
  var inspect_data = new Uint32Array(videoWidth * videoHeight);
  var scope_time_x = 0; // scope cursor
  var scope_x_offset = 0;
  var scope_y_offset = 0;
  var scope_index_offset = 0;
  var scope_max_y = 0;
  var scope_y_top = 0;
  var scope_a = 0; // used for transitions
  var scopeWidth = videoWidth;
  var scopeHeight = videoHeight;
  var scopeImageData;
  var sdata; // scope data
  var module_name;

  var yposlist = [];
  var lasty = [];
  var lastval = [];
  var trace_ports;
  var trace_signals;
  var trace_buffer;
  var trace_index;
  var mouse_pressed;
  var dirty = false;

  this.getPresets = function() { return VERILOG_PRESETS; }

  var RGBLOOKUP = [
    0xff222222,
    0xff2222ff,
    0xff22ff22,
    0xff22ffff,
    0xffff2222,
    0xffff22ff,
    0xffffff22,
    0xffffffff,
    0xff999999,
    0xff9999ff,
    0xff99ff99,
    0xff99ffff,
    0xffff9999,
    0xffff99ff,
    0xffffff99,
    0xff666666,
  ];

  var debugCond;

  function vidtick() {
    gen.tick2();
    if (useAudio)
      audio.feedSample(gen.spkr*(1.0/255.0), 1);
    if (debugCond && debugCond())
      debugCond = null;
  }

  function updateInspectionFrame() {
    useAudio = false;
    if (inspect_obj && inspect_sym) {
      var COLOR_BIT_OFF = 0xffff6666;
      var COLOR_BIT_ON  = 0xffff9999;
      var i = videoWidth;
      for (var y=0; y<videoHeight-2; y++) {
        for (var x=0; x<videoWidth; x++) {
          var val = inspect_data[i];
          idata[i++] = (val & 1) ? COLOR_BIT_ON : COLOR_BIT_OFF;
        }
      }
    }
  }

  function updateInspectionPostFrame() {
    if (inspect_obj && inspect_sym) {
      var ctx = video.getContext();
      var val = inspect_data[inspect_data.length-1];
      ctx.fillStyle = "black";
      ctx.fillRect(18, videoHeight-8, 30, 8);
      ctx.fillStyle = "white";
      ctx.fillText(val.toString(10), 20, videoHeight-1);
    }
  }

  var framex=0;
  var framey=0;
  var frameidx=0;
  var framehsync=false;
  var framevsync=false;

  function updateVideoFrameCycles(ncycles, sync, trace) {
    ncycles |= 0;
    var inspect = inspect_obj && inspect_sym;
    while (ncycles--) {
      if (trace) snapshotTrace(true);
      vidtick();
      if (framex++ < videoWidth) {
        if (framey < videoHeight) {
          if (inspect) {
            inspect_data[frameidx] = inspect_obj[inspect_sym];
          }
          idata[frameidx] = RGBLOOKUP[gen.rgb & 15];
          frameidx++;
        }
      } else if (!framehsync && gen.hsync) {
        framehsync = true;
      } else if ((framehsync && !gen.hsync) || framex > videoWidth*2) {
        framehsync = false;
        framex = 0;
        framey++;
        gen.hpaddle = framey > paddle_x ? 1 : 0;
        gen.vpaddle = framey > paddle_y ? 1 : 0;
      }
      if (framey > maxVideoLines || gen.vsync) {
        framevsync = true;
        framey = 0;
        framex = 0;
        frameidx = 0;
        gen.hpaddle = 0;
        gen.vpaddle = 0;
      } else {
        var wasvsync = framevsync;
        framevsync = false;
        if (sync && wasvsync) return; // exit when vsync ends
      }
    }
  }

  function updateVideoFrame() {
    useAudio = (audio != null);
    debugCond = self.getDebugCallback();
    gen.switches_p1 = switches[0];
    gen.switches_p2 = switches[1];
    gen.switches_gen = switches[2];
    var fps = self.getFrameRate();
    // darken the previous frame?
    if (fps < 45) {
      var mask = fps > 5 ? 0xe7ffffff : 0x7fdddddd;
      for (var i=0; i<idata.length; i++)
        idata[i] &= mask;
    }
    // paint into frame, synched with vsync if full speed
    var sync = fps > 45;
    var trace = fps < 0.02;
    updateVideoFrameCycles(cyclesPerFrame * fps/60 + 1, sync, trace);
    //if (trace) displayTraceBuffer();
    self.restartDebugState();
    gen.__unreset();
    refreshVideoFrame();
  }
  
  function refreshVideoFrame() {
    updateInspectionFrame();
    updateAnimateScope();
    updateInspectionPostFrame();
  }

  function updateFrame() {
    if (!gen) return;
    if (gen.vsync !== undefined && gen.hsync !== undefined && gen.rgb !== undefined)
      updateVideoFrame();
    else
      updateScopeFrame();
  }

  function refreshFrame() {
    if (!gen) return;
    if (gen.vsync !== undefined && gen.hsync !== undefined && gen.rgb !== undefined)
      refreshVideoFrame();
    else
      refreshScopeOverlay(trace_ports);
  }

  function updateAnimateScope() {
    var fps = self.getFrameRate();
    var trace = fps < 0.02;
    var ctx = video.getContext();
    if (scope_a > 0.01) {
      ctx.fillStyle = "black";
      ctx.fillRect(0, 0, videoWidth, videoHeight);
      var vidyoffset = Math.round(scope_a*(-framey+videoHeight/6));
      video.updateFrame(0, vidyoffset, 0, 0, videoWidth, videoHeight);
      ctx.fillStyle = "white";
      ctx.fillRect(framex, framey+vidyoffset, 1, 1);
      scope_index_offset = (trace_index - trace_signals.length*scopeWidth + trace_buffer.length) % trace_buffer.length;
      scope_x_offset = 0;
      refreshScopeOverlay(trace_signals);
    } else {
      video.updateFrame();
      scope_index_offset = 0;
    }
    // smooth transition
    scope_a = scope_a * 0.9 + (trace?1.0:0.0) * 0.1;
    scope_y_top = (1 - scope_a*0.7) * videoHeight - (1 - scope_a) * scope_y_offset;
  }

  function displayTraceBuffer() {
    var skip = trace_signals.length;
    var src = trace_index;
    for (var dest=0; dest<idata.length; dest+=videoWidth) {
      for (var i=0; i<skip; i++) {
        if (--src < 0) src = trace_buffer.length-1;
        var v = trace_buffer[src];
        idata[dest+i] = RGBLOOKUP[v & 15]; // TODO?
      }
    }
  }

  function snapshotTrace(signals) {
    var arr = signals ? trace_signals : trace_ports;
    for (var i=0; i<arr.length; i++) {
      var v = arr[i];
      var z = gen[v.name];
      trace_buffer[trace_index++] = z;
      if (trace_index >= trace_buffer.length) trace_index = 0;
    }
  }

  function fillTraceBuffer(count) {
    var max_index = Math.min(trace_buffer.length - trace_ports.length, trace_index + count);
    while (trace_index < max_index) {
      gen.clk ^= 1;
      gen.eval();
      snapshotTrace(false);
      dirty = true;
    }
    gen.__unreset();
  }

  function shadowText(ctx, txt, x, y) {
    ctx.shadowColor = "black";
    ctx.shadowBlur = 0;
    ctx.shadowOffsetY = -1;
    ctx.shadowOffsetX = 0;
    ctx.fillText(txt, x, y);
    ctx.shadowOffsetY = 1;
    ctx.shadowOffsetX = 0;
    ctx.fillText(txt, x, y);
    ctx.shadowOffsetY = 0;
    ctx.shadowOffsetX = -1;
    ctx.fillText(txt, x, y);
    ctx.shadowOffsetY = 0;
    ctx.shadowOffsetX = 1;
    ctx.fillText(txt, x, y);
    ctx.shadowOffsetX = 0;
  }

  function updateScopeFrame() {
    fillTraceBuffer(Math.floor(videoWidth/4) * trace_ports.length);
    if (!dirty) return;
    dirty = false;
    scope_y_top = 0;
    refreshScopeOverlay(trace_ports);
  }

  function refreshScopeOverlay(arr) {
    if (!sdata) {
      scopeImageData = video.getContext().createImageData(scopeWidth,scopeHeight);
      sdata = new Uint32Array(scopeImageData.data.buffer);
    }
    var COLOR_BLACK  = 0xff000000;
    var COLOR_SIGNAL = 0xff22ff22;
    var COLOR_BORDER = 0xff662222;
    var COLOR_TRANS_SIGNAL = 0xff226622;
    var COLOR_BLIP_SIGNAL = 0xff226622;
    sdata.fill(0xff000000);
    var jstart = scope_x_offset * arr.length + scope_index_offset;
    var j = jstart;
    for (var x=0; x<scopeWidth; x++) {
      var yb = 8;
      var y1 = scope_y_offset;
      for (var i=0; i<arr.length; i++) {
        var v = arr[i];
        var lo = 0; // TODO? v.ofs?
        var hi = ((1 << v.len)-1);
        var ys = hi>1 ? v.len*2+8 : 8;
        var y2 = y1+ys;
        var z = trace_buffer[j++];
        if (j >= trace_buffer.length) j = 0;
        var y = Math.round(y2 - ys*((z-lo)/hi));
        yposlist[i] = y2 + scope_y_top;
        var ly = lasty[i];
        if (x > 0 && ly != y) {
          var dir = ly < y ? 1 : -1;
          while ((ly += dir) != y && ly >= y1 && ly <= y2) {
            sdata[x + ly * scopeWidth] = COLOR_TRANS_SIGNAL;
          }
        }
        sdata[x + y * scopeWidth] = lastval[i]==z ? COLOR_SIGNAL : COLOR_BLIP_SIGNAL;
        lasty[i] = y;
        lastval[i] = z;
        y1 += ys+yb;
      }
    }
    scope_max_y = y1 - scope_y_offset;
    video.getContext().putImageData(scopeImageData, 0, scope_y_top);
    // draw labels
    var ctx = video.getContext();
    for (var i=0; i<arr.length; i++) {
      var yp = yposlist[i];
      if (yp < 20 || yp > videoHeight) continue;
      var v = arr[i];
      var name = v.name;
      ctx.fillStyle = name == inspect_sym ? "yellow" : "white";
      name = name.replace(/__DOT__/g,'.');
      name = name.replace(module_name+'.','');
      ctx.textAlign = 'left';
      ctx.fillStyle = "white";
      shadowText(ctx, name, 1, yposlist[i]);
      if (scope_time_x > 0) {
        ctx.textAlign = 'right';
        var value = (arr.length * scope_time_x + i + jstart) % trace_buffer.length;
        shadowText(ctx, ""+trace_buffer[value], videoWidth-1, yp);
      }
    }
    // draw scope line & label
    if (scope_time_x > 0) {
      ctx.fillStyle = "cyan";
      shadowText(ctx, ""+(scope_time_x+scope_x_offset),
        (scope_time_x>10)?(scope_time_x-2):(scope_time_x+20), videoHeight-2);
      ctx.fillRect(scope_time_x, 0, 1, 4000);
    }
    // scroll left/right
    if (scope_time_x >= videoWidth && scope_x_offset < (trace_buffer.length / arr.length) - videoWidth) {
      scope_x_offset += 1 + (scope_time_x - videoWidth);
      dirty = true;
    }
    else if (scope_time_x < 0 && scope_x_offset > 0) {
      scope_x_offset = Math.max(0, scope_x_offset + scope_time_x);
      dirty = true;
    }
  }

  function clamp(minv,maxv,v) {
    return (v < minv) ? minv : (v > maxv) ? maxv : v;
  }

  this.start = function() {
    video = new RasterVideo(mainElement,videoWidth,videoHeight);
    video.create();
    var ctx = video.getContext();
    ctx.font = "8px TinyFont";
    ctx.fillStyle = "white";
    ctx.textAlign = "left";
    setKeyboardFromMap(video, switches, VERILOG_KEYCODE_MAP);
    var vcanvas = $(video.canvas);
		vcanvas.mousemove(function(e) {
      var new_x = Math.floor(e.offsetX * video.canvas.width / vcanvas.width() - 20);
      var new_y = Math.floor(e.offsetY * video.canvas.height / vcanvas.height() - 20);
      if (mouse_pressed) {
        scope_y_offset = clamp(Math.min(0,-scope_max_y+videoHeight), 0, scope_y_offset + new_y - paddle_y);
  			scope_time_x = Math.floor(e.offsetX * video.canvas.width / vcanvas.width() - 16);
  			dirty = true;
        refreshFrame();
      }
			paddle_x = clamp(8, 240, new_x);
			paddle_y = clamp(8, 240, new_y);
		});
		vcanvas.mousedown(function(e) {
			scope_time_x = Math.floor(e.offsetX * video.canvas.width / vcanvas.width() - 16);
      mouse_pressed = true;
      //if (e.target.setCapture) e.target.setCapture(); // TODO: pointer capture
			dirty = true;
      refreshFrame();
		});
		vcanvas.mouseup(function(e) {
      mouse_pressed = false;
      //if (e.target.setCapture) e.target.releaseCapture(); // TODO: pointer capture
  		dirty = true;
      refreshFrame();
		});
		vcanvas.keydown(function(e) {
      switch (e.keyCode) {
        case 37: scope_time_x--; dirty=true; refreshFrame(); break;
        case 39: scope_time_x++; dirty=true; refreshFrame(); break;
      }
		});
    idata = video.getFrameData();
    timerCallback = function() {
			if (!self.isRunning())
				return;
      gen.switches = switches[0];
      updateFrame();
    };
    trace_buffer = new Uint32Array(0x10000);
    self.setFrameRate(60);
  }
  
  this.printErrorCodeContext = function(e, code) {
    if (e.lineNumber && e.message) {
      var lines = code.split('\n');
      var s = e.message + '\n';
      for (var i=0; i<lines.length; i++) {
        if (i > e.lineNumber-5 && i < e.lineNumber+5) {
          s += lines[i] + '\n';
        }
      }
      console.log(s);
    }
  }

  this.loadROM = function(title, output) {
    var mod;
    if (output.code) {
      // is code identical?
      if (current_output && current_output.code == output.code) {
      } else {
        try {
          mod = new Function('base', output.code);
        } catch (e) {
          this.printErrorCodeContext(e, output.code);
          throw e;
        }
        // compile Verilog code
        var base = new VerilatorBase();
        gen = new mod(base);
        //$.extend(gen, base);
        gen.__proto__ = base;
        current_output = output;
        module_name = output.name ? output.name.substr(1) : "top";
        trace_ports = current_output.ports;
        trace_signals = current_output.ports.concat(current_output.signals);
        trace_index = 0;
        // power on module
        this.poweron();
      }
    }
    // replace program ROM, if using the assembler
    if (output.program_rom && output.program_rom_variable) {
      if (gen[output.program_rom_variable]) {
        if (gen[output.program_rom_variable].length != output.program_rom.length)
          alert("ROM size mismatch -- expected " + gen[output.program_rom_variable].length + " got " + output.program_rom.length);
        else
          gen[output.program_rom_variable] = output.program_rom;
      } else {
        alert("No program_rom variable found (" + output.program_rom_variable + ")");
      }
      this.reset();
    }
    // restart audio
    restartAudio();
  }

  function restartAudio() {
    // stop/start audio
    var hasAudio = gen && gen.spkr !== undefined && frameRate > 1;
    if (audio && !hasAudio) {
      audio.stop();
      audio = null;
    } else if (!audio && hasAudio) {
      audio = new SampleAudio(cyclesPerFrame * self.getFrameRate());
      if (self.isRunning())
        audio.start();
    }
  }

  this.isRunning = function() {
    return timer && timer.isRunning();
  }
  this.pause = function() {
    timer.stop();
    if (audio) audio.stop();
  }
  this.resume = function() {
    timer.start();
    if (audio) audio.start();
  }

  var frameRate = 0;

  this.setFrameRate = function(rateHz) {
    frameRate = rateHz;
    var fps = Math.min(60, rateHz*cyclesPerFrame);
    if (!timer || timer.frameRate != fps) {
      var running = this.isRunning();
      if (timer) timer.stop();
      timer = new AnimationTimer(fps, timerCallback);
      if (running) timer.start();
    }
    if (audio) {
      audio.stop();
      audio = null;
    }
    restartAudio();
  }
  this.getFrameRate = function() { return frameRate; }

  this.poweron = function() {
    gen._ctor_var_reset();
    this.reset();
  }
  this.reset = function() {
    gen.__reset();
    trace_index = scope_x_offset = 0;
    if (trace_buffer) trace_buffer.fill(0);
    dirty = true;
    if (video) video.setRotate(gen.rotate ? -90 : 0);
  }
  this.tick = function() {
    gen.tick2();
  }
  this.getToolForFilename = function(fn) {
    if (fn.endsWith("asm"))
      return "jsasm";
    else
      return "verilator";
  }
  this.getDefaultExtension = function() { return ".v"; };

  this.inspect = function(name) {
    if (!gen) return;
    if (name && !name.match(/^\w+$/)) return;
    var val = gen[name];
    if (val === undefined && current_output.code) {
      var re = new RegExp("(\\w+__DOT__" + name + ")\\b", "gm");
      var m = re.exec(current_output.code);
      if (m) {
        name = m[1];
        val = gen[name];
      }
    }
    if (typeof(val) === 'number') {
      inspect_obj = gen;
      inspect_sym = name;
    } else {
      inspect_obj = inspect_sym = null;
    }
    dirty = true;
  }

  // DEBUGGING

  this.saveState = function() {
    return {T:gen.ticks(), o:$.extend(true, {}, gen)};
  }
  this.loadState = function(state) {
    gen = $.extend(true, gen, state.o);
    gen.setTicks(state.T);
  }

  var onBreakpointHit;
  var debugCondition;
  var debugSavedState = null;
  var debugBreakState = null;
  var debugTargetClock = 0;

  this.setDebugCondition = function(debugCond) {
    if (debugSavedState) {
      this.loadState(debugSavedState);
    } else {
      debugSavedState = this.saveState();
    }
    debugCondition = debugCond;
    debugBreakState = null;
    this.resume();
  }
  this.restartDebugState = function() {
    if (debugCondition && !debugBreakState) {
      debugSavedState = this.saveState();
      if (debugTargetClock > 0)
        debugTargetClock -= debugSavedState.T;
      debugSavedState.T = 0;
      this.loadState(debugSavedState);
    }
  }
  this.getDebugCallback = function() {
    return debugCondition;
  }
  this.setupDebug = function(callback) {
    onBreakpointHit = callback;
  }
  this.clearDebug = function() {
    debugSavedState = null;
    debugBreakState = null;
    debugTargetClock = 0;
    onBreakpointHit = null;
    debugCondition = null;
  }
  this.breakpointHit = function(targetClock) {
    debugTargetClock = targetClock;
    debugBreakState = this.saveState();
    console.log("Breakpoint at clk", debugBreakState.T);
    this.pause();
    if (onBreakpointHit) {
      onBreakpointHit(debugBreakState);
    }
  }
  this.wasBreakpointHit = function() {
    return debugBreakState != null;
  }
  this.step = function() {
    var self = this;
    this.setDebugCondition(function() {
      if (gen.ticks() > debugTargetClock) {
        self.breakpointHit(gen.ticks());
        return true;
      }
      return false;
    });
  }
  this.runToVsync = function() {
    var self = this;
    this.setDebugCondition(function() {
      if (gen.vsync && gen.ticks() > debugTargetClock+2000) {
        self.breakpointHit(gen.ticks());
        return true;
      }
      return false;
    });
  }
  this.stepBack = function() {
    var self = this;
    var prevState;
    var prevClock;
    this.setDebugCondition(function() {
      var debugClock = gen.ticks();
      if (debugClock >= debugTargetClock && prevState) {
        self.loadState(prevState);
        self.breakpointHit(prevClock);
        return true;
      } else if (debugClock >= debugTargetClock-2 && debugClock < debugTargetClock) {
        prevState = self.saveState();
        prevClock = debugClock;
      }
      return false;
    });
  }
  this.runEval = function(evalfunc) {
    var self = this;
    this.setDebugCondition(function() {
			if (gen.ticks() > debugTargetClock) {
        if (evalfunc(gen)) {
          self.breakpointHit(gen.ticks());
          return true;
        }
      }
			return false;
    });
  }

};

////////////////

PLATFORMS['verilog'] = VerilogPlatform;