//! Example demonstrating ECS integration and selective type parsing
//!
//! This example shows:
//! 1. Custom components being automatically inserted into the ECS world
//! 2. Using the parse_with_types! macro for selective parsing
//! 3. Querying the ECS world for components

use cursebreaker_parser::{parse_with_types, ComponentContext, EcsInsertable, FileID, TypeFilter, UnityComponent};

/// Custom Unity MonoBehaviour component
#[derive(Debug, Clone, UnityComponent)]
#[unity_class("PlaySFX")]
pub struct PlaySFX {
    #[unity_field("volume")]
    pub volume: f64,

    #[unity_field("startTime")]
    pub start_time: f64,

    #[unity_field("endTime")]
    pub end_time: f64,

    #[unity_field("isLoop")]
    pub is_loop: bool,
}

/// Another custom component
#[derive(Debug, Clone, UnityComponent)]
#[unity_class("Interactable")]
pub struct Interactable {
    #[unity_field("interactionRadius")]
    pub interaction_radius: f32,

    #[unity_field("interactionText")]
    pub interaction_text: String,

    #[unity_field("canInteract")]
    pub can_interact: bool,
}

fn main() {
    println!("ECS Integration & Selective Parsing Example");
    println!("{}", "=".repeat(60));

    // Example 1: Using parse_with_types! macro
    println!("\n1. Creating type filters:");
    println!("{}", "-".repeat(60));

    let _filter_all = TypeFilter::parse_all();
    println!("✓ Filter that parses ALL types");

    let filter_selective = parse_with_types! {
        unity_types(Transform, Camera),
        custom_types(PlaySFX)
    };
    println!("✓ Filter for Transform, Camera, and PlaySFX only");

    let filter_custom_only = parse_with_types! {
        custom_types(PlaySFX, Interactable)
    };
    println!("✓ Filter for PlaySFX and Interactable only (no Unity types)");

    // Example 2: Demonstrating ECS insertion
    println!("\n2. ECS Integration:");
    println!("{}", "-".repeat(60));

    // Simulate parsing a PlaySFX component
    let yaml_str = r#"
volume: 0.8
startTime: 0.0
endTime: 5.0
isLoop: 0
"#;

    let yaml: serde_yaml::Value = serde_yaml::from_str(yaml_str).unwrap();
    let mapping = yaml.as_mapping().unwrap();

    let ctx = ComponentContext {
        type_id: 114,
        file_id: FileID::from_i64(12345),
        class_name: "PlaySFX",
        entity: None,
        linking_ctx: None,
        yaml: mapping,
    };

    // Parse the component
    if let Some(play_sfx) = PlaySFX::parse(mapping, &ctx) {
        println!("✓ Parsed PlaySFX component:");
        println!("  - volume: {}", play_sfx.volume);
        println!("  - start_time: {}", play_sfx.start_time);
        println!("  - end_time: {}", play_sfx.end_time);
        println!("  - is_loop: {}", play_sfx.is_loop);

        // Create a minimal ECS world to demonstrate insertion
        use sparsey::World;
        let mut world = World::builder().register::<PlaySFX>().build();
        let entity = world.create(());

        println!("\n✓ Created ECS entity: {:?}", entity);

        // Insert the component into the world
        play_sfx.clone().insert_into_world(&mut world, entity);
        println!("✓ Inserted PlaySFX component into ECS world");

        // Query it back
        {
            let view = world.borrow::<PlaySFX>();
            if let Some(component) = view.get(entity) {
                println!("✓ Successfully queried component from ECS:");
                println!("  - volume: {}", component.volume);
            }
        }
    }

    // Example 3: Type filter usage
    println!("\n3. Type Filter Behavior:");
    println!("{}", "-".repeat(60));

    println!("Filter checks:");
    println!("  Transform in selective filter: {}", filter_selective.should_parse_unity("Transform"));
    println!("  Camera in selective filter: {}", filter_selective.should_parse_unity("Camera"));
    println!("  Light in selective filter: {}", filter_selective.should_parse_unity("Light"));
    println!("  PlaySFX in selective filter: {}", filter_selective.should_parse_custom("PlaySFX"));
    println!("  Interactable in selective filter: {}", filter_selective.should_parse_custom("Interactable"));

    println!("\n  PlaySFX in custom-only filter: {}", filter_custom_only.should_parse_custom("PlaySFX"));
    println!("  Transform in custom-only filter: {}", filter_custom_only.should_parse_unity("Transform"));

    // Example 4: Benefits of selective parsing
    println!("\n4. Benefits of Selective Parsing:");
    println!("{}", "-".repeat(60));
    println!("When parsing a large Unity project:");
    println!("  • Parse ALL types: Parse everything (default)");
    println!("  • Parse specific types: Faster parsing & less memory");
    println!("  • Parse only what you need for your tool/analysis");
    println!("\nExample use cases:");
    println!("  • Animation tool: Only parse Animator, AnimationClip");
    println!("  • Audio tool: Only parse AudioSource, PlaySFX");
    println!("  • Transform analyzer: Only parse Transform, RectTransform");

    println!();
    println!("{}", "=".repeat(60));
    println!("Complete! Custom components now work with ECS!");
    println!("{}", "=".repeat(60));
}