; Testing input.
;
; Writen in Sux assembly by
; mr b0nk 500 <b0nk@b0nk.xyz>


; Initalize some variables.
.org $1000
string:
	.byte "Please, type something.\n"
string2:
	.byte "You typed, "
end:
	.byte $0
scr_row:
	.word $0
scr_col:
	.word $0
a:
	.word $0
b:
	.word $0

; Input buffer.
.org $2000
buffer:

; Main program
.org $8000
reset:
	cps
	ldx.w #$FFFF
	txs
	ldy #$0
clr_buf:
	lda #$0
	cpy.w #$1000
	beq start
	sta buffer, y
	iny
	jmp clr_buf

start:
	ldx.w #$0	; Reset x.
	ldy #$0		; Reset y.
	jmp print

rset_a:
	lda #$10
delay:
	beq read
	dec
	jmp delay
sleep:
	lda end
	bne spin	; Are we done with getting input?
read:
	lda $C000	; Get control register.
	beq rset_a	; Loop until we get a character.
	lda #$0
	sta $C000
	jmp getchar	; We got a key.

print:
	lda string, x	; Get character at offset x.
	beq rset_a	; Did we find a null terminator?
	sta $C001	; Print character.
	inx		; Increment offset.
	jmp print	; Keep printing more characters.

getchar:
	lda $C002	; Get typed character.
	cmp #$1B
	beq esc
	cmp #$A
	beq nl		; Did the user type a newline?
	cmp #$8
	beq bs		; Did the user type a backspace?
	cmp #$7F
	beq bs		; Did the user type a backspace?
echo:
	sta $C001	; Echo typed character.
	sta buffer, y	; Store typed character into the input buffer.
	iny		; Increment buffer offset.
	jmp rset_a	; We are not, so add the backspace to the buffer.

esc:
	lda $C000	; Skip the '['.
	lda $C000	; Get the next character.
	beq read	; We have an error, so discard it, and read the next character.
	lda $C002	; Get the escape code.
	cmp #$41	; Did the user press the up arrow?
	beq up		; Yes, so move the cursor up.
	cmp #$42	; Did the user press the down arrow?
	beq down	; Yes, so move the cursor down.
	cmp #$43	; Did the user press the right arrow?
	beq right	; Yes, so move the cursor right.
	cmp #$44	; Did the user press the left arrow?
	beq left	; Yes, so move the cursor left.
up:
	lda scr_row
	beq rset_a
	dec scr_row
	jsr update_pos
	lda #$1B
	sta $C001
	lda #$5B
	sta $C001
	lda #$41
	sta $C001
	jmp rset_a
down:
	inc scr_row
	jsr update_pos
	lda #$1B
	sta $C001
	lda #$5B
	sta $C001
	lda #$42
	sta $C001
	jmp rset_a
right:
	lda scr_col
	cmp #$50
	beq rset_a
	inc scr_col
	jsr update_pos
	lda #$1B
	sta $C001
	lda #$5B
	sta $C001
	lda #$43
	sta $C001
	jmp rset_a
left:
	lda scr_col
	beq rset_a
	dec scr_col
	jsr update_pos
	lda #$1B
	sta $C001
	lda #$5B
	sta $C001
	lda #$44
	sta $C001
	jmp rset_a

update_pos:
	lda #$1B
	sta $C001
	lda #$5B
	sta $C001
	lda scr_row
	jsr uint_to_bcd
	jmp spin

uint_to_bcd:
	div #$A
	lsl #$4
	sta a
	tba
	sta b
	lda a
	ora b
	rts

nl:
	lda #$A
	sta $C001
	inc scr_row
	jsr update_pos
	lda #$0		; Replace newline with a null terminator.
	sta buffer, y	; Store said terminator into the input buffer.
	ldy.w #$0	; Reset y, to print the result.
	jmp result

back:
	sta $C001	; Print backspace.
	lda #$0		; Put a null terminator, in place of the backspace.
	sta buffer, y	; Place it into the input buffer.
	dey		; Decrement buffer offset.
	jmp read	; Get next character.

bs:
	cpy #$0		; Are we at the start of the buffer?
	beq rset_a	; We are, so do not store the backspace into the buffer.
	jmp back	; We are not, so add the backspace to the buffer.

result:
	lda string2, y
	beq rset_y	; Reset y, if we hit the null terminator.
	sta $C001	; Print 'You have typed, '
	iny		; Increment offset.
	jmp result	; Keep printing.


rset_y:
	ldy.w #$0
	jmp print_buf	; Print the input buffer.

print_buf:
	lda buffer, y	; Get a character from the input buffer.
	beq spin	; Are we done with printing the buffer?
	sta $C001	; Print said character.
	iny
	jmp print_buf	; Keep printing the buffer.

spin:
	nop
	nop
	nop
	jmp spin

.org $FFC0
.qword reset

.org $FF50
.qword spin
.qword spin
.qword spin
.qword spin
.qword spin
.qword spin
.qword spin

.org $FFA0
.qword irq_routine
.org $8000
viewmem
.org $8100
viewmem
;q
done