section .data
    prompt db "Ingresa el primer numero: "
    prompt_len equ $-prompt

    prompt2 db 10,"Ingresa el segundo numero: "
    prompt_len2 equ $-prompt2

    opcion1 db 10,10,"Ingresa 1 para realizar una suma"
    opcion1_len equ $-opcion1

    opcion2 db 10,"Ingresa 2 para realizar una resta"
    opcion2_len equ $-opcion2

    opcion3 db 10,"Ingresa 3 para Salir"
    opcion3_len equ $-opcion3

    error db 10,10,"Opcion invalida"
    error_len equ $-error

    adios db 10,10,"Adios", 10
    adios_len equ $-adios

    textsum db 10,10,"La suma es: "
    textsum_len equ $-textsum

    textrest db 10,10,"La resta es: "
    textrest_len equ $-textrest

section .bss
    num resb 20
    num2 resb 20
    opc resb 2
    resultado resb 20
    
    ; --- NUEVAS VARIABLES PARA REEMPLAZAR r8-r15 ---
    val_num1 resq 1    ; Guarda el valor real del primer número
    val_num2 resq 1    ; Guarda el valor real del segundo número
    puntero resq 1     ; Posición en la que vamos escribiendo el resultado
    cantidad resq 1    ; Cantidad de dígitos a imprimir al final

section .text
    global _start

_start:
    ; ==========================================
    ; LEER EL PRIMER NÚMERO
    ; ==========================================
    mov rax, 1
    mov rdi, 1
    mov rsi, prompt
    mov rdx, prompt_len
    syscall

    mov rax, 0
    mov rdi, 0
    mov rsi, num
    mov rdx, 20
    syscall

    ; --- Convertir Texto a Entero usando memoria ---
    mov qword [val_num1], 0  ; Inicializamos la variable en 0
    mov rsi, num             
    mov rbx, 10              ; Multiplicador constante para "mul"

leer_digitos_1:
    mov rcx, 0
    mov cl, [rsi]            ; Leemos el caracter actual
    
    cmp cl, 10               ; Salto de línea (Enter)
    je fin_leer_1
    cmp cl, 0                ; Fin de cadena
    je fin_leer_1

    ; Multiplicar la variable val_num1 por 10
    mov rax, [val_num1]
    mul rbx                  ; RAX = RAX * 10
    mov [val_num1], rax      ; Guardamos el resultado en la variable

    ; Convertir el texto a número y sumarlo
    sub cl, "0"
    add [val_num1], rcx

    add rsi, 1               ; Avanzamos al siguiente carácter
    jmp leer_digitos_1
fin_leer_1:


    ; ==========================================
    ; LEER EL SEGUNDO NÚMERO
    ; ==========================================
    mov rax, 1
    mov rdi, 1
    mov rsi, prompt2
    mov rdx, prompt_len2
    syscall

    mov rax, 0
    mov rdi, 0
    mov rsi, num2
    mov rdx, 20
    syscall

    ; --- Convertir Texto a Entero usando memoria ---
    mov qword [val_num2], 0  
    mov rsi, num2
    mov rbx, 10

leer_digitos_2:
    mov rcx, 0
    mov cl, [rsi]
    
    cmp cl, 10
    je fin_leer_2
    cmp cl, 0
    je fin_leer_2

    ; Multiplicar la variable val_num2 por 10
    mov rax, [val_num2]
    mul rbx
    mov [val_num2], rax

    ; Convertir y sumar
    sub cl, "0"
    add [val_num2], rcx

    add rsi, 1
    jmp leer_digitos_2
fin_leer_2:


    ; ==========================================
    ; MENÚ PRINCIPAL
    ; ==========================================
menu:
    mov rax, 1
    mov rdi, 1
    mov rsi, opcion1
    mov rdx, opcion1_len
    syscall

    mov rax, 1
    mov rdi, 1
    mov rsi, opcion2
    mov rdx, opcion2_len
    syscall

    mov rax, 1
    mov rdi, 1
    mov rsi, opcion3
    mov rdx, opcion3_len
    syscall

    ; Leer la opción
    mov rax, 0
    mov rdi, 0
    mov rsi, opc
    mov rdx, 2
    syscall
    
    mov al, [opc]
    sub al, "0"

comparar:
    cmp al, 1
    je suma
    
    cmp al, 2
    je resta

    cmp al, 3
    je despedida

    jmp menso


    ; ==========================================
    ; OPERACIONES (Suma / Resta)
    ; ==========================================
suma:
    mov rax, 1
    mov rdi, 1
    mov rsi, textsum
    mov rdx, textsum_len
    syscall

    ; Sumamos leyendo desde las variables
    mov rax, [val_num1]
    mov rcx, [val_num2]
    add rax, rcx
    jmp imprimir_resultado

resta:
    mov rax, 1
    mov rdi, 1
    mov rsi, textrest
    mov rdx, textrest_len
    syscall

    ; Restamos leyendo desde las variables
    mov rax, [val_num1]
    mov rcx, [val_num2]
    sub rax, rcx
    jmp imprimir_resultado


    ; ==========================================
    ; IMPRIMIR RESULTADO MULTI-DÍGITO
    ; ==========================================
imprimir_resultado:
    ; RAX ya tiene el total. 
    mov qword [puntero], 20      ; Iniciamos el puntero al final del espacio
    mov rbx, 10                  ; Divisor constante

dividir_numero_final:
    xor rdx, rdx                 ; Limpiamos residuo
    div rbx                      ; Dividimos RAX entre 10

    add rdx, "0"                 ; Convertimos a texto

    ; Restamos 1 al puntero para guardar de atrás hacia adelante
    mov rcx, [puntero]
    sub rcx, 1
    mov [puntero], rcx

    ; Ubicamos la posición exacta en "resultado"
    mov rsi, resultado
    add rsi, rcx                 ; rsi = resultado + puntero
    mov [rsi], dl                ; Guardamos el dígito

    cmp rax, 0
    je fin_dividir_final
    jmp dividir_numero_final

fin_dividir_final:
    ; Calculamos la cantidad de caracteres que generamos (20 - puntero)
    mov rcx, 20
    sub rcx, [puntero]
    mov [cantidad], rcx

    mov rax, 1
    mov rdi, 1
    mov rsi, resultado
    add rsi, [puntero]           ; Empezamos a leer desde el último guardado
    mov rdx, [cantidad]          ; Imprimimos esa cantidad exacta
    syscall

    jmp salir


    ; ==========================================
    ; RUTINAS FINALES
    ; ==========================================
menso:
    mov rax, 1
    mov rdi, 1
    mov rsi, error
    mov rdx, error_len
    syscall
    jmp menu

despedida:
    mov rax, 1
    mov rdi, 1
    mov rsi, adios
    mov rdx, adios_len
    syscall
    jmp salir

salir:
    mov rax, 60
    mov rdi, 0
    syscall