xert 0.1.0

A professional Rust project scaffolding tool for Web, CLI, and Embedded projects.
use crate::cli::Template;
use crate::templates;
use crate::deps;
use anyhow::{Context, Result};
use colored::*;
use indicatif::{ProgressBar, ProgressStyle};
use std::fs;
use std::io::Write;
use std::path::Path;
use std::time::Duration;

pub fn create_project(template: &Template, name: &str) -> Result<()> {
    let path = Path::new(name);
    if path.exists() {
        anyhow::bail!("Directory '{}' already exists. Please choose a different name.", name);
    }
    
    // Resolve Dependencies
    let spinner_style = ProgressStyle::default_spinner()
        .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏", ""])
        .template("{spinner:.blue} {msg}")?;

    let pb = ProgressBar::new_spinner();
    pb.set_style(spinner_style.clone());
    pb.enable_steady_tick(Duration::from_millis(80));
    pb.set_message(format!("Resolving latest dependencies for {}...", name));

    let crates_to_fetch = match template {
        Template::Web => vec![
            "axum", "tokio", "tracing", "tracing-subscriber", 
            "serde", "serde_json", "dotenvy"
        ],
        Template::Cli => vec!["clap", "anyhow", "colored"],
        Template::Embedded => vec!["cortex-m", "cortex-m-rt", "panic-halt"],
    };

    let versions = deps::resolve_dependencies(&crates_to_fetch);
    pb.finish_with_message(format!("{} Dependencies resolved.", "✓".green()));

    // Create Project Structure
    let pb = ProgressBar::new_spinner();
    pb.set_style(spinner_style);
    pb.enable_steady_tick(Duration::from_millis(80));
    pb.set_message("Scaffolding project structure...");

    fs::create_dir(path).context("Failed to initialize project directory")?;

    match template {
        Template::Web => {
            write_file_silent(path, "Cargo.toml", &templates::web::cargo_toml(name, &versions))?;
            fs::create_dir(path.join("src"))?;
            write_file_silent(path, "src/main.rs", templates::web::MAIN_RS)?;
        }
        Template::Cli => {
            write_file_silent(path, "Cargo.toml", &templates::cli::cargo_toml(name, &versions))?;
            fs::create_dir(path.join("src"))?;
            write_file_silent(path, "src/main.rs", templates::cli::MAIN_RS)?;
        }
        Template::Embedded => {
            write_file_silent(path, "Cargo.toml", &templates::embedded::cargo_toml(name, &versions))?;
            fs::create_dir(path.join("src"))?;
            write_file_silent(path, "src/main.rs", templates::embedded::MAIN_RS)?;
        }
    }

    add_security_audit(path)?;
    
    pb.finish_with_message(format!("{} Project scaffolded.", "✓".green()));

    println!("\nSuccess! Created {} at {}", name.green().bold(), path.display());
    println!("inside that directory, you can run:\n");
    println!("  {}    to start the development server", "cargo run".cyan());
    println!("  {}  to check for errors\n", "cargo check".cyan());
    println!("Get started by typing:\n");
    println!("  cd {}", name.cyan());
    println!("  cargo run\n");

    Ok(())
}

fn write_file_silent(path: &Path, filename: &str, content: &str) -> Result<()> {
    let file_path = path.join(filename);
    let mut file = fs::File::create(&file_path).context(format!("Failed to create {}", filename))?;
    file.write_all(content.as_bytes())?;
    Ok(())
}

fn add_security_audit(path: &Path) -> Result<()> {
    let workflows_dir = path.join(".github").join("workflows");
    fs::create_dir_all(&workflows_dir)?;
    write_file_silent(&workflows_dir, "audit.yml", templates::security::AUDIT_YAML)?;
    Ok(())
}