; .setcpu "65C02"
    .include "./macro.inc"

; okay so rn i wanna set up a very basic system init, and write a few subroutines to draw characters at x,y coordinates
n = $01 ; temporary storage for data stack operations

key_row = $200 ; used for character lookup when key pressed
key_col = $201
cursor = $202

char_buffer = $300 ; 256 byte character buffer

kb_row = $4400 ; keyboard hardware register
kb_row_cache = $203 ; cache 

    .org $8000

reset:
    sei
    ldx #0; initialize data stack pointer

initdisplay:
    lda #0
    ldy #0

cleardisplay:
    sta $6000,y
    sta $6100,y
    sta $6200,y
    sta $6300,y
    sta $6400,y
    sta $6500,y
    sta $6600,y
    sta $6700,y ; this goes slightly over but it's fine
    iny
    bne cleardisplay
    cli

print_test:
    lda #0
    sta key_row
    lda #5
    sta key_col
    push_coords #5, #5

main:
    ; jsr printtext
    ; key_zero:
    ;     stz keyboard_cache, x
    ;     dex
    ;     bpl key_zero
    ; fim: 
    ;     cli
    ;     bra fim
    jsr print
    ; jsr print
    stp
    jmp main
    


; keyboard: ; reads keyboard registers and stores the column and row of the first key found
;     ; TODO: make this routine store up to 8 indices (for 8 key rollover)
;     ldy #0 
;     .check_row: ; loop through each row
;         lda kb_row, y
;         beq .skip_row ; if row has no key pressed, skip checking which key
;         ; jmp key_down
;         sta kb_row_cache, y ; if key pressed, cache it
;         lda kb_row, y
;         cmp kb_row_cache, y ; has key changed?
;         beq key_down
;         .skip_row:
;             iny
;             cpy #5
;             bne .check_row
;     rts

;     key_down:               ; a is loaded with the row byte
;         phy
;         sty key_row         ; store character row
;         ldy #0
;         .find_col:          ; test each row bit, store column if key pressed
;             lsr             ; test bit 7
;             bcs store_col       ; if unset, don't go store character columnb
;             .skip:
;                 iny
;                 cpy #8
;                 bne .find_col   ; loop until we've checked each bit
;             rts

;     store_col:
;         sty key_col
;         jsr print
;         rts




print: ; x y -- prints the key indexed with key_col and key_row at position x, y

    keymap_index:
        push
        lda key_col
        stz 1, x
        sta 0, x
        push
        lda #8
        stz 1, x
        sta 0, x
        push
        lda key_row
        stz 1, x
        sta 0, x
        jsr mult
        jsr plus
        lda 0, x
        tay
    lda keymap, y
    push
    sta 0, x
    stz 1, x
    jsr draw_char
    rts

    keymap:
        .byte "?outrew?"
        .byte "?piygsq?"
        .byte "a??khvd?"
        .byte "42ljbfz?"
        .byte "31?mncx?"
        .byte "?????  m"

draw:
    ; push_coords #0, #0
    ; push_char #$00
    ; jsr draw_char
    rts

draw_char: ; draw a character c at (x, y) (n1: x n2: y n3: c -- )
    lda 0, x ; load a with character to draw
    pop ; and pop it off the stack
    jsr get_char_address ; calculate where to put the character in memory
    sta (0, x) ; store a at the address pointed to on the stack
    rts

get_char_address:   ; gets vram address for a character at (x, y),
                    ; (n1: x n2: y -- n: $6000 + x + (64 * y))
    ;jsr push_lit ; push 64 onto stack, low byte first
    ;.byte 64
    ;.byte 0
    pha
    lda #64
    push ; doing this instead until `push_lit` is fixed
    sta 0, x
    stz 1, x
    jsr mult ; multiply 64 with y (n2)
    jsr plus ; add result with x (n1)

    ;jsr push_lit ; push vram address onto the stack
    ;.byte $00
    ;.byte $60
    lda #$60
    push
    sta 1, x
    stz 0, x
    jsr plus ; add vram start address to result

    pla
    rts

fill: ; fills an area from (x1, y1) to (x2, y2) will character c, (n1: c n2: x1 n3: y1 n4: x2 n5: y2 -- )
    jsr get_char_address

isr: ; interrupt service routine
    pha
    phx
    phy
    ; jsr keyboard
    ply
    plx
    pla
    rti

    .include "math.inc"

    .org $fffc
    .word reset
    .word isr