import { newPOKEYAudio, TssChannelAdapter } from "../common/audio";
import { EmuState, Machine } from "../common/baseplatform";
import { MOS6502 } from "../common/cpu/MOS6502";
import { AcceptsKeyInput, AcceptsPaddleInput, AcceptsROM, BasicScanlineMachine, FrameBased, Probeable, RasterFrameBased, TrapCondition, VideoSource } from "../common/devices";
import { dumpRAM, KeyFlags, Keys, makeKeycodeMap, newAddressDecoder, newKeyboardHandler } from "../common/emu";
import { hex, lpad, lzgmini, rgb2bgr, stringToByteArray } from "../common/util";
import { BaseWASIMachine } from "../common/wasmplatform";

const ATARI8_KEYMATRIX_INTL_NOSHIFT = [
  Keys.VK_L, Keys.VK_J, Keys.VK_SEMICOLON, Keys.VK_F1, Keys.VK_F2, Keys.VK_K, Keys.VK_SLASH, Keys.VK_TILDE,
  Keys.VK_O, null, Keys.VK_P, Keys.VK_U, Keys.VK_ENTER, Keys.VK_I, Keys.VK_MINUS, Keys.VK_EQUALS,
  Keys.VK_V, Keys.VK_F8, Keys.VK_C, Keys.VK_F3, Keys.VK_F4, Keys.VK_B, Keys.VK_X, Keys.VK_Z,
  Keys.VK_4, null, Keys.VK_3, Keys.VK_6, Keys.VK_ESCAPE, Keys.VK_5, Keys.VK_2, Keys.VK_1,
  Keys.VK_COMMA, Keys.VK_SPACE, Keys.VK_PERIOD, Keys.VK_N, null, Keys.VK_M, Keys.VK_SLASH, null/*invert*/,
  Keys.VK_R, null, Keys.VK_E, Keys.VK_Y, Keys.VK_TAB, Keys.VK_T, Keys.VK_W, Keys.VK_Q,
  Keys.VK_9, null, Keys.VK_0, Keys.VK_7, Keys.VK_BACK_SPACE, Keys.VK_8, Keys.VK_LEFT, Keys.VK_RIGHT,
  Keys.VK_F, Keys.VK_H, Keys.VK_D, null, Keys.VK_CAPS_LOCK, Keys.VK_G, Keys.VK_S, Keys.VK_A,
];

//TODO
var ATARI8_KEYCODE_MAP = makeKeycodeMap([
  [Keys.UP, 0, 0x1],
  [Keys.DOWN, 0, 0x2],
  [Keys.LEFT, 0, 0x4],
  [Keys.RIGHT, 0, 0x8],
  [Keys.VK_SPACE, 2, 0x1],
  /*
    [Keys.P2_UP, 0, 0x10],
    [Keys.P2_DOWN, 0, 0x20],
    [Keys.P2_LEFT, 0, 0x40],
    [Keys.P2_RIGHT, 0, 0x80],
    [Keys.P2_A, 3, 0x1],
  */
    [Keys.START, 3, 0x1],
    [Keys.SELECT, 3, 0x2],
    [Keys.VK_OPEN_BRACKET, 3, 0x4],
  ]);

// ANTIC

// https://www.atarimax.com/jindroush.atari.org/atanttim.html
// http://www.virtualdub.org/blog/pivot/entry.php?id=243
// http://www.beipmu.com/Antic_Timings.txt
// https://user.xmission.com/~trevin/atari/antic_regs.html
// https://user.xmission.com/~trevin/atari/antic_insns.html
// http://www.atarimuseum.com/videogames/consoles/5200/conv_to_5200.html
// https://www.virtualdub.org/downloads/Altirra%20Hardware%20Reference%20Manual.pdf

const PF_LEFT = [999, 26, 18, 10];
const PF_RIGHT = [999, 26 + 64, 18 + 80, 10 + 96];

const DMACTL = 0;
const CHACTL = 1;
const DLISTL = 2;
const DLISTH = 3;
const HSCROL = 4;
const VSCROL = 5;
const PMBASE = 7;
const CHBASE = 9;
const WSYNC = 10;
const VCOUNT = 11;
const PENH = 12;
const PENV = 13;
const NMIEN = 14;
const NMIRES = 15;
const NMIST = 15;

const PFNONE = 0;
const PFNARROW = 1;
const PFNORMAL = 2;
const PFWIDE = 3;

const NMIST_CYCLE = 12;
const NMI_CYCLE = 24;
const WSYNC_CYCLE = 212;

const MODE_LINES = [0, 0, 8, 10, 8, 16, 8, 16, 8, 4, 4, 2, 1, 2, 1, 1];
// how many bits before DMA clock repeats?
const MODE_PERIOD = [0, 0, 2, 2, 2, 2, 4, 4, 8, 4, 4, 4, 4, 2, 2, 2];
const MODE_YPERIOD = [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1, 0, 0, 0, 0];
//const MODE_BPP = [0, 0, 1, 1, 2, 2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 1];
// how many color clocks / pixel * 2
const MODE_SHIFT = [0, 0, 1, 1, 2, 2, 2, 2, 8, 4, 4, 2, 2, 2, 2, 1];

class ANTIC {
  regs = new Uint8Array(0x10);				// registers
  read: (address: number) => number;	// bus read function
  nmiPending: boolean = false;

  // derived by registers
  pfwidth: number;				// playfield width
  left: number;
  right: number;					// left/right clocks for mode

  // a la minute
  dliop: number = 0;    // dli operation
  mode: number = 0;			// current mode
  jmp = false; // TODO
  lms = false; // TODO
  dlarg_lo: number = 0;
  dlarg_hi: number = 0;
  period: number = 0;		// current mode period bitmask
  scanaddr: number = 0;  // Scan Address (via LMS)
  startaddr: number = 0;	// Start of line Address
  pfbyte: number = 0;		// playfield byte fetched
  ch: number = 0;				// char read
  linesleft: number = 0; // # of lines left in mode
  yofs: number = 0;			// yofs fine
  v: number = 0;					// vertical scanline #
  h: number = 0;					// horizontal color clock

  linebuf = new Uint8Array(48);
  dmaclock: number = 0;
  dmaidx: number = 0;
  output: number = 0;
  dramrefresh = false;

  constructor(readfn) {
    this.read = readfn; // bus read function
  }
  reset() {
    this.regs.fill(0);
    this.regs[NMIEN] = 0x00;
    this.regs[NMIST] = 0x7f;
    this.regs[PENH] = 0x00;
    this.regs[PENV] = 0xff;
    this.setReg(DMACTL, 0x0);
    this.h = this.v = 0;
    this.startaddr = this.scanaddr = 0;
    this.dmaclock = 0;
  }
  saveState() {
    return {
      regs: this.regs.slice(0),
      mode: this.mode,
      period: this.period,
      scanaddr: this.scanaddr,
      startaddr: this.startaddr,
      pfbyte: this.pfbyte,
      ch: this.ch,
      linesleft: this.linesleft,
      yofs: this.yofs,
      v: this.v,
      h: this.h,
      linebuf: this.linebuf.slice(0),
      dmaidx: this.dmaidx,
      dmaclock: this.dmaclock,
      output: this.output,
      dramrefresh: this.dramrefresh,
    };
  }
  loadState(s) {
    this.regs.set(s.regs);
    this.setReg(DMACTL, s.regs[DMACTL]);
    this.mode = s.mode;
    this.period = s.period;
    this.scanaddr = s.scanaddr;
    this.startaddr = s.startaddr;
    this.pfbyte = s.pfbyte;
    this.ch = s.ch;
    this.linesleft = s.linesleft;
    this.yofs = s.yofs;
    this.v = s.v;
    this.h = s.h;
    this.linebuf.set(s.linebuf);
    this.dmaidx = s.dmaidx;
    this.dmaclock = s.dmaclock;
    this.output = s.output;
    this.dramrefresh = s.dramrefresh;
  }
  static stateToLongString(state): string {
    let s = "";
    s += "H: " + lpad(state.h, 3) + " V: " + lpad(state.v, 3) + " Linesleft: " + state.linesleft + "\n";
    s += "Mode: " + hex(state.mode, 2) + " Period: " + (state.period + 1) + "\n";
    s += "Addr: " + hex(state.scanaddr, 4) + "\n";
    s += dumpRAM(state.regs, 0, 16).replace('$00', 'Regs');
    return s;
  }
  setReg(a: number, v: number) {
    this.regs[a] = v;
    switch (a) {
      case WSYNC:
        this.regs[WSYNC] = 0xff;
        break;
      case DMACTL:
        this.pfwidth = this.regs[DMACTL] & 3;
        this.setLeftRight();
        break;
      case NMIRES:
        this.regs[NMIST] = 0x1f;
        break;
    }
  }
  setLeftRight() {
    //let offset = 4 << MODE_PERIOD[this.mode & 0xf];
    this.left = PF_LEFT[this.pfwidth];
    this.right = PF_RIGHT[this.pfwidth];
  }
  readReg(a: number) {
    switch (a) {
      case NMIST:
        return this.regs[a];
      case VCOUNT:
        return this.v >> 1;
      default:  
        return 0xff;
    }
  }
  processDLIEntry() {
    if (this.mode == 0) { // N Blank Lines
      this.linesleft = (this.dliop >> 4) + 1;
    } else {
      this.linesleft = MODE_LINES[this.mode];
      this.period = MODE_PERIOD[this.mode];
      if (this.jmp) {
        this.regs[DLISTL] = this.dlarg_lo;
        this.regs[DLISTH] = this.dlarg_hi;
        this.mode = 0;
        // JVB (Jump and wait for Vertical Blank)
        if (this.dliop & 0x40) {
          this.linesleft = (248 - this.v) & 0xff; // TODO?
        }
      } else if (this.lms) {
        this.scanaddr = this.dlarg_lo + (this.dlarg_hi << 8);
        //console.log('scanaddr', hex(this.scanaddr));
      }
      this.startaddr = this.scanaddr;
    }
  }

  processLine() {
    if (this.linesleft > 0) {
      this.linesleft--;
      this.yofs++;
      if (this.mode >= 8 && this.linesleft) {
        this.scanaddr = this.startaddr; // reset line addr
      }
    }
  }

  triggerNMI(mask: number) {
    if (this.regs[NMIEN] & mask) {
      this.nmiPending = true;
    }
    this.regs[NMIST] = mask | 0x1f;
  }

  nextInsn(): number {
    let pc = this.regs[DLISTL] + (this.regs[DLISTH] << 8);
    let b = this.read(pc);
    //console.log('nextInsn', hex(pc), hex(b), this.v);
    pc = ((pc + 1) & 0x3ff) | (pc & ~0x3ff);
    this.regs[DLISTL] = pc & 0xff;
    this.regs[DLISTH] = pc >> 8;
    return b;
  }

  nextScreen(): number {
    let b = this.read(this.scanaddr);
    this.scanaddr = ((this.scanaddr + 1) & 0xfff) | (this.scanaddr & ~0xfff);
    return b;
  }

  dlDMAEnabled() { return this.regs[DMACTL] & 0b100000; }
  pmDMAEnabled() { return this.regs[DMACTL] & 0b001100; }

  isVisibleScanline() {
    return this.v >= 8 && this.v < 248;
  }
  isPlayfieldDMAEnabled() {
    return this.dlDMAEnabled() && !this.linesleft;
  }
  isPlayerDMAEnabled() {
    return this.regs[DMACTL] & 0b1000;
  }
  isMissileDMAEnabled() {
    return this.regs[DMACTL] & 0x1100;
  }

  clockPulse(): boolean {
    let dma = this.regs[WSYNC] != 0;
    if (!this.isVisibleScanline()) {
      this.doVBlank();
    } else {
      switch (this.h) {
        case 0:
          if (this.isMissileDMAEnabled()) {
            this.doPlayerMissileDMA(3);
            dma = true;
          }
          break;
        case 1:
          if (this.isPlayfieldDMAEnabled()) {
            let op = this.nextInsn(); // get mode
            // TODO: too many booleans
            this.jmp = (op & ~0x40) == 0x01; // JMP insn?
            this.lms = (op & 0x40) != 0 && (op & 0xf) != 0; // LMS insn?
            this.mode = op & 0xf;
            this.dliop = op;
            this.yofs = 0;
            dma = true;
          }
          break;
        case 2: case 3: case 4: case 5:
          if (this.isPlayerDMAEnabled()) {
            this.doPlayerMissileDMA(6 - this.h);
            dma = true;
          }
          break;
        case 6:
        case 7:
          if (this.yofs == 0 && this.isPlayfieldDMAEnabled() && (this.jmp || this.lms)) { // read extra bytes?
            if (this.h == 6) this.dlarg_lo = this.nextInsn();
            if (this.h == 7) this.dlarg_hi = this.nextInsn();
            dma = true;
          }
          break;
        case 9:
          if (this.yofs == 0) {
            this.processDLIEntry();
          }
          break;
        case 8:
          if (this.dliop & 0x80) { // TODO: what if DLI disabled?
            if (this.linesleft == 1) {
              this.triggerNMI(0x80); // DLI interrupt
            }
          }
          break;
        case 111:
          this.processLine();
          ++this.v;
          break;
      }
      this.output = 0; // background color (TODO: only for blank lines)
      if (this.mode >= 2) {
        let candma = this.h < 106;
        this.dmaclock <<= 1;
        if (this.dmaclock & (1 << this.period)) {
          this.dmaclock |= 1;
        }
        if (this.h == this.left) { this.dmaclock |= 1; this.dmaidx = 0; }
        if (this.h == this.right) { this.dmaclock &= ~1; this.dmaidx++; }
        if (this.dmaclock & 1) {
          if (this.mode < 8 && this.yofs == 0) { // only read chars on 1st line
            this.linebuf[this.dmaidx] = this.nextScreen(); // read char name
            dma = candma;
          }
          this.dmaidx++;
        } else if (this.dmaclock & 8) {
          this.ch = this.linebuf[this.dmaidx - 4 / this.period]; // latch char
          this.readBitmapData(); // read bitmap
          dma = candma;
        }
        this.output = this.h >= this.left + 3 && this.h <= this.right + 2 ? 4 : 0;
      }
    }
    if (this.h < 19 || this.h > 102) this.output = 2;
    this.incHorizCounter();
    if (!dma && this.dramrefresh) {
      this.dramrefresh = false;
      dma = true;
    }
    return dma;
  }
  incHorizCounter() {
    ++this.h;
    switch (this.h) {
      case 25: case 25 + 4 * 1: case 25 + 4 * 2: case 25 + 4 * 3: case 25 + 4 * 4:
      case 25 + 4 * 5: case 25 + 4 * 6: case 25 + 4 * 7: case 25 + 4 * 8:
        this.dramrefresh = true;
        break;
      case 105:
        this.regs[WSYNC] = 0; // TODO: dram refresh delay to 106?
        break;
      case 114:
        this.h = 0;
        break;
    }
  }
  doVBlank() {
    this.linesleft = this.mode = 0;
    if (this.h == 111) { this.v++; }
    if (this.v == 248 && this.h == 0) { this.triggerNMI(0x40); } // VBI
    if (this.v == 262 && this.h == 112) { this.v = 0; }
    this.output = 2; // blank
  }

  doPlayerMissileDMA(section: number) {
    let oneline = this.regs[DMACTL] & 0x10;
    let pmaddr = this.regs[PMBASE] << 8;
    if (oneline) {
      pmaddr &= 0b1111100000000000;
      pmaddr |= section << 8;
      pmaddr += this.v & 0xff;
    } else {
      pmaddr &= 0b111111000000000;
      pmaddr |= section << 7;
      pmaddr += this.v >> 1;
    }
    this.read(pmaddr);
  }

  readBitmapData() {
    const mode = this.mode;
    if (mode < 8) {	// character mode
      let ch = this.ch;
      let y = this.yofs >> MODE_YPERIOD[this.mode];
      let addrofs = y & 7;
      let chbase = this.regs[CHBASE];
      // modes 6 & 7
      if ((mode & 0xe) == 6) { // or 7
        ch &= 0x3f;
        chbase &= 0xfe;
      } else {
        ch &= 0x7f;
        chbase &= 0xfc;
      }
      let addr = (ch << 3) + (chbase << 8);
      // modes 2 & 3
      if ((mode & 0xe) == 2) { // or 3
        let chactl = this.regs[CHACTL];
        let mode3lc = mode == 3 && (ch & 0x60) == 0x60;
        if (chactl & 4)
          this.pfbyte = this.read(addr + (addrofs ^ 7)); // mirror
        else
          this.pfbyte = this.read(addr + addrofs);
        if (mode3lc && y < 2) { this.pfbyte = 0; }
        if (!mode3lc && y > 7) { this.pfbyte = 0; }
        if (this.ch & 0x80) {
          if (chactl & 1)
            this.pfbyte = 0x0; // blank
          if (chactl & 2)
            this.pfbyte ^= 0xff; // invert
        }
      } else {
        this.pfbyte = this.read(addr + addrofs);
      }
    } else {	// map mode
      this.pfbyte = this.nextScreen();
    }
  }

  shiftout() {
    if (this.output == 4) { // visible pixel?
      switch (this.mode) {
        case 2: case 3:
        case 15:
          {
            let v = (this.pfbyte >> 7) & 1;
            this.pfbyte <<= 1;
            return v ? 8 : 6;
          }
        case 6: case 7:
          {
            let v = (this.pfbyte >> 7) & 1;
            this.pfbyte <<= 1;
            return v ? (this.ch >> 6) + 4 : 0;
          }
        case 9: case 11: case 12:
          {
            let v = (this.pfbyte >> 7) & 1;
            this.pfbyte <<= 1;
            return v ? 4 : 0;
          }
        case 4: case 5:
        case 8: case 10:
        case 13: case 14:
          {
            let v = (this.pfbyte >> 6) & 3;
            this.pfbyte <<= 2;
            return [0, 4, 5, 6][v]; // TODO: 5th color
          }
      }
    }
    return this.output;
  }

}

// GTIA
// https://user.xmission.com/~trevin/atari/gtia_regs.html
// https://user.xmission.com/~trevin/atari/gtia_pinout.html


// write regs
const HPOSP0 = 0x0;
const HPOSM0 = 0x4;
const SIZEP0 = 0x8;
const SIZEM = 0x0c;
const GRAFP0 = 0x0d;
const GRAFM = 0x11;
const COLPM0 = 0x12;
const COLPF0 = 0x16;
const COLPF1 = 0x17;
const COLPF2 = 0x18;
const COLPF3 = 0x19;
const COLBK = 0x1a;
const PRIOR = 0x1b;
const VDELAY = 0x1c;
const GRACTL = 0x1d;
const HITCLR = 0x1e;
const CONSPK = 0x1f;
// read regs
const M0PF = 0x0;
const P0PF = 0x4;
const M0PL = 0x8;
const P0PL = 0xc;
const TRIG0 = 0x10;
const CONSOL = 0x1f;

class GTIA {
  regs = new Uint8Array(0x20);
  shiftregs = new Uint32Array(8);

  count = 0;
  an = 0;
  rgb = 0;
  pmcol = 0;
  console_inputs = 0;

  reset() {
    this.regs.fill(0);
    this.count = 0;
  }
  saveState() {
    return {
      regs: this.regs.slice(0),
      shiftregs: this.shiftregs.slice(0),
      count: this.count,
      console_inputs: this.console_inputs,
    };
  }
  loadState(s) {
    this.regs.set(s.regs);
    this.shiftregs.set(s.shiftregs);
    this.count = s.count;
    this.console_inputs = s.console_inputs;
  }
  setReg(a: number, v: number) {
    switch (a) {
      case CONSOL:
        v = (v & 15) ^ 15; // 0 = input, 1 = pull down
        break;
      case HITCLR:
        this.regs[P0PF] = this.regs[P0PL] = this.regs[M0PF] = this.regs[M0PL] = 0;
        break;
    }
    this.regs[a] = v;
  }
  readReg(a: number) {
    if (a == CONSOL) {
      return this.console_inputs & this.regs[CONSOL];
    }
    return this.regs[a];
  }
  updateGfx(h: number, data: number) {
    switch (h) {
      case 0:
        this.count = 0;
        if (this.regs[GRACTL] & 1) { this.regs[GRAFM] = data; }
        break;
      case 2: case 3: case 4: case 5:
        if (this.regs[GRACTL] & 2) { this.regs[GRAFP0 - 2 + h] = data; }
        break;
    }
  }
  getPlayfieldColor(): number {
    let pfcol = 0;
    switch (this.an) {
      case 0:
        pfcol = this.regs[COLBK]; // 0 = background
        break;
      case 2: case 3:
        pfcol = 0; // 2/3 = blank
        break;
      case 4: case 5: case 6: case 7:
        pfcol = this.regs[COLPF0 + this.an - 4];
        break;
      case 8:
        pfcol = (this.regs[COLPF2] & 0xf0) | (this.regs[COLPF1] & 0x0f);
        break;
    }
    return pfcol;
  }
  clockPulse1(): void {
    let topcol = -1;
    let lasti = -1;
    let pfset = this.an > 4; // TODO?
    let p0pf = this.regs[P0PF];
    let p0pl = this.regs[P0PL];
    for (let i = 0; i < 8; i++) {
      let pmcol = this.getPlayerMissileColor(i);
      if (pmcol >= 0) {
        if (pfset) {
          p0pl |= 1 << i;
        }
        if (lasti > 0) {
          p0pl |= 1 << i;
          p0pl |= 1 << lasti;
        }
        topcol = pmcol;
        lasti = i;
      }
    }
    this.regs[P0PF] = p0pf;
    this.regs[P0PL] = p0pl;
    this.pmcol = topcol; // TODO: priority
    this.count++;
    this.clockPulse2();
  }
  clockPulse2(): void {
    let col = this.getPlayfieldColor();
    if (this.pmcol >= 0) col = this.pmcol;
    this.rgb = COLORS_RGBA[col];
  }
  getPlayerMissileColor(i: number) {
    let bit = this.shiftregs[i] & 0x80000000;
    this.shiftregs[i] <<= 1;
    if (this.regs[HPOSP0 + i] - 7 == this.count) {
      this.triggerObject(i);
    }
    return bit ? this.regs[COLPM0 + (i & 3)] : -1;
  }
  triggerObject(i: number) {
    let size, data;
    if (i < 4) {
      size = this.regs[SIZEP0 + i] & 3;
      data = this.regs[GRAFP0 + i];
    } else {
      size = (this.regs[SIZEM] >> (i - 4) * 2) & 3;
      data = this.regs[GRAFM] & (1 << i); // TODO
    }
    if (size & 1) data = expandBits(data); else data <<= 8;
    if (size == 3) data = expandBits(data); else data <<= 16;
    this.shiftregs[i] = data;
  }

  static stateToLongString(state): string {
    let s = "";
    s += dumpRAM(state.regs, 0, 32);
    return s;
  }
}

function expandBits(x: number): number {
  x = (x | (x << 8)) & 0x00FF00FF;
  x = (x | (x << 4)) & 0x0F0F0F0F;
  x = (x | (x << 2)) & 0x33333333;
  x = (x | (x << 1)) & 0x55555555;
  return x | (x << 1);
}


export class Atari800 extends BasicScanlineMachine {

  // http://www.ataripreservation.org/websites/freddy.offenga/megazine/ISSUE5-PALNTSC.html
  cpuFrequency = 1789773;
  numTotalScanlines = 262;
  cpuCyclesPerLine = 114;
  canvasWidth = 352; // TODO?
  aspectRatio = 240 / 172;
  firstVisibleClock = 34 * 2; // TODO?
  numVisibleScanlines = 250;
  // TODO: for 400/800/5200
  defaultROMSize = 0x8000;
  overscan = true;
  audioOversample = 4;
  sampleRate = this.numTotalScanlines * 60 * this.audioOversample;

  cpu: MOS6502;
  ram: Uint8Array;
  rom: Uint8Array;
  bios: Uint8Array;
  bus;
  pokey;
  audioadapter;
  antic: ANTIC;
  gtia: GTIA;
  inputs = new Uint8Array(4);
  linergb = new Uint32Array(this.canvasWidth);
  lastdmabyte = 0;
  keycode = 0;
  irqstatus = 0;
  // TODO: save/load vars

  constructor() {
    super();
    this.cpu = new MOS6502();
    this.ram = new Uint8Array(0x10000);
    this.bios = new Uint8Array(0x2800);
    this.bus = this.newBus();
    this.connectCPUMemoryBus(this.bus);
    // create support chips
    this.antic = new ANTIC(this.readDMA.bind(this));
    this.gtia = new GTIA();
    this.pokey = newPOKEYAudio(1);
    this.audioadapter = new TssChannelAdapter(this.pokey.pokey1, this.audioOversample, this.sampleRate);
    this.handler = newKeyboardHandler(
      this.inputs, ATARI8_KEYCODE_MAP, this.getKeyboardFunction(), true);
  }

  newBus() {
    return {
      // TODO: https://github.com/dmlloyd/atari800/blob/master/DOC/cart.txt
      read: newAddressDecoder([
        [0x0000, 0x9fff, 0xffff, (a) => { return this.ram[a]; }],
        [0xa000, 0xbfff, 0xffff, (a) => { return this.rom ? this.rom[a - 0xa000] : this.ram[a]; }],
        [0xd000, 0xd0ff, 0x1f, (a) => { return this.gtia.readReg(a); }],
        [0xd200, 0xd2ff, 0xf, (a) => { return this.readPokey(a); }],
        [0xd300, 0xd3ff, 0xf, (a) => { return this.readPIA(a); }],
        [0xd400, 0xd4ff, 0xf, (a) => { return this.antic.readReg(a); }],
        [0xd800, 0xffff, 0xffff, (a) => { return this.bios[a - 0xd800]; }],
      ]),
      write: newAddressDecoder([
        [0x0000, 0xbfff, 0xffff, (a, v) => { this.ram[a] = v; }],
        [0xd000, 0xd0ff, 0x1f, (a, v) => { this.gtia.setReg(a, v); }],
        [0xd200, 0xd2ff, 0xf, (a, v) => { this.writePokey(a, v); }],
        [0xd400, 0xd4ff, 0xf, (a, v) => { this.antic.setReg(a, v); }],
      ]),
    };
  }

  loadBIOS(bios: Uint8Array) {
    this.bios.set(bios);
  }

  reset() {
    super.reset();
    this.antic.reset();
    this.gtia.reset();
    this.keycode = 0;
    this.irqstatus = 0;
  }

  read(a) {
    // TODO: lastdmabyte?
    return this.bus.read(a);
  }
  // used by ANTIC
  readDMA(a) {
    let v = this.bus.read(a);
    this.probe.logVRAMRead(a, v);
    this.lastdmabyte = v;
    return v;
  }
  readConst(a) {
    return a < 0xd000 || a >= 0xe000 ? this.bus.read(a) : 0xff;
  }
  write(a, v) {
    this.bus.write(a, v);
  }
  readPokey(a: number) {
    //console.log(hex(a), hex(this.saveState().c.PC));
    switch (a) {
      case 9: // KBCODE
        return this.keycode & 0xff;
      case 14: // IRQST
        return this.irqstatus ^ 0xff;
      case 15: // SKSTAT
        return ((~this.keycode >> 6) & 0x4) | ((~this.keycode >> 3) & 0x8) | 0x12;
      default:
        return 0xff;
    }
  }
  readPIA(a: number) {
    if (a == 0 || a == 1) { return ~this.inputs[a]; }
  }
  writePokey(a, v) {
    switch (a) {
      case 13: this.sendIRQ(0x18); break; // serial output ready IRQ (TODO)
      case 14: this.irqstatus = 0; break;
    }
    this.pokey.pokey1.setRegister(a, v);
  }

  startScanline() {
    this.gtia.regs[TRIG0] = ~this.inputs[2];
    this.gtia.console_inputs = this.inputs[3] ^ 7;
    this.audio && this.audioadapter.generate(this.audio);
  }

  drawScanline() {
    // TODO
    if (this.antic.v < this.numVisibleScanlines) {
      this.pixels.set(this.linergb, this.antic.v * this.canvasWidth);
    }
  }

  advanceCPU(): number {
    // update ANTIC
    if (this.antic.clockPulse()) {
      this.probe.logClocks(1);
      // DMA cycle
    } else {
      // update CPU, NMI?
      if (this.antic.nmiPending) {
        this.cpu.NMI();
        this.probe.logInterrupt(1);
        this.antic.nmiPending = false;
      }
      super.advanceCPU();
    }
    // update GTIA
    let gtiatick1 = () => {
      this.gtia.clockPulse1();
      this.linergb[xofs++] = this.gtia.rgb;
    }
    let gtiatick2 = () => {
      this.gtia.clockPulse2();
      this.linergb[xofs++] = this.gtia.rgb;
    }
    this.gtia.updateGfx(this.antic.h - 1, this.lastdmabyte);
    let xofs = this.antic.h * 4 - this.firstVisibleClock;
    let bp = MODE_SHIFT[this.antic.mode];
    if (bp < 8 || (xofs & 4) == 0) { this.gtia.an = this.antic.shiftout(); }
    gtiatick1();
    if (bp == 1) { this.gtia.an = this.antic.shiftout(); }
    gtiatick2();
    if (bp <= 2) { this.gtia.an = this.antic.shiftout(); }
    gtiatick1();
    if (bp == 1) { this.gtia.an = this.antic.shiftout(); }
    gtiatick2();
    return 1;
  }

  loadState(state: any) {
    this.cpu.loadState(state.c);
    this.ram.set(state.ram);
    this.antic.loadState(state.antic);
    this.gtia.loadState(state.gtia);
    this.loadControlsState(state);
    this.lastdmabyte = state.lastdmabyte;
    this.keycode = state.keycode;
    this.irqstatus = state.irqstatus;
  }
  saveState() {
    return {
      c: this.cpu.saveState(),
      ram: this.ram.slice(0),
      antic: this.antic.saveState(),
      gtia: this.gtia.saveState(),
      inputs: this.inputs.slice(0),
      lastdmabyte: this.lastdmabyte,
      keycode: this.keycode, // TODO: inputs?
      irqstatus: this.irqstatus,
    };
  }
  loadControlsState(state) {
    this.inputs.set(state.inputs);
  }
  saveControlsState() {
    return {
      inputs: this.inputs.slice(0)
    };
  }
  getRasterScanline() {
    return this.antic.v;
  }
  getDebugCategories() {
    return ['CPU', 'Stack', 'ANTIC', 'GTIA', 'POKEY'];
  }
  getDebugInfo(category, state) {
    switch (category) {
      case 'ANTIC': return ANTIC.stateToLongString(state.antic);
      case 'GTIA': return GTIA.stateToLongString(state.gtia);
      case 'POKEY': {
        let s = '';
        for (let i = 0; i < 16; i++) { s += hex(this.readPokey(i)) + ' '; }
        s += "\nIRQ Status: " + hex(this.irqstatus) + "\n";
        return s;
      }
    }
  }
  getKeyboardFunction() {
    return (o, key, code, flags) => {
      if (flags & (KeyFlags.KeyDown | KeyFlags.KeyUp)) {
        var keymap = ATARI8_KEYMATRIX_INTL_NOSHIFT;
        if (key == Keys.VK_F9.c) {
          this.sendIRQ(0x80); // break IRQ
          return true;
        }
        for (var i = 0; i < keymap.length; i++) {
          if (keymap[i] && keymap[i].c == key) {
            this.keycode = i;
            if (flags & KeyFlags.Shift) { this.keycode |= 0x40; }
            if (flags & KeyFlags.Ctrl) { this.keycode |= 0x80; }
            if (flags & KeyFlags.KeyDown) {
              this.keycode |= 0x100;
              this.sendIRQ(0x40); // key pressed IRQ
              console.log(o, key, code, flags, hex(this.keycode));
              return true;
            }
          }
        }
      };
    }
  }
  sendIRQ(mask: number) {
    // irq enabled?
    if (this.pokey.pokey1.getRegister(0xe) & mask) {
      this.irqstatus = mask;
      this.cpu.IRQ();
      this.probe.logInterrupt(2);
      // TODO? if (this.antic.h == 4) { console.log("NMI blocked!"); }
    }
  }
  loadROM(rom: Uint8Array) {
    // TODO: support other than 8 KB carts
    super.loadROM(rom);
  }
}

export class Atari5200 extends Atari800 {
  newBus() {
    return {
      read: newAddressDecoder([
        [0x0000, 0x3fff, 0xffff, (a) => { return this.ram[a]; }],
        [0x4000, 0xbfff, 0xffff, (a) => { return this.rom ? this.rom[a - 0x4000] : 0; }],
        [0xc000, 0xcfff, 0x1f, (a) => { return this.gtia.readReg(a); }],
        [0xd400, 0xd4ff, 0xf, (a) => { return this.antic.readReg(a); }],
        [0xe800, 0xefff, 0xf, (a) => { return this.readPokey(a); }],
        [0xf800, 0xffff, 0x7ff, (a) => { return this.bios[a]; }],
      ]),
      write: newAddressDecoder([
        [0x0000, 0x3fff, 0xffff, (a, v) => { this.ram[a] = v; }],
        [0xc000, 0xcfff, 0x1f, (a, v) => { this.gtia.setReg(a, v); }],
        [0xd400, 0xd4ff, 0xf, (a, v) => { this.antic.setReg(a, v); }],
        [0xe800, 0xefff, 0xf, (a, v) => { this.writePokey(a, v); }],
      ]),
    };
  }
  loadROM(rom: Uint8Array) {
    // support 4/8/16/32 KB carts
    let rom2 = new Uint8Array(0x8000);
    for (let i = 0; i < rom2.length; i += rom.length) {
      rom2.set(rom, i);
    }
    super.loadROM(rom2);
  }
}

///

export class Atari8_WASMMachine extends BaseWASIMachine
  implements Machine, Probeable, VideoSource, AcceptsROM, FrameBased, AcceptsKeyInput, AcceptsPaddleInput {

  numTotalScanlines = 312;
  cpuCyclesPerLine = 63;

  prgstart: number;
  joymask0 = 0;
  joymask1 = 0;

  loadROM(rom: Uint8Array) {
    super.loadROM(rom);
    this.reloadROM();
  }
  reloadROM() {
    if (this.sys) {
      var result = this.exports.machine_load_rom(this.sys, this.romptr, this.romlen);
      console.log('machine_load_rom', result);
      //console.log(this.wasmFs.fs.existsSync('atari8.img'), result);
    }
  }
  loadBIOS(srcArray: Uint8Array) {
    super.loadBIOS(srcArray);
  }
  reset() {
    super.reset();
    this.reloadROM();
  }
  advanceFrame(trap: TrapCondition): number {
    // TODO
    this.exports.machine_start_frame(this.sys);
    if (trap) {
      this.advanceFrameClock(trap, 999999); // TODO?
    } else {
      this.exports.machine_advance_frame(this.sys);
    }
    this.syncVideo();
    this.syncAudio();
    return 1;
  }
  getCPUState() {
    this.exports.machine_save_cpu_state(this.sys, this.stateptr);
    var s = this.statearr;
    var pc = s[6] + (s[7] << 8);
    return {
      PC: pc,
      SP: s[2],
      A: s[0],
      X: s[3],
      Y: s[4],
      C: s[1] & 1,
      Z: s[1] & 2,
      I: s[1] & 4,
      D: s[1] & 8,
      V: s[1] & 64,
      N: s[1] & 128,
      o: this.readConst(pc),
    }
  }
  saveState() {
    var cpu = this.getCPUState();
    this.exports.machine_save_state(this.sys, this.stateptr);
    return {
      c: cpu,
      state: this.statearr.slice(0),
      //ram:this.statearr.slice(18640, 18640+0x200), // ZP and stack
    };
  }
  loadState(state): void {
    this.statearr.set(state.state);
    this.exports.machine_load_state(this.sys, this.stateptr);
  }
  getVideoParams() {
    return { width: 384, height: 240, overscan: true, videoFrequency: 60 };
  }
  pollControls() {
  }
  setKeyInput(key: number, code: number, flags: number): void {
    // modifier flags
    if (flags & KeyFlags.Shift) key |= 0x100;
    if (flags & KeyFlags.Ctrl) key |= 0x200;
    // keyboard -> joystick
    var mask = 0;
    if (key == 37) { key = 0x8; mask = 0x4; } // LEFT
    if (key == 38) { key = 0xb; mask = 0x1; } // UP
    if (key == 39) { key = 0x9; mask = 0x8; } // RIGHT
    if (key == 40) { key = 0xa; mask = 0x2; } // DOWN
    if (key == 32) { mask = 0x100; } // FIRE
    // set machine inputs
    if (flags & KeyFlags.KeyDown) {
      this.exports.machine_key_down(this.sys, key);
      this.joymask0 |= mask;
    } else if (flags & KeyFlags.KeyUp) {
      this.exports.machine_key_up(this.sys, key);
      this.joymask0 &= ~mask;
    }
    this.setJoyInput(0, this.joymask0);
    this.setJoyInput(1, this.joymask1);
  }
  setJoyInput(joy: number, mask: number) {
    this.exports.machine_joy_set(this.sys, joy, mask);
  }
  setPaddleInput(controller: number, value: number): void {
    this.exports.machine_paddle_set(this.sys, controller, value);
  }

}

const ATARI_NTSC_RGB = [
  0x000000,		// 00
  0x404040,		// 02
  0x6c6c6c,		// 04
  0x909090,		// 06
  0xb0b0b0,		// 08
  0xc8c8c8,		// 0A
  0xdcdcdc,		// 0C
  0xf4f4f4,		// 0E
  0x004444,		// 10
  0x106464,		// 12
  0x248484,		// 14
  0x34a0a0,		// 16
  0x40b8b8,		// 18
  0x50d0d0,		// 1A
  0x5ce8e8,		// 1C
  0x68fcfc,		// 1E
  0x002870,		// 20
  0x144484,		// 22
  0x285c98,		// 24
  0x3c78ac,		// 26
  0x4c8cbc,		// 28
  0x5ca0cc,		// 2A
  0x68b4dc,		// 2C
  0x78c8ec,		// 2E
  0x001884,		// 30
  0x183498,		// 32
  0x3050ac,		// 34
  0x4868c0,		// 36
  0x5c80d0,		// 38
  0x7094e0,		// 3A
  0x80a8ec,		// 3C
  0x94bcfc,		// 3E
  0x000088,		// 40
  0x20209c,		// 42
  0x3c3cb0,		// 44
  0x5858c0,		// 46
  0x7070d0,		// 48
  0x8888e0,		// 4A
  0xa0a0ec,		// 4C
  0xb4b4fc,		// 4E
  0x5c0078,		// 50
  0x74208c,		// 52
  0x883ca0,		// 54
  0x9c58b0,		// 56
  0xb070c0,		// 58
  0xc084d0,		// 5A
  0xd09cdc,		// 5C
  0xe0b0ec,		// 5E
  0x780048,		// 60
  0x902060,		// 62
  0xa43c78,		// 64
  0xb8588c,		// 66
  0xcc70a0,		// 68
  0xdc84b4,		// 6A
  0xec9cc4,		// 6C
  0xfcb0d4,		// 6E
  0x840014,		// 70
  0x982030,		// 72
  0xac3c4c,		// 74
  0xc05868,		// 76
  0xd0707c,		// 78
  0xe08894,		// 7A
  0xeca0a8,		// 7C
  0xfcb4bc,		// 7E
  0x880000,		// 80
  0x9c201c,		// 82
  0xb04038,		// 84
  0xc05c50,		// 86
  0xd07468,		// 88
  0xe08c7c,		// 8A
  0xeca490,		// 8C
  0xfcb8a4,		// 8E
  0x7c1800,		// 90
  0x90381c,		// 92
  0xa85438,		// 94
  0xbc7050,		// 96
  0xcc8868,		// 98
  0xdc9c7c,		// 9A
  0xecb490,		// 9C
  0xfcc8a4,		// 9E
  0x5c2c00,		// A0
  0x784c1c,		// A2
  0x906838,		// A4
  0xac8450,		// A6
  0xc09c68,		// A8
  0xd4b47c,		// AA
  0xe8cc90,		// AC
  0xfce0a4,		// AE
  0x2c3c00,		// B0
  0x485c1c,		// B2
  0x647c38,		// B4
  0x809c50,		// B6
  0x94b468,		// B8
  0xacd07c,		// BA
  0xc0e490,		// BC
  0xd4fca4,		// BE
  0x003c00,		// C0
  0x205c20,		// C2
  0x407c40,		// C4
  0x5c9c5c,		// C6
  0x74b474,		// C8
  0x8cd08c,		// CA
  0xa4e4a4,		// CC
  0xb8fcb8,		// CE
  0x003814,		// D0
  0x1c5c34,		// D2
  0x387c50,		// D4
  0x50986c,		// D6
  0x68b484,		// D8
  0x7ccc9c,		// DA
  0x90e4b4,		// DC
  0xa4fcc8,		// DE
  0x00302c,		// E0
  0x1c504c,		// E2
  0x347068,		// E4
  0x4c8c84,		// E6
  0x64a89c,		// E8
  0x78c0b4,		// EA
  0x88d4cc,		// EC
  0x9cece0,		// EE
  0x002844,		// F0
  0x184864,		// F2
  0x306884,		// F4
  0x4484a0,		// F6
  0x589cb8,		// F8
  0x6cb4d0,		// FA
  0x7ccce8,		// FC
  0x8ce0fc		// FE
];

var COLORS_RGBA = new Uint32Array(256);
var COLORS_WEB = [];
for (var i = 0; i < 256; i++) {
  COLORS_RGBA[i] = ATARI_NTSC_RGB[i >> 1] | 0xff000000;
  COLORS_WEB[i] = "#" + hex(rgb2bgr(ATARI_NTSC_RGB[i >> 1]), 6);
}