/*
 * Crea un pequeño juego que consista en adivinar palabras en un número máximo de intentos:
 * - El juego comienza proponiendo una palabra aleatoria incompleta
 *   - Por ejemplo "m_ur_d_v", y el número de intentos que le quedan
 * - El usuario puede introducir únicamente una letra o una palabra (de la misma longitud que
 *   la palabra a adivinar)
 *   - Si escribe una letra y acierta, se muestra esa letra en la palabra. Si falla, se resta
 *     uno al número de intentos
 *   - Si escribe una resolución y acierta, finaliza el juego, en caso contrario, se resta uno
 *     al número de intentos
 *   - Si el contador de intentos llega a 0, el jugador pierde
 * - La palabra debe ocultar de forma aleatoria letras, y nunca puede comenzar ocultando más del 60%
 * - Puedes utilizar las palabras que quieras y el número de intentos que consideres
 */

use rand::Rng;
use std::io;

fn creapalabra(palabra: &str, vectorocultas: &mut Vec<usize>) -> String {
    let vector: Vec<char> = palabra.chars().collect();
    let mut vectorfinal: Vec<char> = Vec::new();
    for (index, i) in vector.iter().enumerate() {
        if vectorocultas.contains(&index) == false {
            vectorfinal.push(*i);
        } else {
            vectorfinal.push('_');
        }
    }
    let mut palabrafinal: String = String::from("");
    for i in vectorfinal {
        palabrafinal = palabrafinal + &i.to_string();
    }
    palabrafinal.to_string()
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // api palabras aleatorias
    let html: String = reqwest::get("https://clientes.api.greenborn.com.ar/public-random-word") // Se pasa el url o endpoint con el cual se interacturara
        .await? // Hace que reqwest espere por la respuesta del servidor
        .text() //Convierte el resultado en un String
        .await?;
    let vector: Vec<&str> = html.as_str().split("").collect();
    let mut palabra: String = String::from("");
    let mut vectorpalabra: Vec<&str> = Vec::new();
    for i in vector.iter() {
        if i != &"["
            && i.to_string() != "]"
            && i.is_empty() == false
            && i.chars().last().unwrap() != '"'
        {
            match *i {
                "á" => "a",
                "é" => "e",
                "í" => "i",
                "ó" => "o",
                "ú" => "u",
                _ => i,
            };
            palabra = palabra + i;
            vectorpalabra.push(*i);
        }
    }
    // Ya tenemos la palabra
    // calcula el 60% de la palabra
    let ocultas = palabra.len() * 6 / 10;
    // los números de caracter que va a ocultar
    let mut vectorocultas: Vec<usize> = Vec::new();
    while vectorocultas.len() != ocultas {
        let num = rand::thread_rng().gen_range(0..palabra.len());
        if vectorocultas.contains(&num) == false {
            vectorocultas.push(num);
        }
    }
    let mut intentos: i32 = 10;
    loop {
        let mut entrada = String::from("");
        println!("Intentos: {}", intentos);
        println!("Palabra: {}", creapalabra(&palabra, &mut vectorocultas));
        println!("Ingrese una letra o la solución: ");
        let lector: io::Stdin = io::stdin();
        lector.read_line(&mut entrada).expect("Fallo lectura");
        let vectorentrada: Vec<char> = entrada.chars().collect();
        if vectorentrada.len() == 2 {
            // Si es una letra
            vectorocultas.sort();
            let clonevectorocultas: Vec<usize> = vectorocultas.clone();
            for i in clonevectorocultas.iter() {
                if vectorpalabra[*i].to_string() == vectorentrada[0].to_string() {
                    let index = vectorocultas.iter().position(|x| x == i).unwrap();
                    vectorocultas.remove(index);
                    break;
                }
            }
            if clonevectorocultas.len() <= vectorocultas.len() {
                intentos -= 1;
            }
        } else {
            // Si es una palabra
            if entrada.replace("\n", "") == palabra {
                println!("Acertaste! La palabra era: {}", palabra);
                break;
            } else {
                intentos -= 1;
            }
        }

        if vectorocultas.len() == 0 {
            println!("Acertaste! La palabra era: {}", palabra);
            break;
        }

        if intentos == 0 {
            println!("Perdiste! La palabra era: {}", palabra);
            break;
        }
    }
    Ok(())
}