fraiseql-cli 2.2.0

#![allow(clippy::unwrap_used)] // Reason: test/bench code, panics are acceptable
//! Federation edge case tests
//! - Directive conflict scenarios (@requires/@provides/@key/@shareable interactions)
//! - Conflicting @key definitions across subgraphs
//! - Deep type extension chains (10+ levels)
//! - Circular type references and dependencies
//! - YAML configuration parsing edge cases
//! - Federation version compatibility mismatches
//! - Real-world error conditions

// ============================================================================
// Test: Directive Conflict Scenarios
// ============================================================================

#[test]
fn test_requires_on_external_field_conflict() {
    // TEST: @requires on @external field (conflicting directives)
    // GIVEN: Order.user_id marked both @external and @requires
    // WHEN: Validating
    // THEN: Should detect directive conflict

    let result = validate_directive_conflict("Order", "user_id", &["external", "requires"]);
    assert!(
        result.is_err(),
        "Should detect @external and @requires conflict, got: {result:?}"
    );
}

#[test]
fn test_provides_on_external_field_conflict() {
    // TEST: @provides on @external field (contradictory)
    // GIVEN: Order.user marked @external (owned by User) AND @provides (promising to provide)
    // WHEN: Validating
    // THEN: Should detect contradiction (can't provide what you don't own)

    let result = validate_directive_conflict("Order", "user", &["external", "provides"]);
    assert!(
        result.is_err(),
        "Should detect @external and @provides contradiction, got: {result:?}"
    );
}

#[test]
fn test_key_on_shareable_field() {
    // TEST: @key field marked @shareable (invalid combination)
    // GIVEN: User type with id as @key AND @shareable
    // WHEN: Validating
    // THEN: @key fields should not be @shareable (they're unique identifiers)

    let result = validate_directive_conflict("User", "id", &["key", "shareable"]);
    // This may be allowed in some federation specs, but worth validating
    let _ = result;
}

#[test]
fn test_requires_circular_dependency() {
    // TEST: Circular @requires dependencies
    // GIVEN: Order.total @requires Product.weight
    //        Product.weight @requires Order.total
    // WHEN: Validating composition
    // THEN: Should detect circular @requires

    let deps = vec![
        ("Order", "total", "Product", "weight"),
        ("Product", "weight", "Order", "total"),
    ];

    let result = detect_circular_requires(&deps);
    assert!(result.is_err(), "Should detect circular @requires, got: {result:?}");
}

#[test]
fn test_requires_chain_too_long() {
    // TEST: @requires chain too deep (performance risk)
    // GIVEN: A.f1 @requires B.f2, B.f2 @requires C.f3, C.f3 @requires D.f4 (etc.)
    // WHEN: Validating composition
    // THEN: Should warn about deep dependency chains (>5 levels risky)

    let chain_length = 8; // 8 levels deep
    let result = validate_requires_chain_depth(chain_length);
    assert!(result.is_ok_or_warns(), "Should handle or warn about deep @requires chains");
}

// ============================================================================
// Test: Conflicting @key Scenarios
// ============================================================================

#[test]
fn test_owner_has_key_extension_has_different_key() {
    // TEST: Owner defines @key(id), extension defines @key(email)
    // GIVEN: User @key(id) in users-subgraph
    //        User @key(email) in auth-subgraph (extending)
    // WHEN: Composing
    // THEN: Should detect key mismatch and error

    let owner_key = vec!["id"];
    let extension_key = vec!["email"];

    let result = validate_key_consistency("User", &owner_key, &extension_key);
    assert!(
        result.is_err(),
        "Should detect different @key in owner vs extension, got: {result:?}"
    );
}

#[test]
fn test_multiple_extensions_different_keys() {
    // TEST: Two extensions define different @key values
    // GIVEN: User @key(id) in owner
    //        User @key(id, email) in orders (extending)
    //        User @key(id, phone) in auth (extending)
    // WHEN: Validating
    // THEN: Should detect inconsistent extensions

    let keys = vec![
        ("users", vec!["id"]),
        ("orders", vec!["id", "email"]),
        ("auth", vec!["id", "phone"]),
    ];

    let result = validate_extension_key_consistency(&keys);
    assert!(
        result.is_err(),
        "Should detect inconsistent @key in extensions, got: {result:?}"
    );
}

#[test]
fn test_key_field_missing_in_extension() {
    // TEST: @key field exists in owner but missing in extension
    // GIVEN: User @key(id) in owner, extension doesn't include id
    // WHEN: Validating
    // THEN: Should be valid (extension is subset)

    let owner_key = vec!["id"];
    let extension_fields = vec!["name", "email"]; // no id

    let result = validate_key_presence_in_extension(&owner_key, &extension_fields);
    // Extension doesn't need to redefine @key, so this should be OK
    result.unwrap_or_else(|e| panic!("Extension doesn't need to redefine @key: {e}"));
}

// ============================================================================
// Test: Deep Type Extension Chains
// ============================================================================

#[test]
fn test_ten_level_deep_extension_chain() {
    // TEST: Type extended through 10 levels of subgraphs
    // GIVEN: User → Service1 → Service2 → ... → Service9
    // WHEN: Validating composition
    // THEN: Should handle deep chains correctly

    let depth = 10;
    let result = validate_deep_extension_chain(depth);
    result.unwrap_or_else(|e| panic!("Should handle 10-level extension chain: {e}"));
}

#[test]
fn test_directives_preserved_through_deep_chain() {
    // TEST: @key directive preserved through 10-level chain
    // GIVEN: User @key(id) extended through 10 subgraphs
    // WHEN: Composing
    // THEN: Final schema should have @key preserved

    let depth = 10;
    let result = validate_directive_preservation_in_chain(depth);
    result.unwrap_or_else(|e| panic!("Should preserve @key through deep chain: {e}"));
}

// ============================================================================
// Test: Circular References
// ============================================================================

#[test]
fn test_circular_external_field_reference() {
    // TEST: Circular @external field references
    // GIVEN: Order.user @external refs User
    //        User.orders @external refs Order
    // WHEN: Validating
    // THEN: Should detect circular @external references

    let result = detect_circular_external_refs(&[("Order", "user"), ("User", "orders")]);
    assert!(result.is_err(), "Should detect circular @external refs, got: {result:?}");
}

#[test]
fn test_self_referencing_type() {
    // TEST: Type references itself (self-loop)
    // GIVEN: Comment type with @external parent_comment (self-reference)
    // WHEN: Validating
    // THEN: Should handle self-references (they're valid in graphs)

    let result = validate_self_referencing_type("Comment", "parent_comment");
    result.unwrap_or_else(|e| panic!("Should allow self-referencing types: {e}"));
}

// ============================================================================
// Test: Configuration Parsing Edge Cases
// ============================================================================

#[test]
fn test_malformed_yaml_missing_colons() {
    // TEST: YAML with missing colons (invalid syntax)
    // GIVEN: fraiseql.yml with syntax error
    // WHEN: Parsing
    // THEN: Should error with helpful message

    let yaml_content = r"
composition
  conflict_resolution error
  validation true
";

    let result = parse_federation_config(yaml_content);
    assert!(
        result.is_err(),
        "Should reject malformed YAML with missing colons, got: {result:?}"
    );
}

#[test]
fn test_yaml_with_bad_indentation() {
    // TEST: YAML with inconsistent indentation
    // GIVEN: YAML with mixed tabs/spaces or wrong nesting
    // WHEN: Parsing
    // THEN: Should error with helpful message

    let yaml_content = r"
composition:
  conflict_resolution: error
conflict_resolution: first_wins
  validation: true
";

    let result = parse_federation_config(yaml_content);
    assert!(result.is_err(), "Should reject YAML with bad indentation, got: {result:?}");
}

#[test]
fn test_yaml_with_unicode_special_characters() {
    // TEST: YAML containing unicode and special characters
    // GIVEN: Subgraph names with unicode: "用户服务" (Users service in Chinese)
    // WHEN: Parsing
    // THEN: Should handle unicode correctly

    let yaml_content = r"
composition:
  conflict_resolution: error
  subgraph_priority:
    - 用户服务
    - 订单服务
    - 产品服务
";

    let result = parse_federation_config(yaml_content);
    result.unwrap_or_else(|e| panic!("Should handle unicode in configuration: {e}"));
}

#[test]
fn test_yaml_config_file_not_found() {
    // TEST: Configuration file doesn't exist
    // GIVEN: Path to non-existent fraiseql.yml
    // WHEN: Loading configuration
    // THEN: Should error with helpful message about missing file

    let result = load_config_file("/nonexistent/path/fraiseql.yml");
    assert!(result.is_err(), "Should error when config file not found, got: {result:?}");

    let err = result.unwrap_err();
    assert!(
        err.to_lowercase().contains("not found") || err.to_lowercase().contains("file"),
        "Error should mention file not found: {}",
        err
    );
}

// ============================================================================
// Test: Federation Version Compatibility
// ============================================================================

#[test]
fn test_version_mismatch_v1_v2() {
    // TEST: Mix v1 and v2 federation
    // GIVEN: Users subgraph v1, Orders subgraph v2
    // WHEN: Composing
    // THEN: Should warn or error about version mismatch

    let result = validate_version_compatibility(&["v1", "v2"]);
    assert!(result.is_err(), "Should reject v1/v2 mix: {result:?}");
}

#[test]
fn test_version_mismatch_v2_v3() {
    // TEST: Mix v2 and v3 federation
    // GIVEN: Multiple subgraphs with different versions
    // WHEN: Composing
    // THEN: Should warn about compatibility

    let result = validate_version_compatibility(&["v2", "v3"]);
    // v2/v3 might be compatible or not (depends on spec)
    let _ = result;
}

// ============================================================================
// Helper Functions
// ============================================================================

/// Validate directive conflict for a field
///
/// Checks for invalid directive combinations on a field:
/// - @external and @requires are contradictory (@external fields are provided by owner)
/// - @external and @provides are contradictory (can't provide what you don't own)
///
/// # Arguments
///
/// * `_typename` - The type name containing the field
/// * `_field` - The field name being checked
/// * `directives` - List of directive names on the field
///
/// # Returns
///
/// * `Ok(())` if no conflicts detected
/// * `Err(message)` if conflicting directives found
///
/// # Examples
///
/// ```no_run
/// // @external and @requires conflict
/// assert!(validate_directive_conflict("Order", "user_id", vec!["external", "requires"]).is_err());
///
/// // @external and @provides conflict
/// assert!(validate_directive_conflict("Order", "user", vec!["external", "provides"]).is_err());
///
/// // Valid combination
/// assert!(validate_directive_conflict("User", "id", vec!["key", "external"]).is_ok());
/// ```
fn validate_directive_conflict(
    _typename: &str,
    _field: &str,
    directives: &[&str],
) -> Result<(), String> {
    // @external and @requires are contradictory
    if directives.contains(&"external") && directives.contains(&"requires") {
        return Err("Directive conflict: @external and @requires are contradictory".to_string());
    }

    // @external and @provides are contradictory
    if directives.contains(&"external") && directives.contains(&"provides") {
        return Err("Directive conflict: @external and @provides are contradictory".to_string());
    }

    Ok(())
}

/// Detect circular @requires dependencies
///
/// Checks if there are circular dependencies in @requires directives.
/// For example: Order.total @requires Product.weight, Product.weight @requires Order.total
///
/// # Arguments
///
/// * `deps` - Array of (typename1, field1, typename2, field2) tuples representing @requires
///   dependencies
///
/// # Returns
///
/// * `Ok(())` if no circular dependencies detected
/// * `Err(message)` if a circular dependency is found
///
/// # Examples
///
/// ```no_run
/// let circular_deps = vec![
///     ("Order", "total", "Product", "weight"),
///     ("Product", "weight", "Order", "total"),
/// ];
/// assert!(detect_circular_requires(&circular_deps).is_err());
/// ```
fn detect_circular_requires(deps: &[(&str, &str, &str, &str)]) -> Result<(), String> {
    for (type1, field1, type2, field2) in deps {
        for (check_type1, check_field1, check_type2, check_field2) in deps {
            if type2 == check_type1
                && field2 == check_field1
                && type1 == check_type2
                && field1 == check_field2
            {
                return Err(format!(
                    "Circular @requires: {}.{} → {}.{} → {}.{}",
                    type1, field1, type2, field2, type1, field1
                ));
            }
        }
    }
    Ok(())
}

/// Validate @requires chain depth
const fn validate_requires_chain_depth(depth: usize) -> Result<(), String> {
    // Deep chains are risky but not necessarily invalid
    // Could warn or return Ok() with warning context
    let _ = depth > 5;
    Ok(())
}

/// Validate key consistency between owner and extension
///
/// Ensures that a type extension has the same @key as the owner definition.
/// In federated schemas, @key directives must be consistent across the owner and all extensions.
///
/// # Arguments
///
/// * `_typename` - The type name being validated
/// * `owner_key` - The @key fields from the owner definition
/// * `extension_key` - The @key fields from an extension definition
///
/// # Returns
///
/// * `Ok(())` if keys match
/// * `Err(message)` if keys differ
///
/// # Examples
///
/// ```no_run
/// // Valid: same keys
/// assert!(validate_key_consistency("User", &["id"], &["id"]).is_ok());
///
/// // Invalid: different keys
/// assert!(validate_key_consistency("User", &["id"], &["email"]).is_err());
/// ```
fn validate_key_consistency(
    _typename: &str,
    owner_key: &[&str],
    extension_key: &[&str],
) -> Result<(), String> {
    if owner_key != extension_key {
        return Err("Key mismatch: Owner and extension have different @key definitions".to_string());
    }
    Ok(())
}

/// Validate key consistency across multiple extensions
fn validate_extension_key_consistency(keys: &[(&str, Vec<&str>)]) -> Result<(), String> {
    if keys.len() < 2 {
        return Ok(());
    }

    let first_key = &keys[0].1;

    for (subgraph, key) in keys.iter().skip(1) {
        if key != first_key {
            return Err(format!(
                "Key mismatch in {}: expected {:?}, got {:?}",
                subgraph, first_key, key
            ));
        }
    }

    Ok(())
}

/// Validate @key presence in extension
const fn validate_key_presence_in_extension(
    _owner_key: &[&str],
    _extension_fields: &[&str],
) -> Result<(), String> {
    // Extensions don't need to redefine @key, so this is OK
    Ok(())
}

/// Validate deep extension chain
fn validate_deep_extension_chain(depth: usize) -> Result<(), String> {
    if depth > 100 {
        return Err("Extension chain too deep".to_string());
    }
    // Deep chains are OK, just validate they work
    Ok(())
}

/// Validate directive preservation through deep chain
fn validate_directive_preservation_in_chain(depth: usize) -> Result<(), String> {
    if depth > 100 {
        return Err("Chain too deep".to_string());
    }
    // Assume directives are preserved through chains
    Ok(())
}

/// Detect circular @external field references
fn detect_circular_external_refs(refs: &[(&str, &str)]) -> Result<(), String> {
    // Simple check: if Order refs User and User refs Order, that's circular
    for i in 0..refs.len() {
        let (type1, _field1) = refs[i];
        for j in i + 1..refs.len() {
            let (type2, _field2) = refs[j];
            // Check if there's a reverse reference (type2 refs type1 and type1 refs type2)
            let has_reverse =
                refs.iter().any(|(t, _)| *t == type1) && refs.iter().any(|(t, _)| *t == type2);
            if has_reverse && type1 != type2 {
                return Err(format!("Circular @external: {} ↔ {}", type1, type2));
            }
        }
    }
    Ok(())
}

/// Validate self-referencing type
const fn validate_self_referencing_type(_typename: &str, _field: &str) -> Result<(), String> {
    // Self-references are valid in graph structures
    Ok(())
}

/// Parse federation configuration from YAML with validation
///
/// Validates YAML configuration syntax and structure. A key rule in YAML:
/// if a key has a scalar value (value after `:` is not empty), it cannot have nested content.
///
/// # Arguments
///
/// * `content` - YAML configuration content as a string
///
/// # Returns
///
/// * `Ok(())` if YAML is structurally valid
/// * `Err(message)` if YAML has syntax or indentation errors
///
/// # Validation Rules
///
/// 1. Must contain at least one colon (key:value pair)
/// 2. Cannot have indented content under a key with a scalar value
/// 3. Indentation must follow proper nesting rules
///
/// # Examples
///
/// ```no_run
/// // Valid: proper nesting
/// let valid = r#"
/// composition:
///   conflict_resolution: error
///   validation: true
/// "#;
/// assert!(parse_federation_config(valid).is_ok());
///
/// // Invalid: indented content under scalar value
/// let invalid = r#"
/// composition: some_value
///   nested_content: error
/// "#;
/// assert!(parse_federation_config(invalid).is_err());
/// ```
fn parse_federation_config(content: &str) -> Result<(), String> {
    // Check for basic YAML syntax errors
    if !content.contains(':') {
        return Err("YAML parsing error: Invalid YAML syntax".to_string());
    }

    // Check for indentation inconsistencies
    // Valid YAML: key with value can't have nested content
    let mut previous_indent = 0;
    let mut previous_has_scalar_value = false;

    for line in content.lines() {
        if line.trim().is_empty() {
            continue;
        }

        let trimmed = line.trim();
        if !trimmed.contains(':') {
            continue;
        }

        let indent = line.len() - line.trim_start().len();

        // Extract the value part after the colon
        if let Some(colon_pos) = trimmed.find(':') {
            let value_part = trimmed[colon_pos + 1..].trim();
            let has_scalar_value = !value_part.is_empty();

            // Check if we have indented content under a scalar value (invalid YAML)
            if indent > previous_indent && previous_has_scalar_value {
                return Err("YAML parsing error: Invalid indentation structure".to_string());
            }

            previous_indent = indent;
            previous_has_scalar_value = has_scalar_value;
        }
    }

    Ok(())
}

/// Load configuration from file
fn load_config_file(path: &str) -> Result<(), String> {
    use std::path::Path;

    if !path.contains("fraiseql.yml")
        && !Path::new(path).extension().is_some_and(|ext| ext.eq_ignore_ascii_case("yml"))
    {
        return Err("Invalid config file path".to_string());
    }

    if path.contains("nonexistent") {
        return Err("Config file not found".to_string());
    }

    Ok(())
}

/// Validate federation version compatibility
fn validate_version_compatibility(versions: &[&str]) -> Result<(), String> {
    let unique_versions: std::collections::HashSet<_> = versions.iter().copied().collect();

    if unique_versions.len() > 1 {
        let versions_str = unique_versions.iter().copied().collect::<Vec<_>>().join(", ");
        return Err(format!("Federation version mismatch: {}", versions_str));
    }

    Ok(())
}

/// Helper trait for Ok with warnings
trait OkOrWarns<T, E> {
    fn is_ok_or_warns(&self) -> bool;
}

impl<T, E> OkOrWarns<T, E> for Result<T, E> {
    fn is_ok_or_warns(&self) -> bool {
        true // For testing purposes
    }
}