#include "kernel.inc"
    .db "KEXC"
    .db KEXC_ENTRY_POINT
    .dw start
    .db KEXC_STACK_SIZE
    .dw 30
    .db KEXC_NAME
    .dw name
    .db KEXC_HEADER_END
name:
    .db "keyboard", 0
start:
    ; This is an example program, replace it with your own!
    
    ; Get a lock on the devices we intend to use
    pcall(getLcdLock)
    pcall(getKeypadLock)

    ; Allocate and clear a buffer to store the contents of the screen
    pcall(allocScreenBuffer)
    pcall(clearBuffer)
    pcall(fastCopy)

    kld(hl, packet)
    kld((packet_callback + 1), hl) ; relocate

    pcall(getCurrentThreadId)
    kld((resume_callback + 1), a)

    kld(ix, packet_callback)
    ld b, 4 \ ld a, 0x51
    pcall(ioRegisterHandler)

    kld(hl, .ready)
    kcall(log)

.loop:
    kld(a, (packet))
    or a
    kcall(nz, handle_packet)

    pcall(getKey)

    cp kMODE
    jr nz, .loop
    ret

.ready:
    .db "Ready", 0

handle_packet:
    kld(hl, .packet_text)
    kcall(log)
    kld(a, (packet + 1))
    ld b, a
    kld(de, (cur@log))
    kld(hl, packet_handlers)
.loop:
    ld a, (hl)
    inc hl
    cp 0xFF
    jr z, .none
    cp b
    jr z, .found
    jr .loop
.none:
    kld(hl, .none)
    kcall(log)
    jr .done
.none_text:
    .db "<- ??", 0
.packet_text:
    .db "Got packet", 0
.done:
    xor a
    kld((packet), a)
    ret
.found:
    ld e, (hl)
    inc hl
    ld d, (hl)
    ex de, hl
    kld(bc, 0)
    add hl, bc
    kld(de, .done)
    push de
    push hl
    ret

send_buffer:
    pcall(ioSendBuffer)
    ret z
    jr send_buffer

log:
    push de
    push bc
        kld(de, (.cur))
        pcall(drawStr)
        ld b, 0
        pcall(newline)
        pcall(fastCopy)
        kld((.cur), de)
    pop bc
    pop de
    ret
.cur:
    .dw 0

packet_handlers:
    .db 0x01
    .dw handle_ping
    .db 0x02
    .dw handle_list_dir
    .db 0xFF

handle_ping:
    kld(hl, .log)
    kcall(log)
    kld(hl, .response)
    ld bc, 4
    kld(ix, resume_callback)
    di \ kcall(send_buffer) \ ei
    pcall(suspendCurrentThread)
    kld(hl, .log_pong)
    kcall(log)
    ret
.response:
    .db 0x52, 0x01, 0x00, 0x00
.log:
    .db "-> ping", 0
.log_pong:
    .db "<- pong", 0

handle_list_dir:
    ret

resume_callback:
    ld a, 0
    pcall(resumeThread)
    ret

packet_callback:
    ld de, packet
    push de
        ld bc, 4
        ldir
    pop de
    ex de, hl
    inc hl \ inc hl
    ld c, (hl) \ inc hl
    ld b, (hl)
    ld hl, 0
    pcall(cpHLBC)
    ; if nz, allocate a buffer for the rest of the packet
    ld bc, 0
    ret

packet:
    .db 0, 0, 0, 0