###
APPLE I 8k memory map
-----------------------------------------------------------------
$0FFF       : End of 1st 4k memory
$D010 KBD   : b7 is always 1. Read KBD will clear KBDCR's b7
$D011 KBDCR : When a key is pressed, b7 is set.
$D012 DSP   : b6...b0 is output character.
              Writing to DSP will set b7 by hardware
              After displaying the character, b7 will be cleared.
$E000       : Start of 2nd 4k memory.
$EFFF       : End of 2nd 4k memory.
$FF00       : Start of 256B ROM.
$FFFF       : End of 256B ROM and the memory limit
-----------------------------------------------------------------
###
exports.memory =
    rom : [
           0xd8, 0x58, 0xa0, 0x7f, 0x8c, 0x12, 0xd0, 0xa9
           0xa7, 0x8d, 0x11, 0xd0, 0x8d, 0x13, 0xd0, 0xc9
           0xdf, 0xf0, 0x13, 0xc9, 0x9b, 0xf0, 0x03, 0xc8
           0x10, 0x0f, 0xa9, 0xdc, 0x20, 0xef, 0xff, 0xa9
           0x8d, 0x20, 0xef, 0xff, 0xa0, 0x01, 0x88, 0x30
           0xf6, 0xad, 0x11, 0xd0, 0x10, 0xfb, 0xad, 0x10
           0xd0, 0x99, 0x00, 0x02, 0x20, 0xef, 0xff, 0xc9
           0x8d, 0xd0, 0xd4, 0xa0, 0xff, 0xa9, 0x00, 0xaa
           0x0a, 0x85, 0x2b, 0xc8, 0xb9, 0x00, 0x02, 0xc9
           0x8d, 0xf0, 0xd4, 0xc9, 0xae, 0x90, 0xf4, 0xf0
           0xf0, 0xc9, 0xba, 0xf0, 0xeb, 0xc9, 0xd2, 0xf0
           0x3b, 0x86, 0x28, 0x86, 0x29, 0x84, 0x2a, 0xb9
           0x00, 0x02, 0x49, 0xb0, 0xc9, 0x0a, 0x90, 0x06
           0x69, 0x88, 0xc9, 0xfa, 0x90, 0x11, 0x0a, 0x0a
           0x0a, 0x0a, 0xa2, 0x04, 0x0a, 0x26, 0x28, 0x26
           0x29, 0xca, 0xd0, 0xf8, 0xc8, 0xd0, 0xe0, 0xc4
           0x2a, 0xf0, 0x97, 0x24, 0x2b, 0x50, 0x10, 0xa5
           0x28, 0x81, 0x26, 0xe6, 0x26, 0xd0, 0xb5, 0xe6
           0x27, 0x4c, 0x44, 0xff, 0x6c, 0x24, 0x00, 0x30
           0x2b, 0xa2, 0x02, 0xb5, 0x27, 0x95, 0x25, 0x95
           0x23, 0xca, 0xd0, 0xf7, 0xd0, 0x14, 0xa9, 0x8d
           0x20, 0xef, 0xff, 0xa5, 0x25, 0x20, 0xdc, 0xff
           0xa5, 0x24, 0x20, 0xdc, 0xff, 0xa9, 0xba, 0x20
           0xef, 0xff, 0xa9, 0xa0, 0x20, 0xef, 0xff, 0xa1
           0x24, 0x20, 0xdc, 0xff, 0x86, 0x2b, 0xa5, 0x24
           0xc5, 0x28, 0xa5, 0x25, 0xe5, 0x29, 0xb0, 0xc1
           0xe6, 0x24, 0xd0, 0x02, 0xe6, 0x25, 0xa5, 0x24
           0x29, 0x07, 0x10, 0xc8, 0x48, 0x4a, 0x4a, 0x4a
           0x4a, 0x20, 0xe5, 0xff, 0x68, 0x29, 0x0f, 0x09
           0xb0, 0xc9, 0xba, 0x90, 0x02, 0x69, 0x06, 0x2c
           0x12, 0xd0, 0x30, 0xfb, 0x8d, 0x12, 0xd0, 0x60
           0x00, 0x00, 0x00, 0x0f, 0x00, 0xff, 0x00, 0x00
    ]
    cells : []
    read : (adr) ->
        @cells[adr]
    write : (adr, val) ->
        @cells[adr] = val if (0 <= adr < 0x1000 or 0xE000 <= adr < 0xF000)
        @cells[adr] = (val % 128) + 128 if (adr is 0xD012)
        return
    init : () ->
        @cells[adr] = 0 for adr in [0..0xFFFF]
        @cells[0xFF00..0xFFFF] = @rom
        return

exports.pia6820 =
    KBD   : 0xD010
    KBDCR : 0xD011
    DSP   : 0xD012
    run : () ->
        c = exports.memory.read(@DSP)
        if c >= 128
            c = c % 128 # clear bit 7
            console.log(String.fromCharCode(c))
            exports.memory.cells[@DSP] = c #clear bit 7 by hardware on DSP
            return
        else
            return

exports.m6502 =
    # registeres
    A  : 0
    X  : 0
    Y  : 0
    S  : 0 # stack pointer
    P  : 0 # processor status
    PC : 0 # 16 bit little endian
    # status flag
    N  : 0x80
    V  : 0x40
    M  : 0x20
    B  : 0x10
    D  : 0x08
    I  : 0x04
    Z  : 0x02
    C  : 0x01
    # signal & synchronization
    cyc : 0

    fetch : () ->
        console.log "#{@PC}:#{exports.memory.read(@PC)}"
        return exports.memory.read(@PC++)

    trace : () ->
        console.log "A #{@A} X #{@X} Y #{@Y} S #{@S} P #{@P} PC #{@PC}"
        return

    run : () ->
        switch @fetch()
            when 0x2C # BIT ABS
                @P = @P & (~ @Z)
                @P = @P & (~ @N)
                @P = @P & (~ @V)
                l = @fetch()
                h = @fetch()
                x = exports.memory.read((h << 8) + l)
                if (@A & x) is 0
                    @P = @P | @Z
                @P = @P | (x & @N)
                @P = @P | (x & @V)
            when 0x30 # BMI REL
                rel = @fetch()
                if (rel > 0x7F)
                    rel = -( (~rel & 0xFF) + 1)
                if (@P & @N)
                     @PC = @PC + rel
            when 0x60 # RTS
                if @S < 1 then @S = 0xFF else @S--
                @PC = exports.memory.read(0x100 + @S)
            when 0x8D # STA ABS
                l = @fetch()
                h = @fetch()
                exports.memory.write((h << 8) + l, @A)
        @trace()