mainWindow.java

import javax.swing.*;

import classes.eval;
import classes.tokentizador;
import classes.tokentizador.Token;
import classes.Nodo;

import java.awt.*;
import java.awt.event.*;
import java.util.List;
import javax.swing.border.AbstractBorder;

/*
Calculadora basica con interfaz grafica hecha en Java Swing
Soporta operaciones basicas (+, -, *, /, %, ^)
Soporta funciones avanzadas (raiz cuadrada, logaritmos, funciones trigonometricas, factorial)
Soporta constantes (pi, e)

Autor: Angel Bello
Fecha: Diciembre 2025

Archivos modificados:
- mainWindow.java
- classes/eval.java
- classes/Nodo.java
- classes/tokentizador.java

Flujo general:
1. El usuario ingresa una expresion matematica en la interfaz grafica.
2. La expresion es tokenizada por la clase tokentizador.
3. Los tokens son parseados en un arbol de expresiones por la clase eval.
4. El arbol de expresiones es evaluado por la clase Nodo.
5. El resultado es mostrado en la interfaz grafica.

Responsabilidades de cada clase:
- mainWindow.java: Maneja la interfaz grafica y la interaccion con el usuario.
- classes/tokentizador.java: Convierte la cadena de entrada en una lista de tokens.
- classes/eval.java: Parsea la lista de tokens en un arbol de expresiones.
- classes/Nodo.java: Representa los nodos del arbol de expresiones y evalua el resultado.

*/

/*
Clase mainWindow
Responsable de la interfaz grafica y la interaccion con el usuario.
Utiliza Java Swing para crear la ventana de la calculadora, los botones y los campos de texto.
Implementa ActionListener para manejar los eventos de los botones.

Metodos principales:
- components(): Configura los componentes de la interfaz grafica.
- Manejador.actionPerformed(): Maneja los eventos de los botones.
- clear(): Limpia la pantalla y resetea las variables.
- solve(): Tokeniza, parsea y evalua la expresion en la pantalla, mostrando el resultado en la vista previa.
- confirm(): Confirma el resultado mostrado en la vista previa y lo coloca en la pantalla principal.

Atributos principales:
- pantalla: Campo de texto principal donde se muestra la expresion matematica.
- preview: Campo de texto donde se muestra el resultado preliminar.
- par: Contador de parentesis para asegurar el balanceo correcto.
*/
public class mainWindow extends JFrame{

    JTextField pantalla;
    JTextField preview;
    int par = 0;

    public mainWindow(){

        /*
        Constructor de la clase mainWindow
        Configura la ventana principal de la calculadora.
        Establece el tamaño, la operacion de cierre, la ubicacion y el titulo de la ventana.
        Llama al metodo components() para agregar los componentes de la interfaz grafica.
        */

        this.setSize(450, 650);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
        this.setTitle("Basic Calculator");

        this.components();
    }

    private void components(){

        /*
         Configura los componentes de la interfaz grafica.
         Crea los campos de texto para la pantalla principal y la vista previa.
         Crea los paneles y botones, y los organiza en la ventana.
        */

        JPanel container = new JPanel(new BorderLayout());

        pantalla = new JTextField("");
        pantalla.setEditable(false);
        pantalla.setHorizontalAlignment(JTextField.RIGHT);
        pantalla.setFont(new Font("Arial", Font.BOLD, 46));
        pantalla.setBorder(BorderFactory.createEmptyBorder(20, 0, 10, 10));
        pantalla.setBackground(Color.decode("#0e1116"));
        pantalla.setForeground(Color.decode("#E2E2E2"));

        preview = new JTextField("");
        preview.setEditable(false);
        preview.setHorizontalAlignment(JTextField.RIGHT);
        preview.setFont(new Font("Arial", Font.BOLD, 25));
        preview.setBorder(BorderFactory.createEmptyBorder(2, 8, 15, 17));
        preview.setBackground(Color.decode("#0e1116"));
        preview.setForeground(Color.decode("#B2B2B2"));

        JPanel display = new JPanel(new BorderLayout());

        display.add(pantalla, BorderLayout.NORTH);
        display.add(preview, BorderLayout.SOUTH);

        container.add(display, BorderLayout.NORTH);

        JPanel cuadro = new JPanel(new BorderLayout());

        JPanel topFrame = new JPanel(new GridLayout(2, 5, 5, 5));
        topFrame.setBorder(BorderFactory.createEmptyBorder(5,5,0,5));
        topFrame.setBackground(Color.decode("#0e1116"));

        String[] topButtons = {"√", "pi", "^", "!", "e", "sin", "cos", "tan", "log", "ln"};

        for(String botonName : topButtons){
            JButton boton = new JButton(botonName);
            boton.addActionListener(new Manejador());
            boton.setBackground(Color.decode("#171b23"));
            boton.setForeground(Color.decode("#E2E2E2"));
            boton.setFont(new Font("Calibri", Font.BOLD, 18));
            boton.setFocusPainted(false);
            boton.setBorder(new RoundedCornerBorder(15));
            boton.setBorderPainted(true);
            topFrame.add(boton);
        }

        cuadro.add(topFrame, BorderLayout.NORTH);

        JPanel panel = new JPanel(new GridLayout(5, 4, 5, 5));
        panel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        panel.setBackground(Color.decode("#0e1116"));


        String[] botones = {"AC", "()", "%", "/", "7", "8", "9", "×", "4", "5", "6", "-", "1", "2", "3", "+", "0", ".", "CE", "="};

        for(String botonName : botones){
            JButton boton = new JButton(botonName);
            boton.addActionListener(new Manejador());
            boton.setBackground(Color.decode("#171b23"));
            boton.setForeground(Color.decode("#E2E2E2"));
            boton.setFont(new Font("Calibri", Font.BOLD, 22));
            boton.setFocusPainted(false);
            boton.setBorder(new RoundedCornerBorder(15));
            boton.setBorderPainted(true);
            panel.add(boton);
        }

        cuadro.add(panel, BorderLayout.CENTER);
        container.add(cuadro, BorderLayout.CENTER);
        this.add(container);
    }

    private class Manejador implements ActionListener {

        /*
         Maneja los eventos de los botones de la calculadora.

            Metodos principales:
            - actionPerformed(): Detecta que boton fue presionado y ejecuta la accion correspondiente (limpiar, confirmar, eliminar ultimo caracter, agregar parentesis, agregar simbolo/numero, resolver).
        */

        @Override
        public void actionPerformed(ActionEvent e){

            // Obtener el comando del boton presionado
            String comando = e.getActionCommand();

            // Procesar el comando del boton presionado

            // Caso AC: Limpiar la pantalla
            if (comando.equals("AC")) clear();

            // Caso =: Confirmar el resultado
            else if (comando.equals("=")) confirm();

            // Caso CE: Eliminar el ultimo caracter ingresado
            else if (comando.equals("CE")){
                String text = pantalla.getText();
                if (!text.isEmpty()){
                    char lastChar = text.charAt(text.length() - 1);

                    // Actualizar el contador de paréntesis según el último carácter eliminado
                    if (lastChar == '(') par--;
                    else if (lastChar == ')') par++;
                    pantalla.setText(text.substring(0, text.length() - 1));

                    // Actualizar la vista previa después de eliminar el último carácter
                    solve();
                }
            }

            // Caso (): Agregar paréntesis balanceados
            else if (comando.equals("()")) {
                char lastChar = pantalla.getText().isEmpty() ? ' ' : pantalla.getText().charAt(pantalla.getText().length() - 1);

                // Verificar si se debe agregar un paréntesis de apertura o cierre
                if (par == 0 || lastChar == '×' || lastChar == '/' || lastChar == '-' || lastChar == '+' || lastChar == '^' || lastChar == '%' || lastChar == '(') {
                    String newText = "(";

                    // Verificar si se debe agregar un operador de multiplicación antes del paréntesis
                    if("0123456789!".contains(lastChar + "")){
                        newText = "×" + newText;
                    }
                    pantalla.setText(pantalla.getText() + newText);
                    par++;
                } else if (par > 0 && (Character.isDigit(lastChar) || lastChar == '!' || lastChar == ')' || lastChar == 'i' || lastChar == 'e')) {

                    // Agregar un paréntesis de cierre
                    pantalla.setText(pantalla.getText() + ")");
                    par--;
                }
                solve();
            }
            else {

                String newText = comando;
                if (!pantalla.getText().isEmpty()){
                    char lastChar = pantalla.getText().charAt(pantalla.getText().length() - 1);

                    //Evitar !! o numero!
                    if ((Character.isDigit(lastChar) || lastChar == '!') && comando == "!"){
                        newText = "";
                    } 
                    
                    // Agregar operador de multiplicacion si es necesario despues de un parentesis cerrado o una constante
                    else if (lastChar == ')' && Character.isDigit(comando.charAt(0))){
                        newText = "×" + newText;
                    }

                    // Evitar operadores consecutivos y manejar casos especiales
                    else if ("×-/+^%".contains(lastChar + "") && "×-/+^%".contains(comando)) {
                        pantalla.setText(pantalla.getText().substring(0, pantalla.getText().length() - 1));
                    }

                    // Agregar operador de multiplicacion si es necesario despues de un parentesis cerrado o una constante
                    else if (lastChar == ')' || Character.isDigit(lastChar) && ("pie".contains(comando))) {
                        newText = "×" + newText;
                    }

                    // Agregar operador de multiplicacion si es necesario despues de una constante o un parentesis cerrado
                    else if ("1234567890".contains(comando) && (lastChar == 'i' || lastChar == 'e' || lastChar == '!' || lastChar == ')')) {
                        newText = "×" + newText;
                    }

                    // Manejar casos especiales para el punto decimal y operadores al inicio
                    else if (comando.equals(".") && lastChar == '.') {
                        newText = "";
                    }

                    // Convierte . en 0. si sigue a un operador o funcion
                    else if (comando.equals(".") && !Character.isDigit(lastChar)) {
                        newText = "0.";
                    }
                } else {

                    // No permitir que la expresion comience con ciertos operadores
                    if ("×/^%".contains(comando)) {
                        newText = "";
                    }

                    // Convierte . en 0. si es el primer caracter
                    if (comando.equals(".")) {
                        newText = "0.";
                    }
                }

                // Agregar un parentesis de apertura despues de funciones
                if ("ngs".contains(comando.charAt(comando.length() - 1) + "")){
                    newText = newText + "(";
                    par++;
                }


                pantalla.setText(pantalla.getText() + newText);
                solve();
            }

        }
        
    }

    private void clear(){
        /*
         Limpia la pantalla y resetea las variables.
        */
        par = 0;
        pantalla.setText("");
        preview.setText("");
    }

    private void solve(){

        /*
         Tokeniza, parsea y evalua la expresion en la pantalla.
         Muestra el resultado en la vista previa.
        */

         // Tokenizar la expresion en la pantalla
        List<Token> tokens = tokentizador.Tokentizar(pantalla.getText());
        
            // Crear el arbol de expresion y verificar errores
        Nodo tree = new eval(tokens).createTree().verify();

            // Manejar errores en el arbol de expresion
        if (tree.tipo == "error") {
            preview.setText("Error: " + tree.valor);
            return;
        }

            // Evaluar el arbol de expresion
        double result = tree.getValue();

            // Mostrar el resultado en la vista previa

            /*
            Verificar si el resultado es un numero entero para mostrarlo sin decimales
            o como un numero decimal si tiene parte fraccionaria.
            */
        if (result % 1 == 0){
            preview.setText((int) result + "");
        } else {
            preview.setText(result + "");
        }
        
    }

    private void confirm(){

        /*
         Confirma el resultado mostrado en la vista previa.
         Coloca el resultado en la pantalla principal y limpia la vista previa.
        */

        pantalla.setText(preview.getText());
        preview.setText("");
    }


    public static void main(String[] args) {

        /*
            Punto de entrada de la aplicacion.
            Crea y muestra la ventana principal de la calculadora.
        */
        
        SwingUtilities.invokeLater(() -> {

            new mainWindow().setVisible(true);

        });
    }
    
}

class RoundedCornerBorder extends AbstractBorder {
    private final int radio;

    // Constructor que recibe el radio de redondeo
    public RoundedCornerBorder(int radio) {
        this.radio = radio;
    }

    @Override
    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
        super.paintBorder(c, g, x, y, width, height);
        Graphics2D g2 = (Graphics2D) g;
        
        // Mejora el renderizado del borde
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        
        // Define el color del borde
        g2.setColor(Color.decode("#303030")); 
        
        // Dibuja el borde con esquinas redondeadas (Arc)
        g2.drawRoundRect(x, y, width - 1, height - 1, radio, radio);
    }

    @Override
    public Insets getBorderInsets(Component c) {
        // Define el espacio interior (padding) para que el contenido no toque el borde
        return new Insets(radio + 1, radio + 1, radio + 1, radio + 1);
    }

    @Override
    public Insets getBorderInsets(Component c, Insets insets) {
        insets.left = insets.right = insets.bottom = insets.top = radio + 1;
        return insets;
    }
}