ahorcado.java

import java.util.*;
import java.text.Normalizer;
import java.io.*;

public class ahorcado {
    public static void main(String[] args) {
        // Provider: primero intenta cargar words.txt; si falla, usa la lista por defecto
        WordProvider baseProvider = FileWordProvider.tryLoad("words.txt").orElse(new ListWordProvider());
        ConsoleUI ui = new ConsoleUI(baseProvider);
        ui.run();
    }

    // ======== Dificultades ========
    enum Difficulty {
        FACIL(8, 4, 7),
        MEDIO(6, 6, 10),
        DIFICIL(5, 8, 100);
        final int attempts; final int minLen; final int maxLen;
        Difficulty(int attempts, int minLen, int maxLen){
            this.attempts = attempts; this.minLen = minLen; this.maxLen = maxLen;
        }
    }

    // ======== Provider de palabras ========
    interface WordProvider { String nextWord(); }

    // Lista por defecto (sin tildes; MAYÚSCULAS)
    static class ListWordProvider implements WordProvider {
        private final List<String> words = Arrays.asList(
            "PROGRAMACION","JAVA","ALGORITMO","VARIABLE","FUNCION",
            "COMPUTADORA","SEGURIDAD","DATOS","SERVIDOR","CLIENTE",
            "FIREWALL","COMPILADOR","INTERFAZ","ABSTRACCION","POLIMORFISMO",
            "MICROSERVICIOS","REPOSITORIO","CONTENEDOR","DEPURACION","RECURSIVO"
        );
        private final Random rnd = new Random();
        public String nextWord(){ return words.get(rnd.nextInt(words.size())); }
    }

    // Lee archivo words.txt (UTF-8). Una palabra por línea. Ignora vacías y espacios.
    static class FileWordProvider implements WordProvider {
        private final List<String> words;
        private final Random rnd = new Random();
        private FileWordProvider(List<String> words){ this.words = words; }
        public static Optional<WordProvider> tryLoad(String path){
            File f = new File(path);
            if (!f.exists() || !f.isFile()) return Optional.empty();
            List<String> list = new ArrayList<>();
            try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(f), "UTF-8"))){
                String line;
                while ((line = br.readLine()) != null){
                    String w = normalizeUpper(line.trim());
                    if (!w.isBlank() && w.chars().allMatch(Character::isLetter)) list.add(w);
                }
            } catch (Exception e){
                return Optional.empty();
            }
            if (list.isEmpty()) return Optional.empty();
            return Optional.of(new FileWordProvider(list));
        }
        @Override public String nextWord(){ return words.get(rnd.nextInt(words.size())); }
    }

    // Envuelve otro provider y busca palabras en un rango de longitud; si no encuentra, cae al base
    static class FilterWordProvider implements WordProvider {
        private final WordProvider base; private final int minLen; private final int maxLen;
        FilterWordProvider(WordProvider base, int minLen, int maxLen){ this.base = base; this.minLen = minLen; this.maxLen = maxLen; }
        @Override public String nextWord(){
            // Intentamos varias veces para hallar una palabra en rango
            for (int i=0; i<200; i++){
                String w = base.nextWord();
                int len = w.length();
                if (len >= minLen && len <= maxLen) return w;
            }
            // Fallback
            return base.nextWord();
        }
    }

    // ======== Modelo del juego (estado + reglas) ========
    static class HangmanGame {
        private final String secret;           // palabra en MAYÚSCULAS (sin tildes)
        private final char[] progress;         // progreso: '_' o letra
        private final Set<Character> used;     // letras ya intentadas
        private final int maxAttempts;
        private int attemptsLeft;
        private boolean won = false;
        private final Random rnd = new Random();

        public HangmanGame(String rawSecret, int maxAttempts) {
            this.secret = normalizeUpper(rawSecret);
            this.maxAttempts = maxAttempts;
            this.attemptsLeft = maxAttempts;
            this.progress = new char[secret.length()];
            Arrays.fill(this.progress, '_');
            this.used = new LinkedHashSet<>();
        }

        public int getAttemptsLeft() { return attemptsLeft; }
        public int getMaxAttempts() { return maxAttempts; }
        public boolean isWon() { return won; }
        public boolean isLost() { return attemptsLeft <= 0 && !won; }
        public String getSecret() { return secret; }
        public String getProgressText() {
            StringBuilder sb = new StringBuilder();
            for (char c : progress) sb.append(c).append(' ');
            return sb.toString().trim();
        }
        public String getUsedLetters() {
            StringBuilder sb = new StringBuilder();
            for (char c : used) sb.append(c).append(' ');
            return sb.toString().trim();
        }

        /** Adivinar letra; devuelve mensaje para la UI */
        public String guessLetter(char ch) {
            if (won || isLost()) return "La partida ya terminó.";
            char letter = Character.toUpperCase(ch);
            if (!Character.isLetter(letter)) return "Ingresa una letra válida.";
            if (used.contains(letter)) return "Ya probaste la letra '" + letter + "'.";
            used.add(letter);

            boolean hit = false;
            for (int i = 0; i < secret.length(); i++) {
                if (secret.charAt(i) == letter) { progress[i] = letter; hit = true; }
            }
            if (!hit) {
                attemptsLeft--;
                if (attemptsLeft <= 0) return "Fallaste. No quedan intentos.";
                return "No está la '" + letter + "'. Intentos restantes: " + attemptsLeft + ".";
            } else {
                if (isFullyRevealed()) { won = true; return "¡Adivinaste la palabra!"; }
                return "¡Bien! La '" + letter + "' está.";
            }
        }

        /** Adivinar palabra completa; penaliza 1 intento si falla. */
        public String guessWord(String rawGuess) {
            if (won || isLost()) return "La partida ya terminó.";
            String guess = normalizeUpper(rawGuess);
            if (guess.isBlank()) return "Ingresa una palabra válida.";
            if (guess.equals(secret)) { won = true; revealAll(); return "¡Correcto! Adivinaste la palabra completa."; }
            attemptsLeft--;
            if (attemptsLeft <= 0) return "Palabra incorrecta. No quedan intentos.";
            return "No es '" + guess + "'. Intentos restantes: " + attemptsLeft + ".";
        }

        /** Usa una pista: revela una letra aleatoria no descubierta y descuenta 1 intento. */
        public String useHint() {
            if (won || isLost()) return "La partida ya terminó.";
            List<Integer> hidden = new ArrayList<>();
            for (int i = 0; i < progress.length; i++) if (progress[i] == '_') hidden.add(i);
            if (hidden.isEmpty()) return "No hay nada que revelar.";
            // Elige una posición oculta al azar y la revela
            int idx = hidden.get(rnd.nextInt(hidden.size()));
            char letter = secret.charAt(idx);
            for (int i = 0; i < secret.length(); i++) if (secret.charAt(i) == letter) progress[i] = letter;
            used.add(letter);
            attemptsLeft--;
            if (isFullyRevealed()) { won = true; return "Pista usada: se reveló '" + letter + "'. ¡Ganaste!"; }
            if (attemptsLeft <= 0) return "Pista usada: se reveló '" + letter + "'. No quedan intentos.";
            return "Pista usada: se reveló '" + letter + "'. Intentos restantes: " + attemptsLeft + ".";
        }

        private boolean isFullyRevealed() { for (char c : progress) if (c == '_') return false; return true; }
        private void revealAll() { for (int i = 0; i < secret.length(); i++) progress[i] = secret.charAt(i); }
    }

    // ======== Vista + Control (consola) ========
    static class ConsoleUI {
        private final Scanner sc = new Scanner(System.in);
        private final WordProvider baseProvider;
        private WordProvider currentProvider; // puede ser filtrado por dificultad
        private HangmanGame game;
        private Difficulty difficulty;

        // 7 etapas de la horca (se clampa según intentos usados)
        private static final String[] GALLOWS = new String[]{
            "\n  +---+\n  |   |\n      |\n      |\n      |\n      |\n=========\n",
            "\n  +---+\n  |   |\n  O   |\n      |\n      |\n      |\n=========\n",
            "\n  +---+\n  |   |\n  O   |\n  |   |\n      |\n      |\n=========\n",
            "\n  +---+\n  |   |\n  O   |\n /|   |\n      |\n      |\n=========\n",
            "\n  +---+\n  |   |\n  O   |\n /|\\  |\n      |\n      |\n=========\n",
            "\n  +---+\n  |   |\n  O   |\n /|\\  |\n /    |\n      |\n=========\n",
            "\n  +---+\n  |   |\n  O   |\n /|\\  |\n / \\ |\n      |\n=========\n"
        };

        public ConsoleUI(WordProvider provider){ this.baseProvider = provider; this.currentProvider = provider; }

        public void run(){
            println("=== AHORCADO (Java) ===");
            selectDifficulty();
            boolean again;
            do {
                startNewGame();
                loop();
                again = askYesNo("¿Jugar otra vez? (s/n): ");
                if (again && askYesNo("¿Cambiar dificultad? (s/n): ")) selectDifficulty();
            } while (again);
            println("¡Gracias por jugar!");
        }

        private void selectDifficulty(){
            println("Selecciona dificultad:");
            println("1) Fácil  (8 intentos, palabras 4-7)\n2) Medio  (6 intentos, palabras 6-10)\n3) Difícil(5 intentos, palabras 8+)");
            while (true){
                String s = ask("Opción [1-3]: ");
                switch (s){
                    case "1": difficulty = Difficulty.FACIL; break;
                    case "2": difficulty = Difficulty.MEDIO; break;
                    case "3": difficulty = Difficulty.DIFICIL; break;
                    default: println("Elige 1, 2 o 3."); continue;
                }
                currentProvider = new FilterWordProvider(baseProvider, difficulty.minLen, difficulty.maxLen);
                break;
            }
        }

        private void startNewGame(){
            String secret = currentProvider.nextWord();
            game = new HangmanGame(secret, difficulty.attempts);
        }

        private void loop(){
            while (!game.isWon() && !game.isLost()){
                draw();
                String input = ask("Letra/palabra (?=pista, :salir): ");
                if (input.equalsIgnoreCase(":salir")) { println("Saliendo de la partida actual..."); break; }
                if (input.equals("?")) { println(game.useHint()); continue; }
                if (input.length() == 1) println(game.guessLetter(input.charAt(0)));
                else println(game.guessWord(input));
            }
            draw();
            if (game.isWon()) println("✅ ¡GANASTE! La palabra era: " + game.getSecret());
            else if (game.isLost()) println("❌ PERDISTE. La palabra era: " + game.getSecret());
        }

        private void draw(){
            int stage = game.getMaxAttempts() - game.getAttemptsLeft();
            stage = Math.max(0, Math.min(stage, GALLOWS.length - 1));
            println(GALLOWS[stage]);
            println("Palabra:  " + game.getProgressText());
            println("Usadas:   " + (game.getUsedLetters().isEmpty()? "(ninguna)" : game.getUsedLetters()));
            println("Intentos: " + game.getAttemptsLeft() + "/" + game.getMaxAttempts());
            println("");
        }

        private String ask(String msg){ System.out.print(msg); return sc.nextLine().trim(); }
        private boolean askYesNo(String msg){
            while (true){
                String a = ask(msg);
                if (a.equalsIgnoreCase("s")) return true;
                if (a.equalsIgnoreCase("n")) return false;
                println("Responde 's' o 'n'.");
            }
        }
        private void println(String s){ System.out.println(s); }
    }

    // ======== Utilidad de normalización ========
    static String normalizeUpper(String s){
        if (s == null) return "";
        String u = s.toUpperCase(Locale.ROOT);
        String norm = Normalizer.normalize(u, Normalizer.Form.NFD);
        // Quitamos diacríticos; Ñ se mantiene como Ñ.
        norm = norm.replaceAll("\\p{InCombiningDiacriticalMarks}+", "");
        norm = norm.replace('Á','A').replace('É','E').replace('Í','I').replace('Ó','O').replace('Ú','U');
        return norm;
    }
}