tron 2.1.0

//! Template validation example showing linting and quality checks.
//!
//! This example demonstrates how to use the validation system to check
//! template quality, catch common errors, and enforce best practices.

use tron::{TronTemplate, TronRef, Result};
use tron::validation::{TemplateValidator, ValidationConfig, Severity, IssueCategory};

fn main() -> Result<()> {
    println!("=== Tron Template Validation Example ===\n");

    // Example 1: Basic validation
    example_basic_validation()?;
    
    // Example 2: Validation with issues
    example_validation_with_issues()?;
    
    // Example 3: Custom validation configuration
    example_custom_validation()?;
    
    // Example 4: Security validation
    example_security_validation()?;
    
    // Example 5: Multiple template validation
    example_multiple_template_validation()?;

    Ok(())
}

fn example_basic_validation() -> Result<()> {
    println!("1. Basic Template Validation (Good Template):");
    
    let template = TronTemplate::new(
        "fn @[function_name]@(@[parameters]@) -> @[return_type]@ {\n    @[function_body]@\n}"
    )?;
    
    let validator = TemplateValidator::new();
    let report = validator.validate(&template)?;
    
    println!("   Template: fn @[function_name]@(@[parameters]@) -> @[return_type]@ {{ @[function_body]@ }}");
    println!("   {}", report);
    
    Ok(())
}

fn example_validation_with_issues() -> Result<()> {
    println!("2. Validation with Issues:");
    
    // Template with several issues
    let template = TronTemplate::new(
        "fn @[n]@() { @[x]@; }   \nlet @[a]@ = @[b]@;    "
    )?;
    
    let validator = TemplateValidator::new();
    let report = validator.validate(&template)?;
    
    println!("   Template with issues:");
    println!("   {}", report);
    
    // Show issue breakdown
    let errors = report.issues_by_severity(Severity::Error);
    let warnings = report.issues_by_severity(Severity::Warning);
    let info = report.issues_by_severity(Severity::Info);
    
    println!("   Breakdown: {} errors, {} warnings, {} info", 
        errors.len(), warnings.len(), info.len());
    
    Ok(())
}

fn example_custom_validation() -> Result<()> {
    println!("3. Custom Validation Configuration:");
    
    // Create custom validation config
    let mut config = ValidationConfig::default();
    config.min_placeholder_length = 5; // Require longer placeholder names
    config.check_placeholder_naming = true;
    config.check_security = false; // Skip security checks for this example
    config.check_performance = true;
    
    let template = TronTemplate::new("Hello @[name]@! Your @[age]@ is recorded.")?;
    
    let validator = TemplateValidator::with_config(config);
    let report = validator.validate(&template)?;
    
    println!("   Custom config (min_placeholder_length = 5):");
    println!("   Template: Hello @[name]@! Your @[age]@ is recorded.");
    println!("   {}", report);
    
    Ok(())
}

fn example_security_validation() -> Result<()> {
    println!("4. Security Validation:");
    
    // Template with potential security issues
    let template = TronTemplate::new(
        r#"
function processData() {
    eval(@[user_code]@);
    var password = "@[user_password]@";
    return "<script>alert('XSS');</script>";
}
"#
    )?;
    
    let validator = TemplateValidator::new();
    let report = validator.validate(&template)?;
    
    println!("   Template with security concerns:");
    println!("   {}", report);
    
    // Show only security issues
    let security_issues = report.issues_by_category(&IssueCategory::Security);
    if !security_issues.is_empty() {
        println!("   Security-specific issues:");
        for (i, issue) in security_issues.iter().enumerate() {
            println!("     {}. {}", i + 1, issue.message());
            if let Some(suggestion) = issue.suggestion() {
                println!("        Suggestion: {}", suggestion);
            }
        }
    }
    
    Ok(())
}

fn example_multiple_template_validation() -> Result<()> {
    println!("5. Multiple Template Validation:");
    
    let templates = vec![
        TronTemplate::new("fn @[function_name]@(@[params]@) -> @[return_type]@ { @[body]@ }")?,
        TronTemplate::new("struct @[n]@ { @[f]@ }")?,  // Short placeholder names
        TronTemplate::new("Hello @[user_name]@! Welcome to @[application_name]@.")?,  // Good template
        TronTemplate::new("const @[C]@ = @[value]@;")?,  // Uppercase in placeholder
    ];
    
    let validator = TemplateValidator::new();
    
    // Validate each template and collect results
    for (index, template) in templates.iter().enumerate() {
        let report = validator.validate(template)?;
        
        println!("   Template #{}: {} issue(s)", 
            index + 1, 
            report.issues().len()
        );
        
        if report.has_issues() {
            // Show first few issues
            for issue in report.issues().iter().take(2) {
                println!("     - [{}] {}: {}", 
                    issue.severity(), 
                    issue.category(),
                    issue.message()
                );
            }
            if report.issues().len() > 2 {
                println!("     ... and {} more", report.issues().len() - 2);
            }
        } else {
            println!("     ✓ No issues found");
        }
        println!();
    }
    
    // Demonstrate template reference validation
    println!("   Template Reference Validation:");
    let template = TronTemplate::new("fn main() { @[body]@ }")?;
    let template_ref = TronRef::new(template)
        .with_dependency("unsafe_crate = \"0.1\"");
    
    let report = validator.validate_ref(&template_ref)?;
    println!("   TronRef validation: {} issue(s)", report.issues().len());
    
    Ok(())
}