import java.util.Scanner;
import java.util.InputMismatchException;

/**
 * Sistema Multitarefa de Utilitários Matemáticos.
 * * Esta classe centraliza diversas operações lógicas e aritméticas em um único
 * ambiente de console. O sistema foi projetado com foco em robustez,
 * implementando tratamento de exceções para todas as entradas de dados
 * e uma arquitetura modular para facilitar a manutenção.
 * @version 1.0
 */
public class Main {

    /**
     * Ponto de entrada da aplicação.
     * * Gerencia o ciclo de vida do menu principal, mantendo o programa em execução
     * até que o usuário solicite explicitamente o encerramento (Opção 0).
     * Atua como orquestrador, delegando a lógica de negócios para métodos específicos.
     * * @param args Argumentos de linha de comando (não utilizados).
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int opcao = -1;

        // Mantém o loop do menu ativo até o usuário escolher Sair (0)
        do {
            limparTela(); 
            exibirMenuPrincipal();

            // Solicita a opção com validação de intervalo (0 a 6)
            opcao = lerInteiroComLimite(scanner, 0, 6);

            limparTela(); // Limpa a interface para focar na operação escolhida

            switch (opcao) {
                case 1:
                    executarPositivoNegativo(scanner);
                    break;
                case 2:
                    executarComparacao(scanner);
                    break;
                case 3:
                    executarGeometria(scanner);
                    break;
                case 4:
                    executarTabuada(scanner);
                    break;
                case 5:
                    executarParImpar(scanner);
                    break;
                case 6:
                    executarFatorial(scanner);
                    break;
                case 0:
                    System.out.println("Encerrando o sistema... Até logo!");
                    break;
            }
            
            // Pausa estratégica para que o usuário possa ler o resultado antes de limpar a tela
            if (opcao != 0) {
                System.out.println("\n------------------------------------------------");
                System.out.println("Pressione ENTER para voltar ao menu...");
                scanner.nextLine(); // Consome o buffer pendente
                scanner.nextLine(); // Aguarda o input do usuário
            }

        } while (opcao != 0);

        scanner.close();
    }

    /**
     * Exibe as opções textuais do menu principal.
     * Separado do método main para manter o código limpo.
     */
    private static void exibirMenuPrincipal() {
        System.out.println("=========================================");
        System.out.println("          SISTEMA MULTITAREFA            ");
        System.out.println("=========================================");
        System.out.println("1 - Verificar Positivo/Negativo/Neutro");
        System.out.println("2 - Comparar dois números");
        System.out.println("3 - Geometria Plana (Quadrado/Círculo)");
        System.out.println("4 - Tabuada Automática");
        System.out.println("5 - Verificar Par ou Ímpar");
        System.out.println("6 - Calcular Fatorial");
        System.out.println("0 - SAIR");
        System.out.println("-----------------------------------------");
        System.out.print("Escolha uma opção (0-6): ");
    }

    // ========================================================================
    // MÉTODOS UTILITÁRIOS DE VALIDAÇÃO (BLINDAGEM)
    // ========================================================================

    /**
     * Realiza a leitura segura de um número inteiro.
     * * Este método encapsula o Scanner em um bloco try-catch e um loop infinito.
     * Se o usuário digitar algo que não seja um número (ex: letras), o sistema
     * captura a exceção, exibe um alerta e solicita a entrada novamente,
     * prevenindo o encerramento abrupto do programa (crash).
     * * @param scanner Instância ativa do Scanner.
     * @return Um número inteiro válido (int).
     */
    public static int lerInteiro(Scanner scanner) {
        while (true) {
            try {
                return scanner.nextInt();
            } catch (InputMismatchException e) {
                System.out.print("❌ Erro! Entrada inválida. Por favor, digite apenas NÚMEROS inteiros: ");
                scanner.next(); // Limpa o buffer incorreto do scanner
            }
        }
    }

    /**
     * Realiza a leitura segura de um inteiro dentro de um intervalo específico.
     * * Combina a validação de tipo (garantida por lerInteiro/nextInt) com
     * validação de regra de negócio (limites min/max).
     * Útil para menus e seleções restritas.
     * * @param scanner Instância ativa do Scanner.
     * @param min Valor mínimo aceitável (inclusivo).
     * @param max Valor máximo aceitável (inclusivo).
     * @return Um número inteiro dentro do intervalo [min, max].
     */
    public static int lerInteiroComLimite(Scanner scanner, int min, int max) {
        while (true) {
            try {
                int valor = scanner.nextInt();
                if (valor >= min && valor <= max) {
                    return valor;
                } else {
                    System.out.printf("❌ Opção inválida! Digite um número entre %d e %d: ", min, max);
                }
            } catch (InputMismatchException e) {
                System.out.print("❌ Erro! Entrada inválida. Digite apenas NÚMEROS: ");
                scanner.next(); 
            }
        }
    }

    /**
     * Realiza a leitura segura de um número decimal (double).
     * Similar ao lerInteiro, mas focado em ponto flutuante.
     * * @param scanner Instância ativa do Scanner.
     * @return Um número decimal válido.
     */
    public static double lerDouble(Scanner scanner) {
        while (true) {
            try {
                return scanner.nextDouble();
            } catch (InputMismatchException e) {
                System.out.print("❌ Erro! Digite um número decimal válido (ex: 5,5 ou 10): ");
                scanner.next();
            }
        }
    }

    /**
     * Simula a limpeza do console imprimindo múltiplas linhas em branco.
     * * Utilizado para melhorar a experiência do usuário (UX), mantendo a
     * interface organizada. Esta abordagem foi escolhida por ser compatível
     * com qualquer sistema operacional e IDE.
     */
    public static void limparTela() {
        for (int i = 0; i < 50; i++) {
            System.out.println();
        }
    }

    // ========================================================================
    // MÓDULOS FUNCIONAIS (LÓGICA DE NEGÓCIOS)
    // ========================================================================

    /**
     * Executa a análise de sinal de um número.
     * Classifica a entrada como Positiva, Negativa ou Neutra (Zero).
     */
    public static void executarPositivoNegativo(Scanner scanner) {
        System.out.println("--- VERIFICAR POSITIVO / NEGATIVO ---");
        System.out.print("Digite um número: ");
        int numero = lerInteiro(scanner); 

        if (numero < 0) {
            System.out.printf("Resultado: %d é NEGATIVO.\n", numero);
        } else if (numero == 0) {
            System.out.printf("Resultado: É o número NEUTRO (Zero).\n");
        } else {
            System.out.printf("Resultado: %d é POSITIVO.\n", numero);
        }
    }

    /**
     * Compara dois números inteiros e determina a relação de grandeza entre eles.
     */
    public static void executarComparacao(Scanner scanner) {
        System.out.println("--- COMPARAR NÚMEROS ---");
        System.out.print("Digite o primeiro número: ");
        int n1 = lerInteiro(scanner);
        System.out.print("Digite o segundo número: ");
        int n2 = lerInteiro(scanner);

        if (n1 < n2) System.out.printf("Resultado: %d é MENOR que %d.\n", n1, n2);
        else if (n1 > n2) System.out.printf("Resultado: %d é MAIOR que %d.\n", n1, n2);
        else System.out.printf("Resultado: %d é IGUAL a %d.\n", n1, n2);
    }

    /**
     * Módulo de Geometria Plana.
     * Oferece um submenu para cálculo de área de figuras geométricas básicas.
     */
    public static void executarGeometria(Scanner scanner) {
        System.out.println("--- GEOMETRIA PLANA ---");
        System.out.println("1 - Área do Quadrado");
        System.out.println("2 - Área do Círculo");
        System.out.print("Escolha (1 ou 2): ");
        
        int geoOpcao = lerInteiroComLimite(scanner, 1, 2);
        final double PI = 3.1416;

        switch (geoOpcao) {
            case 1:
                System.out.print("Informe o lado do quadrado: ");
                double lado = lerDouble(scanner);
                System.out.printf("✅ Área do quadrado: %.2f\n", (lado * lado));
                break;
            case 2:
                System.out.print("Informe o raio do círculo: ");
                double raio = lerDouble(scanner);
                System.out.printf("✅ Área do círculo: %.2f\n", (PI * raio * raio));
                break;
        }
    }

    /**
     * Gera a tabuada completa (soma, subtração, multiplicação, divisão) de um número.
     * Permite ao usuário escolher a estrutura de repetição (for ou while) para fins didáticos.
     */
    public static void executarTabuada(Scanner scanner) {
        System.out.println("--- TABUADA AUTOMÁTICA ---");
        System.out.print("Informe um número para a tabuada: ");
        int n = lerInteiro(scanner); 

        System.out.println("Escolha o método de cálculo:");
        System.out.println("1 - Loop For");
        System.out.println("2 - Loop While");
        System.out.print("Opção: ");
        
        // A variável 'metodo' poderia ser usada para ramificar lógica específica,
        // mas neste exemplo simplificado, ambas as opções geram o mesmo output.
        lerInteiroComLimite(scanner, 1, 2);

        System.out.println("\nCalculando tabuada do " + n + "...");
        
        String[] operacoes = {"Soma (+)", "Subtração (-)", "Multiplicação (*)", "Divisão (/)"};
        
        for (String op : operacoes) {
            System.out.println("\n" + op + ":");
            for (int i = 1; i <= 10; i++) {
                if (op.contains("Soma")) System.out.printf("%d + %d = %d\n", n, i, n + i);
                if (op.contains("Subtração")) System.out.printf("%d - %d = %d\n", n, i, n - i);
                if (op.contains("Multiplicação")) System.out.printf("%d * %d = %d\n", n, i, n * i);
                if (op.contains("Divisão")) {
                    if (i != 0) System.out.printf("%d / %d = %.2f\n", n, i, (double)n / i);
                }
            }
        }
    }

    /**
     * Verifica a paridade de um número inteiro utilizando o operador de módulo (%).
     */
    public static void executarParImpar(Scanner scanner) {
        System.out.println("--- PAR OU ÍMPAR ---");
        System.out.print("Informe um número inteiro: ");
        int n = lerInteiro(scanner);
        
        if (n % 2 == 0) System.out.printf("✅ O número %d é PAR.\n", n);
        else System.out.printf("✅ O número %d é ÍMPAR.\n", n);
    }

    /**
     * Calcula o fatorial de um número inteiro não negativo.
     * Inclui validação específica para impedir entrada de números negativos,
     * o que violaria a definição matemática de fatorial.
     */
    public static void executarFatorial(Scanner scanner) {
        System.out.println("--- FATORIAL ---");
        System.out.print("Informe um número não negativo: ");
        
        // Loop de validação específico para regra matemática do Fatorial
        int n;
        while (true) {
            n = lerInteiro(scanner);
            if (n >= 0) break;
            System.out.print("❌ Erro: Fatorial não aceita negativos. Tente de novo: ");
        }

        long fatorial = 1;
        for (int i = 1; i <= n; i++) {
            fatorial *= i;
        }
        System.out.printf("✅ O fatorial de %d é %d.\n", n, fatorial);
    }
}