//! Integration tests for the Terrace Rust implementation.

use terrace::{TerraceDocument, StringReader};

#[tokio::test]
async fn test_basic_parsing() {
    let content = r#"
config
 database
  host localhost
  port 5432
 server
  port 3000
  host 0.0.0.0
"#;

    let reader = StringReader::new(content);
    let mut doc = TerraceDocument::with_reader(reader);

    let mut nodes = Vec::new();
    while let Some(node) = doc.next().await {
        if !node.is_empty() {
            nodes.push((node.level(), node.head().to_string(), node.tail().to_string()));
        }
    }

    // Verify the structure
    assert!(nodes.len() >= 6); // At least config, database, host, port, server, port, host

    // Find config node
    let config_node = nodes.iter().find(|(_, head, _)| head == "config").unwrap();
    assert_eq!(config_node.0, 0);

    // Find database node
    let database_node = nodes.iter().find(|(_, head, _)| head == "database").unwrap();
    assert_eq!(database_node.0, 1);

    // Find host nodes
    let host_nodes: Vec<_> = nodes.iter().filter(|(_, head, _)| head == "host").collect();
    assert_eq!(host_nodes.len(), 2);
    assert_eq!(host_nodes[0].0, 2); // database host
    assert_eq!(host_nodes[1].0, 2); // server host
}

#[tokio::test]
async fn test_navigation_methods() {
    let content = "root\n child1\n child2\n  grandchild\n child3";
    let reader = StringReader::new(content);
    let doc = TerraceDocument::with_reader(reader);

    let nodes = doc.collect().await;

    // Test basic properties
    assert_eq!(nodes[0].head(), "root");
    assert_eq!(nodes[0].level(), 0);

    assert_eq!(nodes[1].head(), "child1");
    assert_eq!(nodes[1].level(), 1);

    assert_eq!(nodes[2].head(), "child2");
    assert_eq!(nodes[2].level(), 1);

    assert_eq!(nodes[3].head(), "grandchild");
    assert_eq!(nodes[3].level(), 2);

    assert_eq!(nodes[4].head(), "child3");
    assert_eq!(nodes[4].level(), 1);
}

#[tokio::test]
async fn test_empty_and_whitespace() {
    let content = "line1\n\n  \nline2";
    let reader = StringReader::new(content);
    let mut doc = TerraceDocument::with_reader(reader);

    let mut non_empty_count = 0;
    while let Some(node) = doc.next().await {
        if !node.is_empty() {
            non_empty_count += 1;
        }
    }

    assert_eq!(non_empty_count, 2);
}