ascfix 0.7.1

//! Tests using malformed fixture files to verify ascfix robustness

use ascfix::cli::Mode;
use ascfix::config::Config;
use ascfix::modes::process_by_mode;

#[cfg(test)]
mod malformed_fixture_tests {
    use super::*;

    fn process_fixture_content(content: &str, mode: &Mode, repair_fences: bool) -> String {
        let config = Config::default();
        process_by_mode(mode, content, repair_fences, &config)
    }

    #[test]
    fn test_malformed_broken_box() {
        let content = include_str!("data/integration/dirty/malformed_broken_box.md");
        // Test that ascfix handles broken boxes gracefully
        let result = process_fixture_content(content, &Mode::Diagram, false);
        // Should not crash, may or may not fix the broken box
        assert!(!result.is_empty());
    }

    #[test]
    fn test_malformed_broken_arrows() {
        let content = include_str!("data/integration/dirty/malformed_broken_arrows.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Check that some arrows are preserved even if malformed
        assert!(result.contains("│A │") || result.contains("│A  │"));
    }

    #[test]
    fn test_malformed_broken_tables() {
        // Test dirty input produces expected clean output
        let dirty_content = include_str!("data/integration/dirty/malformed_broken_tables.md");
        let expected_clean = include_str!("data/integration/clean/malformed_broken_tables.md");

        let result = process_fixture_content(dirty_content, &Mode::Safe, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_malformed_broken_fences() {
        let content = include_str!("data/integration/dirty/malformed_broken_fences.md");
        let result = process_fixture_content(content, &Mode::Diagram, true);
        assert!(!result.is_empty());
        // Fence repair enabled
        assert!(result.contains("```"));
    }

    #[test]
    fn test_edge_case_minimal() {
        let content = include_str!("data/integration/edge_case_minimal.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
    }

    #[test]
    fn test_malformed_overlapping() {
        let content = include_str!("data/integration/dirty/malformed_overlapping.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle overlapping elements without crashing
    }

    #[test]
    fn test_malformed_nested() {
        let content = include_str!("data/integration/dirty/malformed_nested.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle nested structures
        assert!(result.contains("┌"));
    }

    #[test]
    fn test_malformed_box_alignment() {
        // Test dirty input produces expected clean output
        let dirty_content = include_str!("data/integration/dirty/malformed_box_alignment.md");
        let expected_clean = include_str!("data/integration/clean/malformed_box_alignment.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_complex_nested_with_labels() {
        // Test that complex nested diagrams don't crash ascfix
        let content = include_str!("data/integration/complex_nested_with_labels.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle nested boxes without crashing
        assert!(result.contains("┌"));
        assert!(result.contains("└"));
    }

    #[test]
    fn test_complex_connection_lines() {
        let content = include_str!("data/integration/complex_connection_lines.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle L-shaped connections and elbows
        assert!(result.contains("┌"));
        assert!(result.contains("└"));
        assert!(result.contains("─"));
        assert!(result.contains("│"));
    }

    #[test]
    fn test_complex_mixed_content() {
        let content = include_str!("data/integration/complex_mixed_content.md");
        let result = process_fixture_content(content, &Mode::Diagram, true);
        assert!(!result.is_empty());
        // Should handle diagrams, tables, and code blocks
        assert!(result.contains('┌'));
        assert!(result.contains('|'));
        assert!(result.contains("```"));
    }

    #[test]
    fn test_complex_unicode_diagrams() {
        let content = include_str!("data/integration/complex_unicode_diagrams.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle Unicode box characters
        assert!(result.contains("╔") || result.contains("╭"));
    }

    #[test]
    fn test_complex_large_diagram() {
        let content = include_str!("data/integration/complex_large_diagram.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle very large diagrams
        assert!(result.contains("┌"));
        assert!(result.lines().count() > 10);
    }

    #[test]
    fn test_edge_case_minimal_extended() {
        let content = include_str!("data/integration/edge_case_minimal_extended.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle minimal diagrams gracefully
    }

    #[test]
    fn test_complex_overlapping_elements() {
        let content = include_str!("data/integration/complex_overlapping_elements.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle overlapping elements
        assert!(result.contains("┌"));
    }

    #[test]
    fn test_complex_arrow_patterns() {
        let content = include_str!("data/integration/complex_arrow_patterns.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle various arrow styles
        assert!(result.contains('─') || result.contains('>') || result.contains('▶'));
    }

    #[test]
    fn test_complex_mixed_box_styles() {
        let content = include_str!("data/integration/complex_mixed_box_styles.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle different box styles
        assert!(result.contains('┌') || result.contains('╔') || result.contains('╭'));
    }

    #[test]
    fn test_complex_table_issues() {
        let content = include_str!("data/integration/complex_table_issues.md");
        let result = process_fixture_content(content, &Mode::Safe, false);
        assert!(!result.is_empty());
        // Should handle table normalization
        assert!(result.contains('|'));
        assert!(result.contains("Header") || result.contains("Column"));
    }

    #[test]
    fn test_complex_code_fence_issues() {
        let content = include_str!("data/integration/complex_code_fence_issues.md");
        let result = process_fixture_content(content, &Mode::Diagram, true);
        assert!(!result.is_empty());
        // Should handle fence repair
        assert!(result.contains("```") || result.contains("~~~"));
    }

    #[test]
    fn test_complex_links_in_diagrams() {
        let content = include_str!("data/integration/complex_links_in_diagrams.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle links in diagrams
        assert!(result.contains('[') || result.contains(']'));
        assert!(result.contains('┌'));
    }

    #[test]
    fn test_stress_large_table() {
        let content = include_str!("data/integration/stress_large_table.md");
        let result = process_fixture_content(content, &Mode::Safe, false);
        assert!(!result.is_empty());
        // Should handle very wide tables
        assert!(result.contains('|'));
        assert!(result.contains("Component"));
    }

    #[test]
    fn test_regression_github_flavored() {
        let content = include_str!("data/integration/regression_github_flavored.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle GFM features
        assert!(result.contains('┌') || result.contains('-') || result.contains('`'));
    }

    #[test]
    fn test_domain_devops_pipeline() {
        let content = include_str!("data/integration/domain_devops_pipeline.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle CI/CD pipeline diagrams
        assert!(result.contains('┌'));
        assert!(result.contains('─'));
    }

    #[test]
    fn test_domain_data_structures() {
        let content = include_str!("data/integration/domain_data_structures.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle tree structures
        assert!(result.contains('┌'));
        assert!(result.contains('└'));
    }

    #[test]
    fn test_domain_networking_osi() {
        let content = include_str!("data/integration/domain_networking_osi.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle layered network diagrams
        assert!(result.contains('┌'));
        assert!(result.contains('|'));
    }

    #[test]
    fn test_boundary_max_nesting() {
        let content = include_str!("data/integration/boundary_max_nesting.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle deeply nested structures gracefully
        assert!(result.contains('┌'));
    }

    #[test]
    fn test_edge_case_mathematical() {
        let content = include_str!("data/integration/edge_case_mathematical.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle mathematical notation
        assert!(result.contains('┌') || result.contains('∫') || result.contains('∑'));
    }

    #[test]
    fn test_international_multilingual() {
        let content = include_str!("data/integration/international_multilingual.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle international characters
        assert!(result.contains('┌'));
    }

    #[test]
    fn test_error_recovery_corrupted() {
        let content = include_str!("data/integration/dirty/error_recovery_corrupted.md");
        let result = process_fixture_content(content, &Mode::Diagram, true);
        assert!(!result.is_empty());
        // Should handle corrupted content gracefully
    }

    #[test]
    fn test_whitespace_handling() {
        let content = include_str!("data/integration/whitespace_handling.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle various whitespace patterns
        assert!(result.contains('┌'));
    }

    #[test]
    fn test_realworld_api_docs() {
        let content = include_str!("data/integration/realworld_api_docs.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle API documentation patterns
        assert!(result.contains('┌'));
        assert!(result.contains('|'));
    }

    #[test]
    fn test_realworld_database_schema() {
        let content = include_str!("data/integration/realworld_database_schema.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle database schema diagrams
        assert!(result.contains('┌'));
        assert!(result.contains("PK") || result.contains("FK"));
    }

    #[test]
    fn test_realworld_security_architecture() {
        let content = include_str!("data/integration/realworld_security_architecture.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle security architecture diagrams
        assert!(result.contains('┌'));
    }

    #[test]
    fn test_realworld_ml_pipeline() {
        let content = include_str!("data/integration/realworld_ml_pipeline.md");
        let result = process_fixture_content(content, &Mode::Diagram, false);
        assert!(!result.is_empty());
        // Should handle ML pipeline diagrams
        assert!(result.contains('┌'));
        assert!(result.contains('|'));
    }

    #[test]
    fn test_llm_arrow_inconsistency() {
        // Test LLM-generated content with arrows at inconsistent positions
        let dirty_content = include_str!("data/integration/dirty/llm_arrow_inconsistency.md");
        let expected_clean = include_str!("data/integration/clean/llm_arrow_inconsistency.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_mixed_box_styles() {
        // Test LLM-generated content mixing box styles (┌ vs ╔ vs ╭)
        let dirty_content = include_str!("data/integration/dirty/llm_mixed_box_styles.md");
        let expected_clean = include_str!("data/integration/clean/llm_mixed_box_styles.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_side_by_side() {
        // Test LLM-generated side-by-side boxes with uneven widths
        let dirty_content = include_str!("data/integration/dirty/llm_side_by_side.md");
        let expected_clean = include_str!("data/integration/clean/llm_side_by_side.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_fence_repair() {
        // Test LLM-generated code fences with mismatches
        let dirty_content = include_str!("data/integration/dirty/llm_fence_repair.md");
        let expected_clean = include_str!("data/integration/clean/llm_fence_repair.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, true);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_unicode_mixed() {
        // Test LLM-generated content mixing Unicode arrows and box styles
        let dirty_content = include_str!("data/integration/dirty/llm_unicode_mixed.md");
        let expected_clean = include_str!("data/integration/clean/llm_unicode_mixed.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_list_normalization() {
        // Test LLM-generated lists with mixed bullet styles
        let dirty_content = include_str!("data/integration/dirty/llm_list_normalization.md");
        let expected_clean = include_str!("data/integration/clean/llm_list_normalization.md");

        let result = process_fixture_content(dirty_content, &Mode::Safe, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_lists_no_blank_lines() {
        // Test LLM-generated lists missing blank lines before them
        let dirty_content = include_str!("data/integration/dirty/llm_lists_no_blank_lines.md");
        let expected_clean = include_str!("data/integration/clean/llm_lists_no_blank_lines.md");

        let result = process_fixture_content(dirty_content, &Mode::Safe, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_connection_paths() {
        // Test LLM-generated L-shaped connection paths
        let dirty_content = include_str!("data/integration/dirty/llm_connection_paths.md");
        let expected_clean = include_str!("data/integration/clean/llm_connection_paths.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_mixed_tables_diagrams() {
        // Test mixed tables and diagrams together
        let dirty_content = include_str!("data/integration/dirty/llm_mixed_tables_diagrams.md");
        let expected_clean = include_str!("data/integration/clean/llm_mixed_tables_diagrams.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_unicode_tables_mixed() {
        // Test Unicode and table structures mixed
        let dirty_content = include_str!("data/integration/dirty/llm_unicode_tables_mixed.md");
        let expected_clean = include_str!("data/integration/clean/llm_unicode_tables_mixed.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_diagrams_with_code() {
        // Test diagrams mixed with code blocks
        let dirty_content = include_str!("data/integration/dirty/llm_diagrams_with_code.md");
        let expected_clean = include_str!("data/integration/clean/llm_diagrams_with_code.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, true);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_llm_everything_mixed() {
        // Test everything together: lists, tables, diagrams, code, mixed styles
        let dirty_content = include_str!("data/integration/dirty/llm_everything_mixed.md");
        let expected_clean = include_str!("data/integration/clean/llm_everything_mixed.md");

        let result = process_fixture_content(dirty_content, &Mode::Diagram, true);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_malformed_wrapped_cells() {
        // Test that wrapped table cells are unwrapped in safe mode
        let dirty_content = include_str!("data/integration/dirty/malformed_wrapped_cells.md");
        let expected_clean = include_str!("data/integration/clean/malformed_wrapped_cells.md");

        let result = process_fixture_content(dirty_content, &Mode::Safe, false);
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_malformed_wrapped_with_code() {
        // Test that code blocks in table cells are preserved (not unwrapped)
        let content = include_str!("data/integration/dirty/malformed_wrapped_with_code.md");
        let result = process_fixture_content(content, &Mode::Safe, false);

        // Code blocks should be preserved
        assert!(
            result.contains("```python"),
            "Python code block should be preserved"
        );
        assert!(
            result.contains("```rust"),
            "Rust code block should be preserved"
        );
        assert!(
            result.contains("```sql"),
            "SQL code block should be preserved"
        );
        // The structure should remain multi-line
        assert!(
            result.contains("def hello():"),
            "Code content should be preserved"
        );
    }

    #[test]
    fn test_malformed_wrapped_with_links() {
        // Test that links spanning wrap boundaries are preserved
        let dirty_content = include_str!("data/integration/dirty/malformed_wrapped_with_links.md");
        let expected_clean = include_str!("data/integration/clean/malformed_wrapped_with_links.md");

        let result = process_fixture_content(dirty_content, &Mode::Safe, false);

        // Links that span boundaries should be preserved (rows not unwrapped)
        // Links that are complete should allow unwrapping
        assert_eq!(result.trim(), expected_clean.trim());
    }

    #[test]
    fn test_all_fixtures_exist() {
        // Verify all fixture files can be read
        let fixtures = vec![
            include_str!("data/integration/dirty/malformed_broken_box.md"),
            include_str!("data/integration/dirty/malformed_broken_arrows.md"),
            include_str!("data/integration/dirty/malformed_broken_tables.md"),
            include_str!("data/integration/dirty/malformed_broken_fences.md"),
            include_str!("data/integration/edge_case_minimal.md"),
            include_str!("data/integration/dirty/malformed_overlapping.md"),
            include_str!("data/integration/dirty/malformed_nested.md"),
            include_str!("data/integration/dirty/malformed_box_alignment.md"),
            // New complex fixtures
            include_str!("data/integration/complex_nested_with_labels.md"),
            include_str!("data/integration/complex_connection_lines.md"),
            include_str!("data/integration/complex_mixed_content.md"),
            include_str!("data/integration/complex_unicode_diagrams.md"),
            include_str!("data/integration/complex_large_diagram.md"),
            include_str!("data/integration/edge_case_minimal_extended.md"),
            include_str!("data/integration/complex_overlapping_elements.md"),
            include_str!("data/integration/complex_arrow_patterns.md"),
            include_str!("data/integration/complex_mixed_box_styles.md"),
            include_str!("data/integration/complex_table_issues.md"),
            include_str!("data/integration/complex_code_fence_issues.md"),
            include_str!("data/integration/complex_links_in_diagrams.md"),
            // Stress and performance fixtures
            include_str!("data/integration/stress_large_table.md"),
            // Regression fixtures
            include_str!("data/integration/regression_github_flavored.md"),
            // Domain-specific fixtures
            include_str!("data/integration/domain_devops_pipeline.md"),
            include_str!("data/integration/domain_data_structures.md"),
            include_str!("data/integration/domain_networking_osi.md"),
            // Boundary and edge case fixtures
            include_str!("data/integration/boundary_max_nesting.md"),
            include_str!("data/integration/edge_case_mathematical.md"),
            // International fixtures
            include_str!("data/integration/international_multilingual.md"),
            // Error recovery fixtures
            include_str!("data/integration/dirty/error_recovery_corrupted.md"),
            // Whitespace fixtures
            include_str!("data/integration/whitespace_handling.md"),
            // Real-world fixtures
            include_str!("data/integration/realworld_api_docs.md"),
            include_str!("data/integration/realworld_database_schema.md"),
            include_str!("data/integration/realworld_security_architecture.md"),
            include_str!("data/integration/realworld_ml_pipeline.md"),
        ];

        for fixture in fixtures {
            assert!(!fixture.is_empty(), "Fixture file should not be empty");
            assert!(fixture.contains('#'), "Fixture should have header comment");
        }

        // Verify dirty/clean pairs exist for quality validation test cases
        #[allow(clippy::no_effect_underscore_binding)]
        {
            // Stable pairs with reliable transformations (quality validated)
            let _dirty_tables = include_str!("data/integration/dirty/malformed_broken_tables.md");
            let _clean_tables = include_str!("data/integration/clean/malformed_broken_tables.md");
            let _dirty_boxes = include_str!("data/integration/dirty/malformed_box_alignment.md");
            let _clean_boxes = include_str!("data/integration/clean/malformed_box_alignment.md");
            let _dirty_wrapped = include_str!("data/integration/dirty/malformed_wrapped_cells.md");
            let _clean_wrapped = include_str!("data/integration/clean/malformed_wrapped_cells.md");
            let _dirty_nested =
                include_str!("data/integration/dirty/complex_nested_with_labels.md");
            let _clean_nested =
                include_str!("data/integration/clean/complex_nested_with_labels.md");

            // Edge case fixtures (regression tested only, not quality validated)
            // These are known to be handled conservatively by ascfix
            let _edge_arrows = include_str!("data/integration/dirty/malformed_broken_arrows.md");
            let _edge_box = include_str!("data/integration/dirty/malformed_broken_box.md");
            let _edge_fences = include_str!("data/integration/dirty/malformed_broken_fences.md");
            let _edge_overlapping = include_str!("data/integration/dirty/malformed_overlapping.md");
            let _edge_nesting = include_str!("data/integration/dirty/malformed_nested.md");
            let _edge_corrupted =
                include_str!("data/integration/dirty/error_recovery_corrupted.md");
        }
    }
}