section .data
    menu db "Menu Calculadora", 10, \
            "1. Suma (50+10)", 10 \
            "2- REsta (50-10)", 10 \
            "3. Multiplicacion (50*10)", 10
    ;La diagonal invertida sirve para poder ordenar el codigo en diferentes lineas sin perder la pertenencia de la variable que se le esta asignando un valor

    menu_len equ $ - menu

    resp db "El resultado de la operacion es:", 0
    resp_len  equ $ - resp

    error_msg db "Operacion invalida o inexistente. Ejecuta de nuevo", 10, 0
    error_len equ $ - error_msg

section .bss
    choice resb 5
    ;Este bufer reservara los bytes para los que ingrese el usuario

    buffer resb 20
    ;Este buffer reservara20 bytes para formatear a ASCII el resultado final

section ,text
    global _start

_start:
    ;Impromir el menu del programa 
    mov rax, 1
    mov rdi, 1
    mov rsi, menu
    mov rdx, menu_len
    syscall

    ;Leer lo que el usuario eligio
    mov rax, 0
    mov rdi, 0
    mov rsi, choice
    mov rdx, 5
    syscall

    ;Justo despues de la ejecucion, choice guardo el caracter que el usuario ingreso, en caso de que haya existido un enter tambien lo guardo 

    movzx rcx, [choice]
    ;movzx copia el primer byte del buffer en el registro rcx rellenando el resto con 0

    ;Definicion de los valores para la operacion (Constantes)
    mov r8, 50
    mov r9, 10

    ;Comparacion de la opcion que eligio
    cmp rcx, '1'
    ;cmp compara el valor del registro rcx, con los codigos en texto elegidos
    
    je hacer_suma
    ;je (Jump if Equal), si es igual salta a la etiqueta definida

    cmp rcx, '2'
    je hacer_resta

    cmp rcx, '3'
    je hacer_multi

    ;Bloques de operaciones matematicas

    hacer_suma:
        mov rax, r8 
        add rax, r9
        jmp show_op
        ;Justo despues de hacer la operacion hacemos un salto a la etiqueta definida, esto con el fin de que no continue la ejecucion de las demas operaciones
        
    hacer_resta:
        mov rax, r8
        sub rax, r9
        jmp show_op
        
    hacer_multi:
        mov rax, r8
        mov rbx, r9
        mul rbx
        ;Se realiza la multiplicacion de rax por rbx y el resultado se almacena en rax
        jmp show_op

    invalido:
        ;este bloque se ejecuta cuando no exista ninguna operacion valida
        mov rax, 1
        mov rdi, 1
        mov rsi, error_msg
        mov rdx, error_len
        syscall
        jmp exit_program

    show_op:
        ;Bloque para la impresion del resultado
        mov rbx, rax
        ;Respaldamos el resultado de la operacion de otro registro

        ;Imprimimos mensaje decorativo
        mov rax, 1
        mov rdi, 1
        mov rsi, resp
        mov rdx, resp_len
        syscall

        ;Proceso de conversion del numero a ASCII

        mov rax, rbx 
        ;Recuperamos el resultado de la operacion en el registro rax
        lea rsi, [buffer + 19]
        ;Apuntamos el puntero para la conversion al final del buffer que reservamos 
        mov byte [rsi], 10
        ;agregamos un byte adicional para el salto de linea 
        mov rbx, 10 
        ;agregamos el divisor al registro rbx

    .convert_loop:
        ;funcion de conversion de caracteres numeros a ASCII 
        
        xor rdx, rdx 
        ;limpiar el registro de rdx antes de usarlo 
        
        div rbx 
        ;Dividimos lo que almacena en el registro rax /10. el cociente queda en rax y el residuo en rdx
    
        add dl, "0"
        ;Convertimos el residuo numerio a su caracter en ASCII ("O" - "9")
    
        dec rsi 
        ;Retrocedemos una posicion en el buffer para llenar de derecha a izquierda 
    
        mov [rsi], dl 
        ;Guardamos el caracter convertido en la posicion actual del buffer 
    
        test rax, rax 
        ;Evaluamos si nuestro cociente llega a 0
    
        jnz .convert_loop
        ;Si nuestro cociente no es 0, repetimos el ciclo convert_loop 
    
        ;Calculos de bytes que ocupa el numero convertido a ASCII 
    
        lea rdx, [buffer + 20]
        ;Obtenemos la posicio final del buffer 
        
        sub rdx, rsi 
        ;Restamos el inicio actual para obtener los bytes restantes en una longitud exacta 
    
        ;Imprimimos los caracteres 
        mov rax, 1 
        mov rdi, 1 
        syscall

    Exit_program:
        mov rax, 60
        mov rdi, 0
        syscall