main.rs

use reqwest::blocking::Client;
use serde::{Deserialize, Serialize};
use std::env;
use std::thread;
use std::time::Duration;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct CreateTaskRequest {
    client_key: String,
    task: Task,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Task {
    #[serde(rename = "type")]
    task_type: String,
    website_url: String,
    website_key: String,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct CreateTaskResponse {
    error_id: i32,
    error_code: Option<String>,
    error_description: Option<String>,
    task_id: Option<String>,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetTaskResultRequest {
    client_key: String,
    task_id: String,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct GetTaskResultResponse {
    error_id: i32,
    error_code: Option<String>,
    error_description: Option<String>,
    status: Option<String>,
    solution: Option<Solution>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Solution {
    token: String,
}

fn main() {
    // Cargar variables de entorno
    dotenvy::dotenv().ok();
    let api_key = env::var("CAPSOLVER_API_KEY").expect("CAPSOLVER_API_KEY debe estar configurado");

    let client = Client::new();
    let base_url = "https://api.capsolver.com";

    // Paso 1: Crear tarea
    println!("Creando tarea MtCaptchaTaskProxyLess...");

    let create_request = CreateTaskRequest {
        client_key: api_key.clone(),
        task: Task {
            task_type: "MtCaptchaTaskProxyLess".to_string(),
            website_url: "https://example.com".to_string(),
            website_key: "MTPublic-DemoKey9M".to_string(),
        },
    };

    let create_response = client
        .post(format!("{}/createTask", base_url))
        .json(&create_request)
        .send()
        .expect("Error al enviar la solicitud")
        .json::<CreateTaskResponse>()
        .expect("Error al analizar la respuesta");

    if create_response.error_id != 0 {
        eprintln!(
            "Error al crear la tarea: {} - {}",
            create_response.error_code.unwrap_or_default(),
            create_response.error_description.unwrap_or_default()
        );
        return;
    }

    let task_id = create_response.task_id.expect("No se devolvió ID de tarea");
    println!("Tarea creada con éxito. ID de tarea: {}", task_id);

    // Paso 2: Consultar el resultado
    println!("Esperando a que se complete la tarea...");

    loop {
        thread::sleep(Duration::from_secs(2));

        let result_request = GetTaskResultRequest {
            client_key: api_key.clone(),
            task_id: task_id.clone(),
        };

        let result_response = client
            .post(format!("{}/getTaskResult", base_url))
            .json(&result_request)
            .send()
            .expect("Error al enviar la solicitud")
            .json::<GetTaskResultResponse>()
            .expect("Error al analizar la respuesta");

        if result_response.error_id != 0 {
            eprintln!(
                "Error al obtener el resultado de la tarea: {} - {}",
                result_response.error_code.unwrap_or_default(),
                result_response.error_description.unwrap_or_default()
            );
            return;
        }

        match result_response.status.as_deref() {
            Some("ready") => {
                let solution = result_response.solution.expect("No se devolvió solución");
                println!("\n¡Tarea completada con éxito!");
                println!("Token: {}", solution.token);
                break;
            }
            Some("processing") => {
                print!(".");
                std::io::Write::flush(&mut std::io::stdout()).ok();
            }
            Some("failed") => {
                eprintln!("\n¡La tarea falló!");
                return;
            }
            _ => {
                eprintln!("\nEstado desconocido");
                return;
            }
        }
    }
}