use crate::config::{find_project_root, ConfigError, MlfConfig};
use std::path::PathBuf;

pub mod code;
pub mod lexicon;
pub mod mlf;

/// Run all output configurations from mlf.toml
pub fn run_all() -> Result<(), std::io::Error> {
    let current_dir = std::env::current_dir()?;

    let project_root = find_project_root(&current_dir)
        .map_err(|e| match e {
            ConfigError::NotFound => {
                std::io::Error::new(
                    std::io::ErrorKind::NotFound,
                    "No mlf.toml found. Please create a configuration file or provide explicit arguments."
                )
            }
            _ => std::io::Error::new(std::io::ErrorKind::Other, format!("Failed to load config: {}", e)),
        })?;

    let config_path = project_root.join("mlf.toml");
    let config = MlfConfig::load(&config_path)
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("Failed to load config: {}", e)))?;

    if config.output.is_empty() {
        println!("No output configurations found in mlf.toml");
        return Ok(());
    }

    println!("Running {} output configuration(s)...", config.output.len());

    // Build input path from source directory
    let source_dir = project_root.join(&config.source.directory);
    let input_paths = vec![source_dir.clone()];

    let mut errors = Vec::new();
    let mut success_count = 0;

    for output_config in &config.output {
        let output_type = &output_config.r#type;
        let output_dir = PathBuf::from(&output_config.directory);

        println!("\nGenerating {} output to {}...", output_type, output_config.directory);

        let result = match output_type.as_str() {
            "lexicon" => {
                lexicon::run(input_paths.clone(), Some(output_dir), Some(source_dir.clone()), false)
                    .map_err(|e| format!("{}", e))
            }
            "mlf" => {
                // For MLF output, we expect JSON lexicons as input
                // This is a bit different - we'd need JSON input patterns
                eprintln!("  Warning: MLF generation from TOML config not yet fully implemented");
                continue;
            }
            generator_type => {
                // Assume it's a code generator (typescript, go, rust, etc.)
                code::run(Some(generator_type.to_string()), input_paths.clone(), Some(output_dir), Some(source_dir.clone()), false)
                    .map_err(|e| format!("{}", e))
            }
        };

        match result {
            Ok(()) => {
                success_count += 1;
                println!("  ✓ Generated {} output successfully", output_type);
            }
            Err(e) => {
                errors.push((output_type.clone(), e));
                eprintln!("  ✗ Failed to generate {} output", output_type);
            }
        }
    }

    if !errors.is_empty() {
        eprintln!(
            "\n{} output(s) generated successfully, {} error(s)",
            success_count,
            errors.len()
        );
        for (output_type, error) in &errors {
            eprintln!("  {} - {}", output_type, error);
        }
        return Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            format!("Failed to generate {} output(s)", errors.len())
        ));
    }

    println!("\n✓ Successfully generated all {} output(s)", success_count);
    Ok(())
}