org 0x7c00
jmp 0x0000:start

notmsg db "Nao forma triangulo", 0
eqmsg db "Equilatero", 0
isomsg db "Isosceles", 0
scamsg db "Escaleno", 0
strinput db "000", 0
X times 1 db 0
Y times 1 db 0
Z times 1 db 0

start:
    xor ax, ax      ; reg init
    mov ds, ax      ; reg init
    mov es, ax      ; reg init
    mov ss, ax      ; stack init
    mov sp, 0x7c00      ; stack init

    mov di, strinput
    call readvstr

    mov si, strinput
    call atoi
    mov byte [X], dl    ; and store the output conversion

    mov di, strinput
    call readvstr

    mov si, strinput
    call atoi
    mov byte [Y], dl    ; and store the output conversion

    mov di, strinput
    call readvstr

    mov si, strinput
    call atoi
    mov byte [Z], dl    ; and store the output conversion

;;; [Checking if the vertices form a triangle] ;;;
;; X < (Y + Z) ;;
    mov bl, byte [X]    ; check if X < Y + Z
    mov al, byte [Y]
    mov ah, byte [Z]
    add al, ah      ; (Y + Z)
    cmp bl, al      ; X ? (Y + Z)
    jae .nottriangle    ; if (X >= Y + Z), then its not a triangle
;; Y < (X + Z) ;;
    mov bl, byte [Y]
    mov al, byte [X]
    mov ah, byte [Z]
    add al, ah      ; (X + Z)
    cmp bl, al      ; Y ? (X + Z)
    jae .nottriangle    ; if (Y >= X + Z), then its not a triangle
;; Z < (X + Y) ;;
    mov bl, byte [Z]
    mov al, byte [X]
    mov ah, byte [Y]
    add al, ah      ; (X + Y)
    cmp bl, al      ; Z ? (X + Y)
    jae .nottriangle    ; if (Z >= X + Y), then its not a triangle
;;; [Done] ;;;

;;; [Check the type of triangle] ;;;
    mov al, byte[X]
    mov ah, byte[Y]
    mov bl, byte[Z]

    cmp al, ah
    jne .notequilateral
    cmp al, bl
    jne .isosceles
    jmp .equilateral

.notequilateral:
    cmp al, bl
    je .isosceles
    cmp ah, bl
    je .isosceles
    jmp .scalene

.equilateral:
    mov si, eqmsg
    jmp .done

.isosceles:
    mov si, isomsg
    jmp .done

.scalene:
    mov si, scamsg
    jmp .done

.nottriangle:
    mov si, notmsg
    jmp .done

.done:
    call printstr
    call println
    jmp done

;;; read (verbosely) string from di and print char by char
;; @param: use di to read
;; @reg: ax, bx
readvstr:
    .read:
        mov ah, 0   ; read keystroke
        int 16h     ; keyboard interrupt

        cmp al, 0xd     ; compare al with 'enter'
        je .done

        stosb
        jmp .print

    .print:
        mov ah, 0xe     ; call number
        mov bh, 0   ; page number
        mov bl, 0xf ; white color
        int 10h

        jmp .read

    .done:
        call println    ; print line
        mov al, 0   ; insert '\0'
        stosb

        ret         ; return

;;; string to integer -- int atoi(string*)
;; @param use si as string
;; @return dl as int result
;; @reg: ax, dx, bl, si
atoi:
    xor ax, ax      ; init
    mov dx, ax
.convert:
    lodsb

    cmp al, '0'
    jb .done        ; character below '0'

    cmp al, '9'
    ja .done        ; character above '9'

    sub al, '0'     ; convert ascii to (0-9) int

    xchg dl, al         ; this swap is needed because mul

    mov bl, 10      ; supose 12 from 123 string was computed, then 123 = (12*10) + 3
    mul bl          ; prepare data for next unit digit
    add dl, al      ; insert new digit into data

    jmp .convert

.done:
    ret

;;; print string
;; @param: use si to print
;; @reg: ax, bx
printstr:
    .start:

        lodsb       ; si -> al
        cmp al, 0
        je .done    ; if (end of string) return
        jmp .print  ; else print current char

        .print:
            mov ah, 0xe     ; print char and move cursor foward
            mov bh, 0   ; page number
            mov bl, 0xf     ; white color
            int 10h     ; video interrupt

            jmp .start
        .done:
            ret

;;; print line (\n)
;; @reg: ax, bx
println:
    mov ah, 0xe ; char print
    mov bh, 0 ; page number
    mov bl, 0xf ; white color
    mov al, 13 ; vertical tab
    int 10h ; visual interrupt

    mov ah, 0xe ; char print
    mov bh, 0 ; page number
    mov bl, 0xf ; white color
    mov al, 10 ; backspace
    int 10h ; visual interrupt

    ret

;;; integer to string -- string to_string(int*)
;; @param use ax as number input
;; @return di as string output
;; @reg: ax, bl, sp, di
tostring:

    push 0          ; push '\0' end of string

.convert:           ; convert every digit of integer input into characters

    mov bl, 10      ; let number = 123, then, after div, 12 will be al, and 3 will be ah
    div bl          ; so, we need to push 3 onto stack and recursively convert (number/10) until the result be zero
    add ah, '0'     ; convert remainder to ascii...

    mov dl, ah      ; (although the remainder is stored to ah, the stosb works with al)
    push dx         ; ...and push it

    cmp al, 0       ; base case condition
    je .concat

    mov ah, 0       ; the remainder was pushed onto stack, we dont need it anymore so AX = [3, 12] -> [0, 12]
    jmp .convert

.concat:            ; concat every char of stack into a string

    pop ax          ; get top of stack and pop it

    stosb           ; store al at di

    cmp al, 0       ; if end of string
    je .done        ; goto done
    jmp .concat

.done:
    ret



done:
    jmp $           ; infinity jump

times 510-($-$$) db 0   ; Pad remainder of boot sector with 0s
dw 0xAA55               ; The standard PC boot signature