macro_rules! make_optable {
    ($x:ident, $t: ty) => (pub const $x: [$t; 0x100] = [
    /*  0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf */
        brk, ora, nil, nil, nil, ora, asl, nil, php, ora, asl, nil, nil, ora, asl, nil,
        bpl, ora, nil, nil, nil, ora, asl, nil, clc, ora, nil, nil, nil, ora, asl, nil,
        jsr, and, nil, nil, bit, and, rol, nil, plp, and, rol, nil, bit, and, rol, nil,
        bmi, and, nil, nil, nil, and, rol, nil, sec, and, nil, nil, nil, and, rol, nil,
        rti, eor, nil, nil, nil, eor, lsr, nil, pha, eor, lsr, nil, jmp, eor, lsr, nil,
        bvc, eor, nil, nil, nil, eor, lsr, nil, cli, eor, nil, nil, nil, eor, lsr, nil,
        rts, adc, nil, nil, nil, adc, ror, nil, pla, adc, ror, nil, jmp, adc, ror, nil,
        bvs, adc, nil, nil, nil, adc, ror, nil, sei, adc, nil, nil, nil, adc, ror, nil,
        nil, sta, nil, nil, sty, sta, stx, nil, dey, nil, txa, nil, sty, sta, stx, nil,
        bcc, sta, nil, nil, sty, sta, stx, nil, tya, sta, txs, nil, nil, sta, nil, nil,
        ldy, lda, ldx, nil, ldy, lda, ldx, nil, tay, lda, tax, nil, ldy, lda, ldx, nil,
        bcs, lda, nil, nil, ldy, lda, ldx, nil, clv, lda, tsx, nil, ldy, lda, ldx, nil,
        cpy, cmp, nil, nil, cpy, cmp, dec, nil, iny, cmp, dex, nil, cpy, cmp, dec, nil,
        bne, cmp, nil, nil, nil, cmp, dec, nil, cld, cmp, nil, nil, nil, cmp, dec, nil,
        cpx, sbc, nil, nil, cpx, sbc, inc, nil, inx, sbc, nop, nil, cpx, sbc, inc, nil,
        beq, sbc, nil, nil, nil, sbc, inc, nil, sed, sbc, nil, nil, nil, sbc, inc, nil
    ];);
}

macro_rules! make_addrtable {
    ($x:ident, $t: ty) => (pub const $x: [$t; 0x100] = [
       nil, xin, nil, nil, nil, zpg, zpg, nil, nil, imm, acc, nil, nil, abs, abs, nil,
       rel, iny, nil, nil, nil, zpx, zpx, nil, nil, aby, nil, nil, nil, abx, abx, nil,
       abs, xin, nil, nil, zpg, zpg, zpg, nil, nil, imm, acc, nil, abs, abs, abs, nil,
       rel, iny, nil, nil, nil, zpx, zpx, nil, nil, aby, nil, nil, nil, abx, abx, nil,
       nil, xin, nil, nil, nil, zpg, zpg, nil, nil, imm, acc, nil, abs, abs, abs, nil,
       rel, iny, nil, nil, nil, zpx, zpx, nil, nil, aby, nil, nil, nil, abx, abx, nil,
       nil, xin, nil, nil, nil, zpg, zpg, nil, nil, imm, acc, nil, ind, abs, abs, nil,
       rel, iny, nil, nil, nil, zpx, zpx, nil, nil, aby, nil, nil, nil, abx, abx, nil,
       nil, xin, nil, nil, zpg, zpg, zpg, nil, nil, nil, nil, nil, abs, abs, abs, nil,
       rel, iny, nil, nil, zpx, zpx, zpy, nil, nil, aby, nil, nil, nil, abx, nil, nil,
       imm, xin, imm, nil, zpg, zpg, zpg, nil, nil, imm, nil, nil, abs, abs, abs, nil,
       rel, iny, nil, nil, zpx, zpx, zpy, nil, nil, aby, nil, nil, abx, abx, aby, nil,
       imm, xin, nil, nil, zpg, zpg, zpg, nil, nil, imm, nil, nil, abs, abs, abs, nil,
       rel, iny, nil, nil, nil, zpx, zpx, nil, nil, aby, nil, nil, nil, abx, abx, nil,
       imm, xin, nil, nil, zpg, zpg, zpg, nil, nil, imm, nil, nil, abs, abs, abs, nil,
       rel, iny, nil, nil, nil, zpx, zpx, nil, nil, aby, nil, nil, nil, abx, abx, nil
    ];);
}

macro_rules! ids2strs {
    ($($x:ident), *) => {
        $(#[allow(non_upper_case_globals)]
            const $x: &str = stringify!($x);)*
    };
}

pub mod disasm {
    mod disops {
        make_optable!(OPS, &str);
        ids2strs!(adc, and, asl, bcc, bcs, beq, bit, bmi,
                  bne, bpl, brk, bvc, bvs, clc, cld, cli,
                  clv, cmp, cpx, cpy, dec, dex, dey, eor,
                  inc, inx, iny, jmp, jsr, lda, ldx, ldy,
                  lsr, nop, ora, pha, php, pla, plp, rol,
                  ror, rti, rts, sbc, sec, sed, sei, sta,
                  stx, sty, tax, tay, tsx, txa, txs, tya, nil);
    }
    
    mod disaddr {
        pub type T<'a, 'b> = &'a mut Iterator<Item=&'b u8>;
        make_addrtable!(ADDR_MODES, fn (T) -> String);
        fn acc(code: T) -> String {
            "a".to_string()
        }
        fn imm(code: T) -> String {
            format!("#${:02x}", code.next().unwrap())
        }
        fn zpg(code: T) -> String {
            format!("${:02x}", code.next().unwrap())
        }
        fn zpx(code: T) -> String {
            format!("${:02x}, x", code.next().unwrap())
        }
        fn zpy(code: T) -> String {
            format!("${:02x}, y", code.next().unwrap())
        }
        fn rel(code: T) -> String {
            let b = *code.next().unwrap();
            if b >> 7 == 0 {
                format!("+${:02x}, x", b & 0x7f)
            } else {
                format!("-${:02x}, x", b & 0x7f)
            }
        }
        fn abs(code: T) -> String {
            let low = *code.next().unwrap() as u16;
            let high = *code.next().unwrap() as u16;
            format!("${:04x}", (high << 8) | low)
        }
        fn abx(code: T) -> String {
            let low = *code.next().unwrap() as u16;
            let high = *code.next().unwrap() as u16;
            format!("${:04x}, x", (high << 8) | low)
        }
        fn aby(code: T) -> String {
            let low = *code.next().unwrap() as u16;
            let high = *code.next().unwrap() as u16;
            format!("${:04x}, y", (high << 8) | low)
        }
        fn ind(code: T) -> String {
            let low = *code.next().unwrap() as u16;
            let high = *code.next().unwrap() as u16;
            format!("(${:04x})", (high << 8) | low)
        }
        fn xin(code: T) -> String {
            format!("(${:02x}, x)", code.next().unwrap())
        }
        fn iny(code: T) -> String {
            format!("(${:02x}), y", code.next().unwrap())
        }
        fn nil(code: T) -> String {
            "".to_string()
        }
    }

    pub struct Disassembler<'a, T> where T: Iterator<Item=&'a u8> {
        raw_code: T
    }
    
    impl<'a, T> Disassembler<'a, T> where T: Iterator<Item=&'a u8> {
        pub fn new(raw_code: T) -> Self {
            Disassembler{raw_code}
        }
        fn parse(opcode: u8, code: &mut T) -> String {
            format!("{} {}", disops::OPS[opcode as usize],
                             disaddr::ADDR_MODES[opcode as usize](code))
        }
    }
    
    impl<'a, T> Iterator for Disassembler<'a, T> where T: Iterator<Item=&'a u8> {
        type Item = String;
        fn next(&mut self) -> Option<Self::Item> {
            match self.raw_code.next() {
                Some(opcode) => Some(Disassembler::parse(*opcode, &mut self.raw_code)),
                None => None
            }
        }
    }
    
    pub fn parse(opcode: u8, code: &[u8]) -> String {
        Disassembler::parse(opcode, &mut code.iter())
    }
}

mod ops {
    use mos6502::CPU;
    make_optable!(OPS, fn (&mut CPU));

    fn adc(cpu: &mut CPU) {}
    fn and(cpu: &mut CPU) {}
    fn asl(cpu: &mut CPU) {}
    fn bcc(cpu: &mut CPU) {}
    fn bcs(cpu: &mut CPU) {}
    fn beq(cpu: &mut CPU) {}
    fn bit(cpu: &mut CPU) {}
    fn bmi(cpu: &mut CPU) {}
    fn bne(cpu: &mut CPU) {}
    fn bpl(cpu: &mut CPU) {}
    fn brk(cpu: &mut CPU) {}
    fn bvc(cpu: &mut CPU) {}
    fn bvs(cpu: &mut CPU) {}
    fn clc(cpu: &mut CPU) {}
    fn cld(cpu: &mut CPU) {}
    fn cli(cpu: &mut CPU) {}
    fn clv(cpu: &mut CPU) {}
    fn cmp(cpu: &mut CPU) {}
    fn cpx(cpu: &mut CPU) {}
    fn cpy(cpu: &mut CPU) {}
    fn dec(cpu: &mut CPU) {}
    fn dex(cpu: &mut CPU) {}
    fn dey(cpu: &mut CPU) {}
    fn eor(cpu: &mut CPU) {}
    fn inc(cpu: &mut CPU) {}
    fn inx(cpu: &mut CPU) {}
    fn iny(cpu: &mut CPU) {}
    fn jmp(cpu: &mut CPU) {}
    fn jsr(cpu: &mut CPU) {}
    fn lda(cpu: &mut CPU) {}
    fn ldx(cpu: &mut CPU) {}
    fn ldy(cpu: &mut CPU) {}
    fn lsr(cpu: &mut CPU) {}
    fn nop(cpu: &mut CPU) {}
    fn ora(cpu: &mut CPU) {}
    fn pha(cpu: &mut CPU) {}
    fn php(cpu: &mut CPU) {}
    fn pla(cpu: &mut CPU) {}
    fn plp(cpu: &mut CPU) {}
    fn rol(cpu: &mut CPU) {}
    fn ror(cpu: &mut CPU) {}
    fn rti(cpu: &mut CPU) {}
    fn rts(cpu: &mut CPU) {}
    fn sbc(cpu: &mut CPU) {}
    fn sec(cpu: &mut CPU) {}
    fn sed(cpu: &mut CPU) {}
    fn sei(cpu: &mut CPU) {}
    fn sta(cpu: &mut CPU) {}
    fn stx(cpu: &mut CPU) {}
    fn sty(cpu: &mut CPU) {}
    fn tax(cpu: &mut CPU) {}
    fn tay(cpu: &mut CPU) {}
    fn tsx(cpu: &mut CPU) {}
    fn txa(cpu: &mut CPU) {}
    fn txs(cpu: &mut CPU) {}
    fn tya(cpu: &mut CPU) {}
    fn nil(cpu: &mut CPU) {}
}

mod addr {
    use mos6502::CPU;
    make_addrtable!(ADDR_MODES, fn (&mut CPU));

    fn acc(cpu: &mut CPU) {}
    fn imm(cpu: &mut CPU) {}
    fn zpg(cpu: &mut CPU) {}
    fn zpx(cpu: &mut CPU) {}
    fn zpy(cpu: &mut CPU) {}
    fn rel(cpu: &mut CPU) {}
    fn abs(cpu: &mut CPU) {}
    fn abx(cpu: &mut CPU) {}
    fn aby(cpu: &mut CPU) {}
    fn ind(cpu: &mut CPU) {}
    fn xin(cpu: &mut CPU) {}
    fn iny(cpu: &mut CPU) {}
    fn nil(cpu: &mut CPU) {}
}

pub trait VMem {
    fn read(addr: u16) -> u8;
    fn write(addr: u16, data: u8);
}

pub struct CPU {
    /* registers */
    a: u8,
    x: u8,
    y: u8,
    status: u8,
    pc: u8,
    sp: u8,
    /* internal state */
    ea: u16,    /* effective address */
}

impl CPU {
    fn step(&mut self, opcode: u8) {
        ops::OPS[opcode as usize](self);
        addr::ADDR_MODES[opcode as usize](self);
    }
    fn new() -> Self {
        CPU{a: 0, x: 0, y: 0, status: 0, pc: 0, sp: 0, ea: 0}
    }
}