;Elior
IDEAL
MODEL small
STACK 100h
DATASEG
	var1			dw 0
	var2			dw 0
	op 				db ?

	power 			dw 1

	; buffer for var1
	bufferSize1 	db 6  ; how many characters do I want to get as an input + 1 for enter at the end
	inputLength1	db 0   ; number of characters
	input1			db 6 dup(0) ; actual input

	;buffer for var2
	bufferSize2 	db 6  ; how many characters do I want to get as an input + 1 for enter at the end
	inputLength2	db 0   ; number of characters
	input2			db 6 dup(0)

	exitCondition	db ? ; at var2 translate

	res				dw ?
	digits			db 5 dup(0), '$'

	modd			dw ?
	start_msg		db 10, 13, 'Welcome to my calculaotr!', 1, 10, 13, 'Enter first number, then press Enter, then operator, then second number and then Enter again', 10, 13, 'to exit press escape and then enter', 10, 13, 'supports only positive numbers as input and numbers untill 65,535', 10, 13, '$'
	err_msg			db 'error$'
CODESEG
	proc divide
		push bp
		mov bp,sp
		cmp [var2], 0
		je err1

		xor dx, dx
		xor ax, ax
		mov ax, [var1]
		div [var2]

		mov [res], ax
		mov [modd], dx

		jmp print
		pop bp
		ret
	endp divide
	proc minus
		push bp
		mov bp,sp
		mov ax, [var1]

		; cmp ax, [var2]
		; jb neg_minus

		sub ax, [var2]
		mov [res], ax
		jmp print
		pop bp
		ret
	endp minus
	proc neg_minus
		push bp
		mov ah, 2
		mov dl, '-'
		int 21h

		mov ax, [var2]
		sub ax, [var1]
		mov [res], ax
		jmp print
		pop bp
		ret
	endp neg_minus
	proc multiplay
		push bp
		mov bp,sp
		xor dx, dx

		mov ax, [var1]
		mul [var2]
		mov [res], ax

		; if dd then err
		jmp print
		pop bp
		ret
	endp multiplay
start:
	mov ax, @data
	mov ds, ax
; --------------------------
; Your code here
; --------------------------
	; print starting msg
	mov ah, 9
	mov dx, offset start_msg
	int 21h

	; set cx=0 and start the main loop
	jmp get_inputs
	close_exit:
		jmp exit
	err1:
		mov dx, offset err_msg
		mov ah, 9
		int 21h
		jmp get_inputs
	get_inputs:
		; reset numbers for new run
		mov [var1], 0
		mov [var2], 0
		mov [power], 1

		;new line
		mov ah, 2
		mov dl, 10
		int 21h
		mov dl, 13
		int 21h

		;get var1
		mov dx, offset bufferSize1  ; load our pointer to the beginning of the structure
		mov ah, 10
		int 21h

		; if escape is pressed
		cmp [byte ptr offset input1], 1Bh
		je close_exit

		;new line
		mov ah, 2
		mov dl, 10
		int 21h
		mov dl, 13
		int 21h

		; get op
		mov ah, 1
		int 21h
		mov [op], al

		;new line
		mov ah, 2
		mov dl, 10
		int 21h
		mov dl, 13
		int 21h

		;get var2
		mov ah, 9
		mov dx, offset bufferSize2  ; load our pointer to the beginning of the structure
		mov ah, 10
		int 21h

		;new line
		mov ah, 2
		mov dl, 10
		int 21h
		mov dl, 13
		int 21h


		; translate var1
		; set bl as the end of the input
		mov bx, offset input1
		add bl, [inputLength1]
		dec bl

		; set loop to number chracters
		mov cl, [inputLength1]

		jmp var1loop
		var1loop:
			; var1 += ([bl]-30h) * power
			; var1 += ([bl + 8]-30h) * power

			;var1
			xor ax, ax

			; sub 30 from each number so it will be real number
			mov al, [bx]
			sub al, 30h

			; if not a number error
			cmp al, 10
			jae err1

			; ax = [bl] * power
			mul [power]

			add [var1], ax

			; power *= * 10
			mov ax, [power]
			push bx ; save bx
			mov bx, 10
			mul bx
			mov [power], ax
			pop bx ; get saved bx


			; set bl to next digit
			dec bl

			loop var1loop

		mov [power], 1

		; set bx to correct position of of input2
		mov bx, offset input2
		add bl, [inputLength2]
		dec bx

		; set loop to number chracters
		mov cl, [inputLength2]
		xor ax, ax
		var2loop:
			xor ax, ax

			; put number in ax
			mov al, [bx]
			; sub 30 from each number so it will be real number
			sub al, 30h

			; if not a number

			; ax = [bl] * power
			mul [power]

			add [var2], ax

			; decrese exitCondition by one to stop the second loop when needed

			; power *= * 10
			mov ax, [power]
			push bx ; save bx
			mov bx, 10
			mul bx
			mov [power], ax

			pop bx ; get saved bx

			; set bl to next digit
			dec bl

			loop var2loop

		; check ops

		cmp [op], '-' ; if -
		call minus

		cmp [op], '*' ; if *
		call multiplay

		cmp [op], '/' ; if /
		call divide

		jmp err1


	print:
		; 12345
		; 12345 / 1000 = 12 => 12 / 10 => d1 = (/) 1, d2 = (%) 2
		; 12345 / 100 = 123 => d3 = 123 % 10 = 3
		; 12345 % 100 = 45 => d4 = 45 / 10 = 4, d5 = 45 % 10 = 5

		; d1, d2
		; res / 1000
		xor dx, dx
		mov ax, [res]
		mov bx, 1000
		div bx

		; (res / 1000) / 10
		xor dx, dx
		mov bx, 10
		div bx

		; put result as first number and mod as second number
		mov [offset digits], al
		mov [offset digits + 1], dl

		; d3
		; res / 100
		xor dx, dx
		mov ax, [res]
		mov bx, 100
		div bx

		push dx

		; res mod 10
		xor dx, dx
		mov bx, 10
		div bx

		; put mod as 3rd digit
		mov [offset digits + 2], dl

		; d4 d5
		; res mod 100
		pop ax
		; (res mod 100) / 10
		xor dx, dx
		mov bx, 10
		div bx

		mov [offset digits + 3], al
		mov [offset digits + 4], dl

		mov cx, 5
		xor si, si

		; check when actual number starts
		lo1:
			cmp [byte ptr offset digits + si], 0
			je incStart
			jmp done

		incStart:
			inc si
			loop lo1
		done:

		; print zero if all digits are 0
		cmp si, 5
		je printZero
		jmp notZero

		printZero:
			mov ah, 2
			mov dx, '0'
			int 21h
			jmp get_inputs

		notZero:


		; translate numbers
		mov cx, 5
		sub cx, si
		mov bx, offset digits
		trans:
			add [byte ptr bx+si], 30h
			inc bx
			loop trans

		;print numbers
		mov dx, offset digits
		add dx, si
		mov ah, 9
		int 21h

		cmp [op], '/'
		je mod_print

		; get numbers again
		jmp get_inputs

	mod_print:
		;12345
		; 12345 / 1000 = 12 => 12 / 10 => d1 = (/) 1, d2 = (%) 2
		; 12345 / 100 = 123 => d3 = 123 % 10 = 3
		; 12345 % 100 = 45 => d4 = 45 / 10 = 4, d5 = 45 % 10 = 5

		; d1, d2
		; res / 1000
		xor dx, dx
		mov ax, [modd]
		mov bx, 1000
		div bx

		; (res / 1000) / 10
		xor dx, dx
		mov bx, 10
		div bx

		; put result as first number and mod as second number
		mov [offset digits], al
		mov [offset digits + 1], dl

		; d3
		; res / 100
		xor dx, dx
		mov ax, [modd]
		mov bx, 100
		div bx

		push dx

		; res mod 10
		xor dx, dx
		mov bx, 10
		div bx

		; put mod as 3rd digit
		mov [offset digits + 2], dl

		; d4 d5
		; res mod 100
		pop ax
		; (res mod 100) / 10
		xor dx, dx
		mov bx, 10
		div bx

		mov [offset digits + 3], al
		mov [offset digits + 4], dl

		mov cx, 5
		xor si, si

		; check when actual number starts
		lo2:
			cmp [byte ptr offset digits + si], 0
			je incStart1
			jmp done1

		incStart1:
			inc si
			loop lo2
		done1:

		;print (
		mov ah, 2
		mov dx, '('
		int 21h

		; print zero if all digits are 0
		cmp si, 5
		je print0
		jmp not0

		print0:
			mov ah, 2
			mov dx, '0'
			int 21h
			jmp after0

		not0:

		; translate numbers
		mov cx, 5
		sub cx, si
		mov bx, offset digits
		trans1:
			add [byte ptr bx+si], 30h
			inc bx
			loop trans1

		;print numbers
		mov dx, offset digits
		add dx, si
		mov ah, 9
		int 21h

		after0:

		;print )
		mov ah, 2
		mov dx, ')'
		int 21h

		jmp get_inputs
exit:
	mov ax, 4c00h
	int 21h
END start