dojo_cli/commands/

init.rs

use crate::config::Config;
use dialoguer::{Confirm, Input, Password};
use std::path::Path;
use std::process::Command;

pub async fn handle_init_command(
    sub_matches: &clap::ArgMatches,
) -> Result<(), Box<dyn std::error::Error>> {
    println!("__________.__  __               .__         ________             __        ");
    println!("\\______   \\__|/  |_  ____  ____ |__| ____   \\______ \\   ____    |__| ____  ");
    println!(" |    |  _/  \\   __\\/ ___\\/  _ \\|  |/    \\   |    |  \\ /  _ \\   |  |/  _ \\ ");
    println!(" |    |   \\  ||  | \\  \\__(  <_> )  |   |  \\  |    `   (  <_> )  |  (  <_> )");
    println!(" |______  /__||__|  \\___  >____/|__|___|  / /_______  /\\____/\\__|  |\\____/ ");
    println!("        \\/              \\/              \\/          \\/      \\______|       \n");
    println!("🚀 Welcome to Bitcoin Dojo CLI Setup!");
    println!("This will help you configure your development environment.\n");

    // Check if config already exists
    if Config::exists() {
        let overwrite = Confirm::new()
            .with_prompt("Configuration already exists. Do you want to overwrite it?")
            .default(false)
            .interact()?;

        if !overwrite {
            println!("Setup cancelled.");
            return Ok(());
        }
    }

    // Prompt for workspace directory
    let default_workspace = dirs::home_dir()
        .map(|home| {
            home.join("bitcoin_dojo_workspace")
                .to_string_lossy()
                .to_string()
        })
        .unwrap_or_else(|| "./bitcoin_dojo_workspace".to_string());

    let workspace_directory: String = Input::new()
        .with_prompt("Enter your workspace directory (or press enter to use the default directory)")
        .default(default_workspace)
        .interact_text()?;

    // Validate and create workspace directory if it doesn't exist
    let workspace_path = Path::new(&workspace_directory);
    if !workspace_path.exists() {
        let create_dir = Confirm::new()
            .with_prompt(format!(
                "Directory '{}' doesn't exist. Create it?",
                workspace_directory
            ))
            .default(true)
            .interact()?;

        if create_dir {
            std::fs::create_dir_all(workspace_path)?;
            println!("✅ Created workspace directory: {}", workspace_directory);
        }
    }

    // Get API token from command line argument or prompt user
    let api_token = if let Some(token) = sub_matches.get_one::<String>("token") {
        token.to_string()
    } else {
        println!("\n🔑 API Token Setup");
        println!("You can get your API token from the Bitcoin Dojo web dashboard.");

        Password::new()
            .with_prompt("Enter your API token")
            .interact()?
    };

    // Validate API token (basic check)
    if api_token.trim().is_empty() {
        return Err("API token cannot be empty".into());
    }

    // Initialize curriculum version from backend (required)
    println!("\n🔧 Initializing curriculum version...");
    let curriculum_version = Config::init_curriculum_version(&api_token).await?;
    println!("✅ Curriculum version initialized: {}", curriculum_version);

    // Create and save config
    let config = Config::new(
        workspace_directory.clone(),
        api_token,
        curriculum_version.clone(),
    );
    config.save()?;

    let config_path = Config::get_config_path()?;

    println!("\n✅ Configuration saved successfully!");
    println!("📁 Config file: {}", config_path.display());
    println!("📂 Workspace: {}", workspace_directory);
    println!("📚 Curriculum version: {}", curriculum_version);

    // Check if cargo is available before attempting to create Rust project
    let cargo_available = is_cargo_available();

    if !cargo_available {
        println!("\n⚠️  Cargo is not available on your system.");
        println!("This means you won't be able to create a Rust project automatically.");
        println!("You can still use the CLI to download exercises, but you'll need to create the Rust project manually.");

        let continue_without_cargo = Confirm::new()
            .with_prompt("Continue without creating a Rust project?")
            .default(true)
            .interact()?;

        if !continue_without_cargo {
            println!("Setup cancelled. Please install Rust and Cargo first, then try again.");
            return Ok(());
        }

        println!("✅ Configuration saved successfully!");
        println!("📁 Config file: {}", config_path.display());
        println!("📂 Workspace: {}", workspace_directory);
        println!("📚 Curriculum version: {}", curriculum_version);
        println!("\n🎯 You can now use 'dojo-cli download --exercise <exercise-name>' to download exercises.");
        println!("Remember to create a Rust project manually in your workspace when you're ready.");
        return Ok(());
    }

    // Create new Rust project in workspace
    println!("\n🦀 Creating Rust project...");
    let project_path = workspace_path.join("bitcoin_dojo");

    if project_path.exists() {
        let overwrite_project = Confirm::new()
            .with_prompt("Rust project 'bitcoin_dojo' already exists in workspace. Overwrite it?")
            .default(false)
            .interact()?;

        if !overwrite_project {
            println!("Skipping Rust project creation.");
        } else {
            std::fs::remove_dir_all(&project_path)?;
            create_rust_project(&workspace_directory)?;
        }
    } else {
        create_rust_project(&workspace_directory)?;
    }

    println!("\n🎯 You're all set! Open your editor to {}/bitcoin_dojo and run 'dojo-cli download --exercise 1.1-hashing-randomness' to download the first exercise.", &workspace_directory);

    Ok(())
}

fn create_rust_project(workspace_directory: &str) -> Result<(), Box<dyn std::error::Error>> {
    // Check if cargo is available
    if !is_cargo_available() {
        return Err(
            "❌ Cargo is not available. Please install Rust and Cargo first.\n\n\
                   To install Rust, visit https://rustup.rs/ or run:\n\
                   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh\n\n\
                   After installation, restart your terminal and try again."
                .into(),
        );
    }

    let output = Command::new("cargo")
        .args(["new", "--lib", "bitcoin_dojo"])
        .current_dir(workspace_directory)
        .output()?;

    if output.status.success() {
        println!("✅ Created Rust project: bitcoin_dojo");
        println!("📁 Project location: {}/bitcoin_dojo", workspace_directory);
    } else {
        let error_msg = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Failed to create Rust project: {}", error_msg).into());
    }

    Ok(())
}

/// Check if cargo is available in the system PATH
fn is_cargo_available() -> bool {
    Command::new("cargo")
        .arg("--version")
        .output()
        .map(|output| output.status.success())
        .unwrap_or(false)
}