INCLUDE "WRISTAPP.I"

	org $100
		jmp	test


idx		EQU	$60
lidx		EQU	$61
k		EQU	$62
src1		EQU	$63
src2		EQU	$64
dest		EQU	$65
i		EQU	$66
j		EQU	$67


; BYTES 60-67 are persisent RAM for our use
; BYTES 110-435 are copied in from the EEPROM when we run

	org $110
START	EQU   *

;0x110 The main entry point - WRIST_MAIN
	jmp	main

;0x113 Called when we are suspended for any reason - WRIST_SUSPEND
	rts
	nop
      	nop

;0x116 Called to handle any timers or time events - WRIST_DOTIC
	rts
	nop
	nop

;0x119 Called when the COMM app starts and we have timers pending - WRIST_INCOMM
	rts
	nop
	nop

;0x11c Called when the COMM app loads new data - WRIST_NEWDATA
	rts
	nop
        nop

;0x11f The state table get routine - WRIST_GETSTATE
	lda	state_table0,X
        rts

;0x123 The state handler for state 0
	jmp	handle_st0_event
;0x126 Offset of state zero into the state table
        db  	state_table0 - state_table0


hello_string:   timex6  "HELLO "

; state table
state_table0:
        	db  	0
		db	EVT_ENTER,	TIM_ONCE,	0 	; Initial state
 	        db  	EVT_RESUME,	TIM_ONCE,	0	; Resume from a nested app
        	db  	EVT_DNNEXT,	TIM_ONCE,	0	; Next button
        	db  	EVT_MODE,	TIM_ONCE,	$FF	; Mode button - quit
        	db  	EVT_END

;
; (7) This is the main initialization routine which is called when we first get the app into memory
;
main:
		lda	#$c0		        ; We want button beeps and to indicate that we have been loaded
		sta	$96
	    	rts


handle_st0_event:
 	  	bset	1,$8f			; Indicate that we can be suspended
;         	lda	BTNSTATE		; Get the event
		
		jsr	CLEARALL		; Clear the screen

		lda	#hello_string-start
		jsr	PUT6TOP                 

		lda	#SYS8_MODE              ; Get the system offset for the 'MODE' string
		jsr	PUTMSGBOT               ; and put it on the bottom line

		rts



test:


		lda	#0
		sta	lidx

		; data starts off as all zeros
		; fixme correct time here
		lda	#$a6
		sta	DATA1+4
		lda	#$a7
		sta	DATA1+5

		; don't need to init H from IH already there
		jsr	sha1_block
		inc	lidx
		jsr	sha1_block

		; Copy H->DATA, IH->H
		ldx	#20
test_l1:
		lda	(H-1),x
		sta	(DATA1-1),x
		lda	(IH-1),x
		sta	(H-1),x
		decx
		bne test_l1

		lda 	#$80
		sta	DATA1+23

		lda	#$a0
		sta	DATA2

		; set KEYOR = 5c5c5c5c
		lda	#$5c
		ldx 	#4
test_l2:
		sta	(KEYOR-1),x
		decx
		bne	test_l2

		dec	lidx
		jsr	sha1_block
		inc	lidx
		jsr	sha1_block

		lda 	H+16
		and	#$F
		tax
		add	#(H-BASE_START)
		sta	src1
		lda	H+3,x
		and	#$7F
		sta	H+3,x
		lda	#(T1-BASE_START)
		sta	dest
		lda	#(ZERO-BASE_START)
		jsr 	add4
		
		

end:		bra end



get_w32_015_to_t2:
		lda	#(T2-BASE_START)
		sta	dest
		lda	#(ZERO-BASE_START)
		sta	src1

		lda	lidx
		cmp 	#0
		bne 	get_w32_015_to_t2_l1

			lda	j
			cmp 	#3
			bhs	get_w32_015_to_t2_z1
				lsla
				lsla
				add	#(KEY-BASE_START)
				sta	src1
get_w32_015_to_t2_z1:
			lda	#(ZERO-BASE_START)
			jsr	add4
			lda	#(T2-BASE_START)
			sta	src1
			lda	#(KEYOR-BASE_START)
			jsr 	xor4
		rts
get_w32_015_to_t2_l1:
		lda	j
		cmp	#6
		bhs	get_w32_015_to_t2_l2
			lsla
			lsla
			add	#(DATA1-BASE_START)
			bra	get_w32_015_to_t2_e
get_w32_015_to_t2_l2:
		cmp	#15
		bne	get_w32_015_to_t2_l3
			lda	#(DATA2-BASE_START)
			bra	get_w32_015_to_t2_e
get_w32_015_to_t2_l3:	
			lda	#(ZERO-BASE_START)
get_w32_015_to_t2_e:
		jsr	add4
		rts

get_w32_to_t2:
	lda	idx
	cmp	#16
	bhs	get_w32_to_t2_l0
		sta	j			; <16 use our function
		jsr	get_w32_015_to_t2
		rts
get_w32_to_t2_l0:
	sub 	#15				; store number of iterations needed in i
	sta	i

	; fill W
	lda	#0
	sta	j
get_w32_to_t2_l1:
		jsr	get_w32_015_to_t2	
		lda	j
		lsla
		lsla
		add	#(WBUF-BASE_START)
		sta 	dest
		lda	#(T2-BASE_START)
		sta	src1
		lda	#(ZERO-BASE_START)
		jsr 	add4

	inc	j
	lda	j	
	cmp 	#16
	bne	get_w32_to_t2_l1	


get_w32_to_t2_l2:
		lda	#(T2-BASE_START)
		sta	dest
		lda	#(WBUF13 - BASE_START)
		sta	src1
		lda	#(WBUF8 - BASE_START)
		jsr	xor4		; T2 =W13 ^ W8
		lda	#(T2-BASE_START)
		sta	src1
		lda	#(WBUF2 - BASE_START)
		jsr	xor4		; T2 = T2 ^ W2
		lda	#(WBUF0 - BASE_START)
		jsr	xor4		; T2= T2 ^ W0
		lda	#1
		jsr	rot_left	; T2= ROTLEFT(T2,1)


		; for (x=0;x<14;++x) wbuf[x]=wbuf[x+1]
		ldx	#((WBUF0 + $FF - 3 ) - WBUF14)
get_w32_to_t2_l3:
			lda 	(WBUF15 + 3 - $FF),x
			sta 	(WBUF14 + 3 - $FF),x
		incx
		bne	get_w32_to_t2_l3
		lda	#(WBUF15-BASE_START)
		sta	dest
		lda	#(ZERO-BASE_START)
		jsr	add4		; WBUF15=T2
		
	dec i
	bne get_w32_to_t2_l2
	rts


sha1_block:	
		ldx #20

sha1_block_copy_h_to_ae_loop:
		lda 	(H-1),x
		sta	(VA-1),x
		decx
		bne	sha1_block_copy_h_to_ae_loop

		lda	#0

sha1_block_loop:	
			; a contains idx
			sta	idx
			cmp	#20
			bhs	sha1_block_k2
				lda	#(K1-BASE_START)
				sta	k

				; T1 = (B & C) | ((~B) & D)
				lda	#(T2-BASE_START)
				sta	dest
				lda	#(VB-BASE_START)
				sta	src1
				lda	#(FFFFFFFF-BASE_START)
				jsr	xor4	;T2=~B

				lda	#(T2-BASE_START)
				sta	src1
				lda	#(VD-BASE_START)
				jsr	and4	;T2=T2&D

				bra	sha1_block_t2_or_bandc ; T1=T2 | (B&C)
sha1_block_k2:
			cmp	#40
			bhs	sha1_block_k3
				lda	#(K2-BASE_START)
				sta	k
				bra	sha1_block_k24 ; T1 = B ^ C ^ D

sha1_block_k3:
			cmp	#60
			bhs	sha1_block_k4
				; T1 = (B & C) | (B & D) | (C & D)
				lda	#(K3-BASE_START)
				sta	k

				lda	#(T1-BASE_START)
				sta	dest
				lda	#(VD-BASE_START)
				sta	src1
				lda	#(VB-BASE_START)
				jsr	and4	; T1=B&D

				lda	#(T2-BASE_START)
				sta	dest
				lda	#(VC-BASE_START)
				jsr	and4	; T2=C&D

				lda	#(T2-BASE_START)
				sta	src1
				lda	#(T1-BASE_START)
				jsr	or4	; T2=T1|T2

sha1_block_t2_or_bandc:

				lda	#(T1-BASE_START)
				sta	dest
				lda	#(VB-BASE_START)
				sta	src1
				lda	#(VC-BASE_START)
				jsr	and4	; T1 = B&C

				lda	#(T1-BASE_START)
				sta	src1
				lda	#(T2-BASE_START)
				jsr	or4	; T1= T1|T2

				bra	sha1_block_shuffle

sha1_block_k4:
				lda	#(K4-BASE_START)
				sta	k
sha1_block_k24:
				; T1 = B ^ C ^ D
				lda	#(T1-BASE_START)
				sta	dest
				lda	#(VB-BASE_START)
				sta	src1
				lda	#(VC-BASE_START)
				jsr	xor4
				lda	#(T1-BASE_START)
				sta	src1
				lda	#(VD-BASE_START)
				jsr	xor4
sha1_block_shuffle:
			; T1 is src1 and dest here

			lda	#(VE-BASE_START)
			jsr	add4	; T1=T1+E

			lda	k
			jsr	add4	; T1=T1+k

			jsr	get_w32_to_t2 	; W[i]->T2

			lda	#(T1-BASE_START)
			sta	dest
			sta	src1
			lda	#(T2-BASE_START)
			jsr	add4	; T1=T1+data

			lda	#(VD-BASE_START)
			jsr 	copy_up	; E=D
			lda	#(VC-BASE_START)
			jsr 	copy_up	; D=C
			lda	#(VB-BASE_START)	
			jsr 	copy_up	; C=B
			lda	#30
			jsr	rot_left	; C=ROTLEFT(C,30)
			lda	#(VA-BASE_START)	
			jsr 	copy_up	; B=A

			lda	#(VA-BASE_START)
			sta	dest
			sta	src1
			lda	#5
			jsr	rot_left	; A=ROTLEFT(A,5)

			lda	#(T1-BASE_START)
			jsr	add4		; A=A+T1


		lda	idx
		add	#1
		cmp 	#80
		bhs	sha1_block_done
		jmp 	sha1_block_loop
sha1_block_done:


		ldx	#0
sha1_block_add0:
		clc
sha1_block_add1:
		lda	VA,x
		adc	H,x
		sta	H,x
		incx
		txa	
		and	#3
		bne	sha1_block_add1
		cpx	#20
		bne	sha1_block_add0

		rts


copy_up:
		sta	src1
		add	#4
		sta	dest
		lda	#(ZERO-BASE_START)

add4:
		sta	src2
		lda	#$d9	; adc $ffff,a
		sta 	op4_src2
		bra 	op4_binary

and4:
		sta	src2
		lda	#$d4	; and $ffff,a
		sta 	op4_src2
		bra 	op4_binary

xor4:
		sta	src2
		lda	#$d8	; eor $ffff,a
		sta 	op4_src2
		bra	op4_binary
or4:
		sta	src2
		lda	#$da	; or $ffff,a
		sta 	op4_src2
op4_binary:		
		ldx	#0
		lda	#BASE_START & $ff
		add	src2
		sta	op4_src2+2
	        txa	
		adc 	#BASE_START>>8
		sta	op4_src2+1

		lda	#BASE_START & $ff
		add	src1
		sta	op4_src1+2
		txa 	
		adc 	#BASE_START>>8
		sta	op4_src1+1

		lda	#BASE_START & $ff
		add	dest
		sta	op4_dst+2
		txa 	
		adc 	#BASE_START>>8
		sta	op4_dst+1
		 		
		clc
op4_1:
op4_src1:
			lda	$fffe,x
op4_src2:
			adc	$fffe,x
op4_dst:
			sta	$fffe,x
			incx
			txa
			and	#3
			bne	op4_1
		rts

rot_left:	
		ldx dest
		sta 	j
rot_loop:
		lda	BASE_START,x
		rola
		lda	BASE_START+1,x
		rola
		sta	BASE_START+1,x
		lda	BASE_START+2,x
		rola
		sta	BASE_START+2,x
		lda	BASE_START+3,x
		rola
		sta	BASE_START+3,x
		lda	BASE_START,x
		rola
		sta	BASE_START,x
		dec	j
		bne 	rot_loop
		rts

		
BASE_START:

KEY:
		DB	$89
		DB	$0e
		DB	$38
		DB      $6e


		DB	$bb
		DB	$3c
		DB	$cf
		DB	$e9

		DB	$00
		DB	$00
		DB	$4f
		DB	$e4
		
IH:
		DB      $01
		DB      $23
		DB      $45
		DB      $67
		DB      $89
		DB      $AB
		DB      $CD
		DB      $EF
		DB      $FE
		DB      $DC
		DB      $BA
		DB      $98
		DB      $76
		DB      $54
		DB      $32
		DB      $10
		DB      $F0
		DB      $E1
		DB      $D2
		DB      $C3
		
H:
		DB      $01
		DB      $23
		DB      $45
		DB      $67
		DB      $89
		DB      $AB
		DB      $CD
		DB      $EF
		DB      $FE
		DB      $DC
		DB      $BA
		DB      $98
		DB      $76
		DB      $54
		DB      $32
		DB      $10
		DB      $F0
		DB      $E1
		DB      $D2
		DB      $C3
K1:
        DB      $99
        DB      $79
        DB      $82
        DB      $5A
K2:
        DB      $A1
        DB      $EB
        DB      $D9
        DB      $6E
K3:
		DB      $DC
		DB      $BC
		DB      $1B
		DB      $8F
K4:
		DB      $D6
		DB      $C1
		DB      $62
		DB      $CA
K5:
		DB      $D0
		DB      $83
		DB      $8C
		DB      $46

FFFFFFFF:
		DB 	$FF
		DB 	$FF
		DB 	$FF
		DB 	$FF

KEYOR:
		DW	$3636
		DW	$3636


bss:

VA:		DW	0
		DW	0
VB:		DW	0
		DW	0
VC:		DW	0
		DW	0
VD:		DW	0
		DW	0
VE:		DW	0
		DW	0

T1:		DW	0 
		DW	0

T2:		DW	0 
		DW	0

ZERO:		DW	0 
		DW	0


WBUF:		
WBUF0:
		DW	0
		DW	0
WBUF1:
		DW	0
		DW	0
WBUF2:
		DW	0
		DW	0
WBUF3:
		DW	0
		DW	0
WBUF4:
		DW	0
		DW	0
WBUF5:
		DW	0
		DW	0
WBUF6:
		DW	0
		DW	0
WBUF7:
		DW	0
		DW	0
WBUF8:
		DW	0
		DW	0
WBUF9:
		DW	0
		DW	0
WBUF10:
		DW	0
		DW	0
WBUF11:
		DW	0
		DW	0
WBUF12:
		DW	0
		DW	0
WBUF13:
		DW	0
		DW	0
WBUF14:
		DW	0
		DW	0
WBUF15:
		DW	0
		DW	0


DATA1:
		DW	0
		DW	0
		DW	0
		DW	0
		DB	0
		DB	0
		DB	0
		DB	$80
		DW	0
		DW	0
		DW	0
		DW	0
		DW	0
		DW	0
DATA2:	
		DB	$40
		DB	$02
		DB	0
		DB	0

BASE_END: