/*
 * Copyright 2010-2013 Will Scullin <scullin@scullinsteel.com>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or
 * implied warranty.
 */

import { debug, toHex } from './util';

export default function CPU6502(options)
{
    options = options || {};

    var is65C02 = options['65C02'] ? true : false;

    /* Registers */
    var pc = 0, // Program Counter
        sr = 0x20, // Process Status Register
        ar = 0, // Accumulator
        xr = 0, // X Register
        yr = 0, // Y Register
        sp = 0xff; // Stack Pointer

    /* Addressing Mode */
    var modes = {
        accumulator: 0,           // A (Accumulator)
        implied:     1,           // Implied
        immediate:   2,           // # Immediate
        absolute:    3,           // a Absolute
        zeroPage:    4,           // zp Zero Page
        relative:    5,           // r Relative

        absoluteX:   6,           // a,X Absolute, X
        absoluteY:   7,           // a,Y Absolute, Y
        zeroPageX:   8,           // zp,X Zero Page, X
        zeroPageY:   9,           // zp,Y Zero Page, Y

        absoluteIndirect:   10,  // (a) Indirect
        zeroPageXIndirect:  11, // (zp,X) Zero Page Indexed Indirect
        zeroPageIndirectY:  12, // (zp),Y Zero Page Indexed with Y

        /* 65c02 */
        zeroPageIndirect:   13,  // (zp),
        absoluteXIndirect:  14   // (a, X)
    };

    var sizes = {
        0 /* modes.accumulator */: 1,
        1 /* modes.implied */: 1,
        2 /* modes.immediate */: 2,
        3 /* modes.absolute */: 3,
        4 /* modes.zeroPage */: 2,
        5 /* modes.relative */: 2,
        6 /* modes.absoluteX */: 3,
        7 /* modes.absoluteY */: 3,
        8 /* modes.zeroPageX */: 2,
        9 /* modes.zeroPageY */: 2,
        10 /* modes.indirect */: 3,
        11 /* modes.zeroPageXIndirect */: 2,
        12 /* modes.zeroPageYIndirect */: 2,

        13 /* mode.zeroPageIndirect */: 2,
        14 /* mode.absoluteXIndirect */: 3
    };

    /* Flags */
    var flags = {
        N: 0x80, // Negative
        V: 0x40, // oVerflow
        B: 0x10, // Break
        D: 0x08, // Decimal
        I: 0x04, // Interrupt
        Z: 0x02, // Zero
        C: 0x01  // Carry
    };

    /* Memory Locations */
    var loc = {
        STACK: 0x100,
        NMI: 0xFFFA,
        RESET: 0xFFFC,
        BRK: 0xFFFE
    };

    var idx;

    var readPages = [];
    var writePages = [];
    var resetHandlers = [];
    var inCallback = false;
    var cycles = 0;

    var blankPage = {
        read: function() { return 0; },
        write: function() {}
    };

    for (idx = 0; idx < 0x100; idx++) {
        readPages[idx] = blankPage;
        writePages[idx] = blankPage;
    }

    function setFlag(f, on) {
        sr = on ? (sr | f) : (sr & ~f);
    }

    function testNZ(val) {
        sr = val === 0 ? (sr | flags.Z) : (sr & ~flags.Z);
        sr = val & 0x80 ? (sr | flags.N) : (sr & ~flags.N);

        return val;
    }

    function testZ(val) {
        sr = val === 0 ? (sr | flags.Z) : (sr & ~flags.Z);

        return val;
    }

    function add(a, b, sub) {
        if (sub)
            b ^= 0xff;

        // KEGS
        var c, v;
        if (sr & flags.D) {
            c = (a & 0x0f) + (b & 0x0f) + (sr & flags.C);
            if (sub) {
                if (c < 0x10)
                    c = (c - 0x06) & 0x0f;
                c += (a & 0xf0) + (b & 0xf0);
                v = (c >> 1) ^ c;
                if (c < 0x100)
                    c = (c + 0xa0) & 0xff;
            } else {
                if (c > 0x09)
                    c = (c - 0x0a) | 0x10; // carry to MSN
                c += (a & 0xf0) + (b & 0xf0);
                v = (c >> 1) ^ c;
                if (c > 0x99)
                    c += 0x60;
            }
        } else {
            c = a + b + (sr & flags.C);
            v = (c ^ a) & 0x80;
        }

        if ((a ^ b) & 0x80)
            v = 0;

        setFlag(flags.C, c > 0xff);
        setFlag(flags.V, v);

        return testNZ(c & 0xff);
    }

    function increment(a) {
        return testNZ((a + 0x01) & 0xff);
    }

    function decrement(a) {
        return testNZ((a + 0xff) & 0xff);
    }

    function readBytePC(dbg) {
        var addr = (pc++) & 0xffff,
            page = addr >> 8,
            off = addr & 0xff;

        return readPages[page].read(page, off, dbg);
    }

    function readByte(addr, dbg) {
        var page = addr >> 8,
            off = addr & 0xff;

        return readPages[page].read(page, off, dbg);
    }

    function writeByte(addr, val) {
        var page = addr >> 8,
            off = addr & 0xff;

        writePages[page].write(page, off, val);
    }

    function readWord(addr, dbg) {
        return readByte(addr, dbg) | (readByte(addr + 1, dbg) << 8);
    }

    function readWordPC(dbg) {
        return readBytePC(dbg) | (readBytePC(dbg) << 8);
    }

    function readZPWord(addr, dbg) {
        var lsb, msb;

        lsb = readByte(addr & 0xff, dbg);
        msb = readByte((addr + 1) & 0xff, dbg);

        return (msb << 8) | lsb;
    }

    function pushByte(val) {
        writeByte(loc.STACK | sp, val);
        sp = (sp + 0xff) & 0xff;
    }

    function pushWord(val) {
        pushByte(val >> 8);
        pushByte(val & 0xff);
    }

    function pullByte() {
        sp = (sp + 0x01) & 0xff;
        var result = readByte(loc.STACK | sp);
        return result;
    }

    function pullWord() {
        var lsb = pullByte(),
            msb = pullByte();

        return (msb << 8) | lsb;
    }

    function indirectBug(addr) {
        var page = addr & 0xff00;
        var off = addr & 0xff;
        var lsb = readByte(page | (off & 0xff));
        var msb = readByte(page | ((off + 0x01) & 0xff));

        return (msb << 8) | lsb;
    }

    /*
     * Read functions
     */

    // #$00
    function readImmediate() {
        return readBytePC();
    }

    // $0000
    function readAbsolute() {
        return readByte(readWordPC());
    }

    // $00
    function readZeroPage() {
        return readByte(readBytePC());
    }

    // $0000,X
    function readAbsoluteX() {
        var addr = readWordPC(), oldPage = addr >> 8, page;
        addr = (addr + xr) & 0xffff;
        page = addr >> 8;
        if (page != oldPage) {
            cycles++;
        }
        return readByte(addr);
    }

    // $0000,Y
    function readAbsoluteY() {
        var addr = readWordPC(), oldPage = addr >> 8, page;
        addr = (addr + yr) & 0xffff;
        page = addr >> 8;
        if (page != oldPage) {
            cycles++;
        }
        return readByte(addr);
    }

    // $00,X
    function readZeroPageX() {
        return readByte((readBytePC() + xr) & 0xff);
    }

    // $00,Y
    function readZeroPageY() {
        return readByte((readBytePC() + yr) & 0xff);
    }

    // ($00,X)
    function readZeroPageXIndirect() {
        return readByte(readZPWord((readBytePC() + xr) & 0xff));
    }

    // ($00),Y
    function readZeroPageIndirectY() {
        var addr = readZPWord(readBytePC()), oldPage = addr >> 8, page;
        addr = (addr + yr) & 0xffff;
        page = addr >> 8;
        if (page != oldPage) {
            cycles++;
        }
        return readByte(addr);
    }

    // ($00) (65C02)
    function readZeroPageIndirect() {
        return readByte(readZPWord(readBytePC()));
    }

    /*
     * Write Functions
     */

    // $0000
    function writeAbsolute(val) {
        writeByte(readWordPC(), val);
    }

    // $00
    function writeZeroPage(val) {
        writeByte(readBytePC(), val);
    }

    // $0000,X
    function writeAbsoluteX(val) {
        writeByte((readWordPC() + xr) & 0xffff, val);
    }

    // $0000,Y
    function writeAbsoluteY(val) {
        writeByte((readWordPC() + yr) & 0xffff, val);
    }

    // $00,X
    function writeZeroPageX(val) {
        writeByte((readBytePC() + xr) & 0xff, val);
    }

    // $00,Y
    function writeZeroPageY(val) {
        writeByte((readBytePC() + yr) & 0xff, val);
    }

    // ($00,X)
    function writeZeroPageXIndirect(val) {
        writeByte(readZPWord((readBytePC() + xr) & 0xff), val);
    }

    // ($00),Y
    function writeZeroPageIndirectY(val) {
        writeByte((readZPWord(readBytePC()) + yr) & 0xffff, val);
    }

    // ($00) (65C02)
    function writeZeroPageIndirect(val) {
        writeByte(readZPWord(readBytePC()), val);
    }

    // $00
    function readAddrZeroPage() {
        return readBytePC();
    }

    // $00,X
    function readAddrZeroPageX() {
        return (readBytePC() + xr) & 0xff;
    }

    // $0000 (65C02)
    function readAddrAbsolute() {
        return readWordPC();
    }

    // $0000
    function readAddrAbsoluteIndirectBug() {
        return indirectBug(readWordPC());
    }

    // ($0000)
    function readAddrAbsoluteIndirect() {
        return readWord(readWordPC());
    }

    // $0000,X
    function readAddrAbsoluteX() {
        return (readWordPC() + xr) & 0xffff;
    }

    // $(0000,X)
    function readAddrAbsoluteXIndirect() {
        return readWord((readWordPC() + xr) & 0xffff);
    }

    /* Break */
    function brk(readFn) {
        readFn();
        pushWord(pc);
        php();
        if (is65C02) {
            setFlag(flags.D, false);
        }
        setFlag(flags.I, true);
        pc = readWord(loc.BRK);
    }

    /* Load Accumulator */
    function lda(readFn) {
        ar = testNZ(readFn());
    }

    /* Load X Register */
    function ldx(readFn) {
        xr = testNZ(readFn());
    }

    /* Load Y Register */
    function ldy(readFn) {
        yr = testNZ(readFn());
    }

    /* Store Accumulator */
    function sta(writeFn) {
        writeFn(ar);
    }

    /* Store X Register */
    function stx(writeFn) {
        writeFn(xr);
    }

    /* Store Y Register */
    function sty(writeFn) {
        writeFn(yr);
    }

    /* Store Zero */
    function stz(writeFn) {
        writeFn(0);
    }

    /* Add with Carry */
    function adc(readFn) {
        ar = add(ar, readFn(), false);
    }

    /* Subtract with Carry */
    function sbc(readFn) {
        ar = add(ar, readFn(), true);
    }

    /* Increment Memory */
    function incA() {
        ar = increment(ar);
    }

    function inc(readAddrFn) {
        var addr = readAddrFn();
        writeByte(addr, increment(readByte(addr)));
    }

    /* Increment X */
    function inx() {
        xr = increment(xr);
    }

    /* Increment Y */
    function iny() {
        yr = increment(yr);
    }

    /* Decrement Memory */
    function decA() {
        ar = decrement(ar);
    }

    function dec(readAddrFn) {
        var addr = readAddrFn();
        writeByte(addr, decrement(readByte(addr)));
    }

    /* Decrement X */
    function dex() {
        xr = decrement(xr);
    }

    /* Decrement Y */
    function dey() {
        yr = decrement(yr);
    }

    function shiftLeft(val) {
        setFlag(flags.C, val & 0x80);
        return testNZ((val << 1) & 0xff);
    }

    /* Arithmatic Shift Left */
    function aslA() {
        ar = shiftLeft(ar);
    }

    function asl(readAddrFn) {
        var addr = readAddrFn();
        writeByte(addr, shiftLeft(readByte(addr)));
    }

    function shiftRight(val) {
        setFlag(flags.C, val & 0x01);
        return testNZ(val >> 1);
    }

    /* Logical Shift Right */
    function lsrA() {
        ar = shiftRight(ar);
    }

    function lsr(readAddrFn) {
        var addr = readAddrFn();
        writeByte(addr, shiftRight(readByte(addr)));
    }

    function rotateLeft(val) {
        var c = (sr & flags.C);
        setFlag(flags.C, val & 0x80);
        return testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff);
    }

    /* Rotate Left */
    function rolA() {
        ar = rotateLeft(ar);
    }

    function rol(readAddrFn) {
        var addr = readAddrFn();
        writeByte(addr, rotateLeft(readByte(addr)));
    }

    function rotateRight(a) {
        var c = (sr & flags.C);
        setFlag(flags.C, a & 0x01);
        return testNZ((a >> 1) | (c ? 0x80 : 0x00));
    }

    /* Rotate Right */
    function rorA() {
        ar = rotateRight(ar);
    }

    function ror(readAddrFn) {
        var addr = readAddrFn();
        writeByte(addr, rotateRight(readByte(addr)));
    }

    /* Logical And Accumulator */
    function and(readFn) {
        ar = testNZ(ar & readFn());
    }

    /* Logical Or Accumulator */
    function ora(readFn) {
        ar = testNZ(ar | readFn());
    }

    /* Logical Exclusive Or Accumulator */
    function eor(readFn) {
        ar = testNZ(ar ^ readFn());
    }

    /* Test and Reset Bits */
    function trb(readAddrFn) {
        var addr = readAddrFn(),
            val = readByte(addr);
        testZ(val & ar);
        writeByte(addr, val & ~ar);
    }

    /* Test and Set Bits */
    function tsb(readAddrFn) {
        var addr = readAddrFn(),
            val = readByte(addr);
        testZ(val & ar);
        writeByte(addr, val | ar);
    }

    /* Bit */
    function bit(readFn) {
        var val = readFn();
        setFlag(flags.Z, !(val & ar));
        setFlag(flags.N, val & 0x80);
        setFlag(flags.V, val & 0x40);
    }

    /* Bit Immediate*/
    function bitI(readFn) {
        var val = readFn();
        setFlag(flags.Z, !(val & ar));
    }

    function compare(a, b)
    {
        b = (b ^ 0xff);
        var c = a + b + 1;
        setFlag(flags.C, c > 0xff);
        testNZ(c & 0xff);
    }

    function cmp(readFn) {
        compare(ar, readFn());
    }

    function cpx(readFn) {
        compare(xr, readFn());
    }

    function cpy(readFn) {
        compare(yr, readFn());
    }

    /* Branches */
    function brs(f) {
        var off = readBytePC(); // changes pc
        if (f & sr) {
            var oldPC = pc;
            pc += off > 127 ? off - 256 : off;
            cycles++;
            if ((pc >> 8) != (oldPC >> 8)) cycles++;
        }
    }

    function brc(f) {
        var off = readBytePC(); // changes pc
        if (!(f & sr)) {
            var oldPC = pc;
            pc += off > 127 ? off - 256 : off;
            cycles++;
            if ((pc >> 8) != (oldPC >> 8)) cycles++;
        }
    }

    /* Transfers and stack */
    function tax() { testNZ(xr = ar); }

    function txa() { testNZ(ar = xr); }

    function tay() { testNZ(yr = ar); }

    function tya() { testNZ(ar = yr); }

    function tsx() { testNZ(xr = sp); }

    function txs() { sp = xr; }

    function pha() { pushByte(ar); }

    function pla() { testNZ(ar = pullByte()); }

    function phx() { pushByte(xr); }

    function plx() { testNZ(xr = pullByte()); }

    function phy() { pushByte(yr); }

    function ply() { testNZ(yr = pullByte()); }

    function php() { pushByte(sr | flags.B); }

    function plp() { sr = (pullByte() & ~flags.B) | 0x20; }

    /* Jump */
    function jmp(readAddrFn) {
        pc = readAddrFn();
    }

    /* Jump Subroutine */
    function jsr(readAddrFn) {
        var dest = readAddrFn();
        pushWord(pc - 1);
        pc = dest;
    }

    /* Return from Subroutine */
    function rts() {
        pc = (pullWord() + 1) & 0xffff;
    }

    /* Return from Subroutine */
    function rti() {
        sr = pullByte() & ~flags.B;
        pc = pullWord();
    }

    /* Set and Clear */
    function set(flag) {
        sr |= flag;
    }

    function clr(flag) {
        sr &= ~flag;
    }

    /* No-Op */
    function nop() {
    }

    var ops = {
        // LDA
        0xa9: ['LDA', lda, readImmediate, modes.immediate, 2],
        0xa5: ['LDA', lda, readZeroPage, modes.zeroPage, 3],
        0xb5: ['LDA', lda, readZeroPageX, modes.zeroPageX, 4],
        0xad: ['LDA', lda, readAbsolute, modes.absolute, 4],
        0xbd: ['LDA', lda, readAbsoluteX, modes.absoluteX, 4],
        0xb9: ['LDA', lda, readAbsoluteY, modes.absoluteY, 4],
        0xa1: ['LDA', lda, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0xb1: ['LDA', lda, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // LDX
        0xa2: ['LDX', ldx, readImmediate, modes.immediate, 2],
        0xa6: ['LDX', ldx, readZeroPage, modes.zeroPage, 3],
        0xb6: ['LDX', ldx, readZeroPageY, modes.zeroPageY, 4],
        0xae: ['LDX', ldx, readAbsolute, modes.absolute, 4],
        0xbe: ['LDX', ldx, readAbsoluteY, modes.absoluteY, 4],

        // LDY
        0xa0: ['LDY', ldy, readImmediate, modes.immediate, 2],
        0xa4: ['LDY', ldy, readZeroPage, modes.zeroPage, 3],
        0xb4: ['LDY', ldy, readZeroPageX, modes.zeroPageX, 4],
        0xac: ['LDY', ldy, readAbsolute, modes.absolute, 4],
        0xbc: ['LDY', ldy, readAbsoluteX, modes.absoluteX, 4],

        // STA
        0x85: ['STA', sta, writeZeroPage, modes.zeroPage, 3],
        0x95: ['STA', sta, writeZeroPageX, modes.zeroPageX, 4],
        0x8d: ['STA', sta, writeAbsolute, modes.absolute, 4],
        0x9d: ['STA', sta, writeAbsoluteX, modes.absoluteX, 5],
        0x99: ['STA', sta, writeAbsoluteY, modes.absoluteY, 5],
        0x81: ['STA', sta, writeZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0x91: ['STA', sta, writeZeroPageIndirectY, modes.zeroPageIndirectY, 6],

        // STX
        0x86: ['STX', stx, writeZeroPage, modes.zeroPage, 3],
        0x96: ['STX', stx, writeZeroPageY, modes.zeroPageY, 4],
        0x8e: ['STX', stx, writeAbsolute, modes.absolute, 4],

        // STY
        0x84: ['STY', sty, writeZeroPage, modes.zeroPage, 3],
        0x94: ['STY', sty, writeZeroPageX, modes.zeroPageX, 4],
        0x8c: ['STY', sty, writeAbsolute, modes.absolute, 4],

        // ADC
        0x69: ['ADC', adc, readImmediate, modes.immediate, 2],
        0x65: ['ADC', adc, readZeroPage, modes.zeroPage, 3],
        0x75: ['ADC', adc, readZeroPageX, modes.zeroPageX, 4],
        0x6D: ['ADC', adc, readAbsolute, modes.absolute, 4],
        0x7D: ['ADC', adc, readAbsoluteX, modes.absoluteX, 4],
        0x79: ['ADC', adc, readAbsoluteY, modes.absoluteY, 4],
        0x61: ['ADC', adc, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0x71: ['ADC', adc, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // SBC
        0xe9: ['SBC', sbc, readImmediate, modes.immediate, 2],
        0xe5: ['SBC', sbc, readZeroPage, modes.zeroPage, 3],
        0xf5: ['SBC', sbc, readZeroPageX, modes.zeroPageX, 4],
        0xeD: ['SBC', sbc, readAbsolute, modes.absolute, 4],
        0xfD: ['SBC', sbc, readAbsoluteX, modes.absoluteX, 4],
        0xf9: ['SBC', sbc, readAbsoluteY, modes.absoluteY, 4],
        0xe1: ['SBC', sbc, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0xf1: ['SBC', sbc, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // INC
        0xe6: ['INC', inc, readAddrZeroPage, modes.zeroPage, 5],
        0xf6: ['INC', inc, readAddrZeroPageX, modes.zeroPageX, 6],
        0xee: ['INC', inc, readAddrAbsolute, modes.absolute, 6],
        0xfe: ['INC', inc, readAddrAbsoluteX, modes.absoluteX, 7],

        // INX
        0xe8: ['INX', inx, null, modes.implied, 2],

        // INY
        0xc8: ['INY', iny, null, modes.implied, 2],

        // DEC
        0xc6: ['DEC', dec, readAddrZeroPage, modes.zeroPage, 5],
        0xd6: ['DEC', dec, readAddrZeroPageX, modes.zeroPageX, 6],
        0xce: ['DEC', dec, readAddrAbsolute, modes.absolute, 6],
        0xde: ['DEC', dec, readAddrAbsoluteX, modes.absoluteX, 7],

        // DEX
        0xca: ['DEX', dex, null, modes.implied, 2],

        // DEY
        0x88: ['DEY', dey, null, modes.implied, 2],

        // ASL
        0x0A: ['ASL', aslA, null, modes.accumulator, 2],
        0x06: ['ASL', asl, readAddrZeroPage, modes.zeroPage, 5],
        0x16: ['ASL', asl, readAddrZeroPageX, modes.zeroPageX, 6],
        0x0E: ['ASL', asl, readAddrAbsolute, modes.absolute, 6],
        0x1E: ['ASL', asl, readAddrAbsoluteX, modes.absoluteX, 7],

        // LSR
        0x4A: ['LSR', lsrA, null, modes.accumulator, 2],
        0x46: ['LSR', lsr, readAddrZeroPage, modes.zeroPage, 5],
        0x56: ['LSR', lsr, readAddrZeroPageX, modes.zeroPageX, 6],
        0x4E: ['LSR', lsr, readAddrAbsolute, modes.absolute, 6],
        0x5E: ['LSR', lsr, readAddrAbsoluteX, modes.absoluteX, 7],

        // ROL
        0x2A: ['ROL', rolA, null, modes.accumulator, 2],
        0x26: ['ROL', rol, readAddrZeroPage, modes.zeroPage, 5],
        0x36: ['ROL', rol, readAddrZeroPageX, modes.zeroPageX, 6],
        0x2E: ['ROL', rol, readAddrAbsolute, modes.absolute, 6],
        0x3E: ['ROL', rol, readAddrAbsoluteX, modes.absoluteX, 7],

        // ROR
        0x6A: ['ROR', rorA, null, modes.accumulator, 2],
        0x66: ['ROR', ror, readAddrZeroPage, modes.zeroPage, 5],
        0x76: ['ROR', ror, readAddrZeroPageX, modes.zeroPageX, 6],
        0x6E: ['ROR', ror, readAddrAbsolute, modes.absolute, 6],
        0x7E: ['ROR', ror, readAddrAbsoluteX, modes.absoluteX, 7],

        // AND
        0x29: ['AND', and, readImmediate, modes.immediate, 2],
        0x25: ['AND', and, readZeroPage, modes.zeroPage, 2],
        0x35: ['AND', and, readZeroPageX, modes.zeroPageX, 3],
        0x2D: ['AND', and, readAbsolute, modes.absolute, 4],
        0x3D: ['AND', and, readAbsoluteX, modes.absoluteX, 4],
        0x39: ['AND', and, readAbsoluteY, modes.absoluteY, 4],
        0x21: ['AND', and, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0x31: ['AND', and, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // ORA
        0x09: ['ORA', ora, readImmediate, modes.immediate, 2],
        0x05: ['ORA', ora, readZeroPage, modes.zeroPage, 2],
        0x15: ['ORA', ora, readZeroPageX, modes.zeroPageX, 3],
        0x0D: ['ORA', ora, readAbsolute, modes.absolute, 4],
        0x1D: ['ORA', ora, readAbsoluteX, modes.absoluteX, 4],
        0x19: ['ORA', ora, readAbsoluteY, modes.absoluteY, 4],
        0x01: ['ORA', ora, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0x11: ['ORA', ora, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // EOR
        0x49: ['EOR', eor, readImmediate, modes.immediate, 2],
        0x45: ['EOR', eor, readZeroPage, modes.zeroPage, 3],
        0x55: ['EOR', eor, readZeroPageX, modes.zeroPageX, 4],
        0x4D: ['EOR', eor, readAbsolute, modes.absolute, 4],
        0x5D: ['EOR', eor, readAbsoluteX, modes.absoluteX, 4],
        0x59: ['EOR', eor, readAbsoluteY, modes.absoluteY, 4],
        0x41: ['EOR', eor, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0x51: ['EOR', eor, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // CMP
        0xc9: ['CMP', cmp, readImmediate, modes.immediate, 2],
        0xc5: ['CMP', cmp, readZeroPage, modes.zeroPage, 3],
        0xd5: ['CMP', cmp, readZeroPageX, modes.zeroPageX, 4],
        0xcD: ['CMP', cmp, readAbsolute, modes.absolute, 4],
        0xdD: ['CMP', cmp, readAbsoluteX, modes.absoluteX, 4],
        0xd9: ['CMP', cmp, readAbsoluteY, modes.absoluteY, 4],
        0xc1: ['CMP', cmp, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
        0xd1: ['CMP', cmp, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],

        // CPX
        0xE0: ['CPX', cpx, readImmediate, modes.immediate, 2],
        0xE4: ['CPX', cpx, readZeroPage, modes.zeroPage, 3],
        0xEC: ['CPX', cpx, readAbsolute, modes.absolute, 4],

        // CPY
        0xC0: ['CPY', cpy, readImmediate, modes.immediate, 2],
        0xC4: ['CPY', cpy, readZeroPage, modes.zeroPage, 3],
        0xCC: ['CPY', cpy, readAbsolute, modes.absolute, 4],

        // BIT
        0x24: ['BIT', bit, readZeroPage, modes.zeroPage, 3],
        0x2C: ['BIT', bit, readAbsolute, modes.absolute, 4],

        // BCC
        0x90: ['BCC', brc, flags.C, modes.relative, 2],

        // BCS
        0xB0: ['BCS', brs, flags.C, modes.relative, 2],

        // BEQ
        0xF0: ['BEQ', brs, flags.Z, modes.relative, 2],

        // BMI
        0x30: ['BMI', brs, flags.N, modes.relative, 2],

        // BNE
        0xD0: ['BNE', brc, flags.Z, modes.relative, 2],

        // BPL
        0x10: ['BPL', brc, flags.N, modes.relative, 2],

        // BVC
        0x50: ['BVC', brc, flags.V, modes.relative, 2],

        // BVS
        0x70: ['BVS', brs, flags.V, modes.relative, 2],

        // TAX
        0xAA: ['TAX', tax, null, modes.implied, 2],

        // TXA
        0x8A: ['TXA', txa, null, modes.implied, 2],

        // TAY
        0xA8: ['TAY', tay, null, modes.implied, 2],

        // TYA
        0x98: ['TYA', tya, null, modes.implied, 2],

        // TSX
        0xBA: ['TSX', tsx, null, modes.implied, 2],

        // TXS
        0x9A: ['TXS', txs, null, modes.implied, 2],

        // PHA
        0x48: ['PHA', pha, null, modes.implied, 3],

        // PLA
        0x68: ['PLA', pla, null, modes.implied, 4],

        // PHP
        0x08: ['PHP', php, null, modes.implied, 3],

        // PLP
        0x28: ['PLP', plp, null, modes.implied, 4],

        // JMP
        0x4C: ['JMP', jmp,
            readAddrAbsolute, modes.absolute, 3],
        0x6C: ['JMP', jmp,
            readAddrAbsoluteIndirectBug, modes.absoluteIndirect, 5],

        // JSR
        0x20: ['JSR', jsr, readAddrAbsolute, modes.absolute, 6],

        // RTS
        0x60: ['RTS', rts, null, modes.implied, 6],

        // RTI
        0x40: ['RTI', rti, null, modes.implied, 6],

        // SEC
        0x38: ['SEC', set, flags.C, modes.implied, 2],

        // SED
        0xF8: ['SED', set, flags.D, modes.implied, 2],

        // SEI
        0x78: ['SEI', set, flags.I, modes.implied, 2],

        // CLC
        0x18: ['CLC', clr, flags.C, modes.implied, 2],

        // CLD
        0xD8: ['CLD', clr, flags.D, modes.implied, 2],

        // CLI
        0x58: ['CLI', clr, flags.I, modes.implied, 2],

        // CLV
        0xB8: ['CLV', clr, flags.V, modes.implied, 2],

        // NOP
        0xea: ['NOP', nop, null, modes.implied, 2],

        // BRK
        0x00: ['BRK', brk, readImmediate, modes.immediate, 7]
    };

    /* 65C02 Instructions */

    var cops = {
        // INC / DEC A
        0x1A: ['INC', incA, null, modes.accumulator, 2],
        0x3A: ['DEC', decA, null, modes.accumulator, 2],

        // Indirect Zero Page for the masses
        0x12: ['ORA', ora, readZeroPageIndirect, modes.zeroPageIndirect, 5],
        0x32: ['AND', and, readZeroPageIndirect, modes.zeroPageIndirect, 5],
        0x52: ['EOR', eor, readZeroPageIndirect, modes.zeroPageIndirect, 5],
        0x72: ['ADC', adc, readZeroPageIndirect, modes.zeroPageIndirect, 5],
        0x92: ['STA', sta, writeZeroPageIndirect, modes.zeroPageIndirect, 5],
        0xB2: ['LDA', lda, readZeroPageIndirect, modes.zeroPageIndirect, 5],
        0xD2: ['CMP', cmp, readZeroPageIndirect, modes.zeroPageIndirect, 5],
        0xF2: ['SBC', sbc, readZeroPageIndirect, modes.zeroPageIndirect, 5],

        // Better BIT
        0x34: ['BIT', bit, readZeroPageX, modes.zeroPageX, 4],
        0x3C: ['BIT', bit, readAbsoluteX, modes.absoluteX, 4],
        0x89: ['BIT', bitI, readImmediate, modes.immediate, 2],

        // JMP absolute indirect indexed
        0x6C: ['JMP', jmp, readAddrAbsoluteIndirect,
            modes.absoluteIndirect, 6],
        0x7C: ['JMP', jmp, readAddrAbsoluteXIndirect,
            modes.absoluteXIndirect, 6],

        // BRA
        0x80: ['BRA', brc, 0, modes.relative, 3],

        // PHX
        0xDA: ['PHX', phx, null, modes.implied, 3],

        // PHY
        0x5A: ['PHY', phy, null, modes.implied, 3],

        // PLX
        0xFA: ['PLX', plx, null, modes.implied, 3],

        // PLY
        0x7A: ['PLY', ply, null, modes.implied, 3],

        // STZ
        0x64: ['STZ', stz, writeZeroPage, modes.zeroPage, 3],
        0x74: ['STZ', stz, writeZeroPageX, modes.zeroPageX, 4],
        0x9C: ['STZ', stz, writeAbsolute, modes.absolute, 4],
        0x9E: ['STZ', stz, writeAbsoluteX, modes.absoluteX, 5],

        // TRB
        0x14: ['TRB', trb, readAddrZeroPage, modes.zeroPage, 5],
        0x1C: ['TRB', trb, readAddrAbsolute, modes.absolute, 6],

        // TSB
        0x04: ['TSB', tsb, readAddrZeroPage, modes.zeroPage, 5],
        0x0C: ['TSB', tsb, readAddrAbsolute, modes.absolute, 6]
    };

    if (is65C02) {
        for (var key in cops) {
            ops[key] = cops[key];
        }
    }

    function unknown(b) {
        var unk;

        if (is65C02) {
            unk = ['NOP (' + toHex(b) + ')', function() {
                debug('Unknown OpCode: ' + toHex(b) + ' at ' + toHex(pc - 1, 4));
            }, null, modes.implied, 2];
        } else {
            unk = ['???',
                function() { /* debug("Unknown OpCode: " + toHex(b) +
                                      " at " + toHex(pc - 1, 4)); */ },
                null, modes.implied,
                1];
        }
        ops[b] = unk;
        return unk;
    }

    /* Certain browsers benefit from using arrays over maps */
    var opary = [];

    for (idx = 0; idx < 0x100; idx++) {
        opary[idx] = ops[idx] || unknown(idx);
    }

    function dumpArgs(addr, m, symbols) {
        function toHexOrSymbol(v, n) {
            if (symbols && symbols[v]) {
                return symbols[v];
            } else {
                return '$' + toHex(v, n);
            }
        }
        var result = '';
        switch (m) {
        case modes.implied:
            break;
        case modes.immediate:
            result = '#' + toHexOrSymbol(readByte(addr, true));
            break;
        case modes.absolute:
            result = '' + toHexOrSymbol(readWord(addr, true), 4);
            break;
        case modes.zeroPage:
            result = '' + toHexOrSymbol(readByte(addr, true));
            break;
        case modes.relative:
            {
                var off = readByte(addr, true);
                if (off > 127) {
                    off -= 256;
                }
                addr += off + 1;
                result = '' + toHexOrSymbol(addr, 4) + ' (' + off + ')';
            }
            break;
        case modes.absoluteX:
            result = '' + toHexOrSymbol(readWord(addr, true), 4) + ',X';
            break;
        case modes.absoluteY:
            result = '' + toHexOrSymbol(readWord(addr, true), 4) + ',Y';
            break;
        case modes.zeroPageX:
            result = '' + toHexOrSymbol(readByte(addr, true)) + ',X';
            break;
        case modes.zeroPageY:
            result = '' + toHexOrSymbol(readByte(addr, true)) + ',Y';
            break;
        case modes.absoluteIndirect:
            result = '(' + toHexOrSymbol(readWord(addr, true), 4) + ')';
            break;
        case modes.zeroPageXIndirect:
            result = '(' + toHexOrSymbol(readByte(addr, true)) + ',X)';
            break;
        case modes.zeroPageIndirectY:
            result = '(' + toHexOrSymbol(readByte(addr, true)) + '),Y';
            break;
        case modes.accumulator:
            result = 'A';
            break;
        case modes.zeroPageIndirect:
            result = '(' + toHexOrSymbol(readByte(addr, true)) + ')';
            break;
        case modes.absoluteXIndirect:
            result = '(' + toHexOrSymbol(readWord(addr, true), 4) + ',X)';
            break;
        default:
            break;
        }
        return result;
    }

    return {
        step: function cpu_step(cb) {
            var op = opary[readBytePC()];

            op[1](op[2]);
            cycles += op[4];

            if (cb) {
                inCallback = true;
                cb(this);
                inCallback = false;
            }
        },

        stepN: function(n) {
            var op, idx;

            for (idx = 0; idx < n; idx++) {
                op = opary[readBytePC()];
                op[1](op[2]);
                cycles += op[4];
            }
        },

        stepCycles: function(c) {
            var op, end = cycles + c;

            while (cycles < end) {
                op = opary[readBytePC()];
                op[1](op[2]);
                cycles += op[4];
            }
        },

        stepCyclesDebug: function(c, cb)
        {
            var op, end = cycles + c;

            if (inCallback)
                return;

            while (cycles < end) {
                op = opary[readBytePC()];
                op[1](op[2]);
                cycles += op[4];

                if (cb) {
                    inCallback = true;
                    cb(this);
                    inCallback = false;
                }
            }
        },

        addPageHandler: function(pho) {
            for (var idx = pho.start(); idx <= pho.end(); idx++) {
                writePages[idx] = pho;
                if (pho.read)
                    readPages[idx] = pho;
                if (pho.write)
                    writePages[idx] = pho;
            }
            if (pho.reset)
                resetHandlers.push(pho);
        },

        reset: function cpu_reset()
        {
            // cycles = 0;
            sr = 0x20;
            sp = 0xff;
            ar = 0;
            yr = 0;
            xr = 0;
            pc = readWord(loc.RESET);

            for (var idx = 0; idx < resetHandlers.length; idx++) {
                resetHandlers[idx].reset();
            }
        },

        /* IRQ - Interupt Request */
        irq: function cpu_irq()
        {
            if (!(sr & flags.I)) {
                pushWord(pc);
                pushByte(sr & ~flags.B);
                if (is65C02) {
                    setFlag(flags.D, false);
                }
                setFlag(flags.I, true);
                pc = readWord(loc.BRK);
            }
        },

        /* NMI Non-maskable Interrupt */
        nmi: function cpu_nmi()
        {
            pushWord(pc);
            pushByte(sr & ~flags.B);
            if (is65C02) {
                setFlag(flags.D, false);
            }
            setFlag(flags.I, true);
            pc = readWord(loc.NMI);
        },

        setPC: function(_pc) {
            pc = _pc;
        },

        dumpPC: function(_pc, symbols) {
            if (_pc === undefined) {
                _pc = pc;
            }
            var b = readByte(_pc, true),
                op = ops[b],
                size = sizes[op[3]],
                result = toHex(_pc, 4) + '- ';

            if (symbols) {
                if (symbols[_pc]) {
                    result += symbols[_pc] +
                        '          '.substring(symbols[_pc].length);
                } else {
                    result += '          ';
                }
            }

            for (var idx = 0; idx < 4; idx++) {
                if (idx < size) {
                    result += toHex(readByte(_pc + idx, true)) + ' ';
                } else {
                    result += '   ';
                }
            }

            if (op === undefined)
                result += '??? (' + toHex(b) + ')';
            else
                result += op[0] + ' ' + dumpArgs(_pc + 1, op[3], symbols);

            return result;
        },

        dumpPage: function(start, end) {
            var result = '';
            if (start === undefined) {
                start = pc >> 8;
            }
            if (end === undefined) {
                end = start;
            }
            for (var page = start; page <= end; page++) {
                var b, idx, jdx;
                for (idx = 0; idx < 16; idx++) {
                    result += toHex(page) + toHex(idx << 4) + ': ';
                    for (jdx = 0; jdx < 16; jdx++) {
                        b = readByte(page * 256 + idx * 16 + jdx, true);
                        result += toHex(b) + ' ';
                    }
                    result += '        ';
                    for (jdx = 0; jdx < 16; jdx++) {
                        b = readByte(page * 256 + idx * 16 + jdx, true) & 0x7f;
                        if (b >= 0x20 && b < 0x7f) {
                            result += String.fromCharCode(b);
                        } else {
                            result += '.';
                        }
                    }
                    result += '\n';
                }
            }
            return result;
        },

        list: function(_pc, symbols) {
            if (_pc === undefined) {
                _pc = pc;
            }
            var results = [];
            for (var jdx = 0; jdx < 20; jdx++) {
                var b = readByte(_pc), op = ops[b];
                results.push(this.dumpPC(_pc, symbols));
                _pc += sizes[op[3]];
            }
            return results;
        },

        cycles: function() {
            return cycles;
        },

        registers: function() {
            return [pc,ar,xr,yr,sr,sp];
        },

        getState: function() {
            return {
                a: ar,
                x: xr,
                y: yr,
                s: sr,
                pc: pc,
                sp: sp,
                cycles: cycles
            };
        },

        setState: function(state) {
            ar = state.a;
            xr = state.x;
            yr = state.y;
            sr = state.s;
            pc = state.pc;
            sp = state.sp;
            cycles = state.cycles;
        },

        dumpRegisters: function() {
            return toHex(pc, 4) +
                '-   A=' + toHex(ar) +
                ' X=' + toHex(xr) +
                ' Y=' + toHex(yr) +
                ' P=' + toHex(sr) +
                ' S=' + toHex(sp) +
                ' ' +
                (sr & flags.N ? 'N' : '-') +
                (sr & flags.V ? 'V' : '-') +
                '-' +
                (sr & flags.B ? 'B' : '-') +
                (sr & flags.D ? 'D' : '-') +
                (sr & flags.I ? 'I' : '-') +
                (sr & flags.Z ? 'Z' : '-') +
                (sr & flags.C ? 'C' : '-');
        },

        read: function(page, off) {
            return readPages[page].read(page, off, false);
        },

        write: function(page, off, val) {
            writePages[page].write(page, off, val);
        }
    };
}