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

; Instruction mnemonics,
; and opcodes.
.org $1000
tok:
	.byte "dab"
msg:
	.byte "oof, you divided a, and b on me.\n"

; Input buffer.
.org $2000
buffer:

.org $4000
cmd_buf:

.org $200
bitmask:
	.byte $0
bitabl:
	.qword $0
	.word $0
bits:
	.byte $0

; Initalize some variables.
.org $0
scr_row:
	.byte $0
scr_col:
	.byte $0
scr_lnst:
	.word $0
scr_lncnt:
	.word $0
scr_rowst:
	.byte $0
a:
	.byte $0
b:
	.byte $0
c:
	.byte $0
d:
	.byte $0
e:
	.byte $0
string:
	.byte "Please, type something.\n"
string2:
	.byte "You typed, "
end:
	.byte $0

; Pointers
ptr:
	.qword buffer
cptr:
	.qword cmd_buf
tptr:
	.qword tok
mptr:
	.qword msg
bmptr:
	.qword bitmask
btptr:
	.qword bitabl

; Main program
.org $8000
reset:
	cps
	ldx.w #$FFFF
	txs
	ldy #0
	lda #0
	jsl clr_buf
	jmp start
clr_buf:
	lda #0
	cpy.w #$1FFF
	beq clr_buf_end
	sta (ptr), y
	iny
	jmp clr_buf
clr_buf_end:
	ldy.w #0
	rtl

start:
	lda #0
	tax
	sta $C000
	phy #2
	ldy.w #0
	jsl clr_cbuf
	ply #2
	lda #1
	sta $C000
	jmp print

clr_cbuf:
	cpy.w #$3FF
	beq clr_cbuf_end
	sta (cptr), y
	iny
	jmp clr_cbuf
clr_cbuf_end:
	rtl

pull_y:
	ply #2
rset_a:
	lda #0
	sta $C000
	inc
read:
	lda $C000	; Get control register.
	beq rset_a	; Loop until we get a character.
	jsl getchar	; We got a key.
	beq parse	; We got a newline, so start parsing the line.
	jmp rset_a	; We didn't get a newline, so keep getting more characters.
sleep:
	lda end
	bne spin	; Are we done with getting input?

print:
	phy #2
	txy
	lda string, y	; Get character at offset x.
	beq pull_y	; Did we find a null terminator?
	ply #2
	inx
	jsl print_char
	jmp print

getbit:
	phy #2
	ldx scr_row
getbt1:
	jsl bitpos
	txy
	ldb (btptr), y
	ply #2
	aba
	cmp #1
	jmp bitout

bitpos:
	stx bitmask
	txa
	and #7
	tax
	lda bits, x
	pha #1
	lda bitmask
	lsr #3
	tax
	pla #1
	rtl

bitout:
	ldx bitmask
	rtl

getchar:
	lda $C002	; Get typed character.
	pha #1
	phy #2
	cmp #10
	beq cmd_cpy
getchar_pnt:
	ply #2
	pla #1
	jsl print_char
	lda a
	cmp #10
	beq getchar_line
	jmp getchar_char
cmd_cpy:
	lda scr_row
	mul #80
	tay
	ldx.w #$0
cmd_cpy_strt:
	lda (ptr), y
	beq getchar_pnt
	phy #2
	txy
	sta (cptr), y
	inx
	ply #2
	iny
	jmp cmd_cpy_strt
getchar_line:
	lda #$0
	sta scr_lncnt
	jmp getchar_end
getchar_char:
	lda #$1
getchar_end:
	rtl

parse:
	lda #0
	tax
	jsl dabbed
	beq start
	lda #0
	tax
	jmp result

print_char:
	sta a
	cmp #$1B
	beq esc
	cmp #$A
	beq nl		; Did the user type a newline?
	cmp #$C
	beq clr_scr
	cmp #8
	beq bs		; Did the user type a backspace?
	cmp #$7F
	beq bs		; Did the user type a backspace?
	sta a
	ldb scr_col
	cpb #79
	beq linewrap
	jmp printc
linewrap:
	ldb #0
	stb scr_col
	lda #$42
	sta c
	jsl isdown
	ldb scr_row
	cpb #23
	beq printc_end
printc:
	lda a
	inc scr_col	; Increment the cursor's x coordinate.
	inc scr_lncnt
	sta (ptr), y	; Store typed character into the input buffer.
	iny
	sta $C001	; Echo typed character.
printc_end:
	rtl

nl:
	lda #0
	sta (ptr), y	; Store said terminator into the input buffer.
	sta scr_col
	lda scr_row
	cmp #23
	bne nl_inc
	lda #1
	sta a
	jmp printc_end
nl_inc:
	lda #$42
	sta c
	jsl isdown
	sty.w scr_lnst
	lda #10
	sta a
	jmp printc_end

clr_scr:
	lda #0
	sta.w scr_lnst
	sta scr_rowst
	tay
	jsl clr_buf
	sta scr_col
	sta scr_row
	jsl update_pos
	lda #$C
	sta $C001
	jmp printc_end

back:
	lda #$7F
	sta $C001
	dey		; Decrement buffer offset.
	lda #0		; Put a null terminator, in place of the backspace.
	sta (ptr), y	; Place it into the input buffer.
	lda #$44
	dec scr_col
	dec scr_lncnt
	jsl update_pos
	jmp printc_end	; Get next character.

bs:
	lda scr_col	; Are we at the start of the buffer?
	beq printc_end
	jmp back	; We are not, so add the backspace to the buffer.

esc:
	lda $C000	; Skip the '['.
	lda $C000	; Get the next character.
	beq printc_end	; We have an error, so discard it, and go back to getting user input.
	lda $C002	; Get the escape code.
	sta c		; Store the escape code, until we need it.
	lda #0
	sta d
	jsl isup	; Check if the user pressed up.
	lda e
	bne esc_lnst
	lda d
	bne esc_end
	jsl isdown	; Check if the user pressed down.
	lda e
	bne esc_lnst
	lda d
	bne esc_end
	lda #0
	jsl isleft	; Check if the user pressed left.
	lda d
	bne esc_end
	jsl isright	; Check if the user pressed right.
	jmp esc_end
esc_lnst:
	lda scr_row
	sta scr_rowst
	mul #80
	sta.w scr_lnst
esc_end:
	lda #0
	sta d
	jmp printc_end	; Go back to getting user input.

isup:
	lda scr_row	; Is the cursor at the top of the screen?
	beq isup_done	; Yes, so return.
	lda c		; No, so load the escape code back into the accumulator.
	cmp #$41	; Did the user press the up arrow key?
	beq up		; Yes, so move the cursor up.
isup_done:
	rtl		; End of isup.

isdown:
	lda scr_row	; Start checking the y coordinate of the cursor.
	cmp #23		; Is the cursor at the bottom of the screen?
	beq isdown_done	; Yes, so return.
	lda c		; No, so load the escape code back into the accumulator.
	cmp #$42	; Did the user press the down arrow key?
	beq down	; Yes, so move the cursor down.
	jmp isdown_done
isdown_scrl:
	lda #$1B	; Print an escape character
	sta $C001	; to the screen.
	lda #$5B	; Print '['
	sta $C001	; to the screen, and start the escape sequence.
	lda #$54	; Print 'T'
	sta $C001	; to the screen, and end the escape sequence.
isdown_done:
	rtl		; End of isdown.

isright:
	lda scr_col	; Start checking the x coordinate of the cursor.
	cmp #79		; Is the cursor at the far right of the screen?
	beq isright_end	; Yes, so return.
	lda c		; No, so load the escape code back into the accumulator.
	cmp #$43	; Did the user press the right arrow key?
	beq right	; Yes, so move the cursor right.
isright_end:
	rtl		; End of isright.

isleft:
	lda scr_col	; Is the cursor at the far left of the screen?
	beq isleft_done	; Yes, so return.
	lda c		; No, so load the escape code back into the accumulator.
	cmp #$44	; Did the user press the left arrow key?
	beq left	; Yes, so move the cursor left.
isleft_done:
	rtl		; End of isleft.

up:
	dec scr_row
	jsl update_pos
	lda #1
	sta d
	jmp isup_done
down:
	inc scr_row
	jsl update_pos
	lda #1
	sta d
	jmp isdown_done
right:
	inc scr_col
	jsl update_pos
	jmp isright_end
left:
	dec scr_col
	jsl update_pos
	lda #1
	sta d
	jmp isleft_done

update_pos:
	lda scr_row
	mul #80
	adc scr_col
	tay
	lda #$1B	; Print an escape character
	sta $C001	; to the screen.
	lda #$5B	; Print '['
	sta $C001	; to the screen, and start the escape sequence.
	jsl getrow	; Start printing the row number to the screen.
	jsl getcol	; Start printing the column number to the screen.
	lda #$48	; Print 'H'
	sta $C001	; to the screen.
	rtl		; End of update_pos.

getrow:
	lda scr_row	; Get the cursor's y coordinate.
	div #10		; Divide A by 10.
	adc #$30	; Convert it to ascii, and
	sta $C001	; print to the screen.
	tba		; Get the remainder.
	adc #$30	; Convert it to ascii, and
	sta $C001	; print to the screen.
	rtl		; End of getrow.

getcol:
	lda #$3B	; Print ';'
	sta $C001	; to the screen.
	lda scr_col	; Get the cursor's x coordinate.
	div #10		; Divide A by 10.
	adc #$30	; Convert it to ascii, and
	sta $C001	; print to the screen.
	tba		; Get the remainder.
	adc #$30	; Convert it to ascii, and
	sta $C001	; print to the screen.
	rtl		; End of getrow.

result:
	phy #2
	txy
	lda string2, y
	beq rset_y	; Reset y, if we hit the null terminator.
	ply #2
	jsl print_char	; Print 'You have typed, '
	inx
	jmp result	; Keep printing.

rset_y:
	ply #2
	lda #0		; Reset a.
	tax		; Reset y.
	jmp print_buf	; Print the input buffer.

dabbed:
	phy #2
	txy
	lda (cptr), y	; Get a character from the input buffer.
	beq dab_pend	; Are we done with printing the buffer?
	cmp (tptr), y
	bcs dab_pend
	beq chk_str
	bcc dab_pend
chk_str:
	ply #2
	inx
	cpx #3
	bne dabbed
	ldx #0
pnt_msg:
	phy #2
	txy
	lda (mptr), y	; Get a character from the input buffer.
	beq dab_peqnd	; Are we done with printing the buffer?
	ply #2
	jsl print_char
	inx
	jmp pnt_msg	; Keep printing the buffer.
dab_pend:
	ply #2
	lda #1
	jmp dab_end
dab_peqnd:
	ply #2
	lda #0
	jmp dab_end
dab_end:
	rtl

print_buf:
	phy #2
	txy
	lda (cptr), y	; Get a character from the input buffer.
	beq cmd_clr	; Are we done with printing the buffer?
	ply #2
	jsl print_char
	inx
	jmp print_buf	; Keep printing the buffer.

cmd_clr:
	ply #2
	lda #10
	jsl print_char
	jmp start

.org $FFC0
.qword reset

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