use std::path::PathBuf;
use tempfile::TempDir;

#[test]
fn test_scanner_finds_all_sample_files() {
    let samples_dir = PathBuf::from("tests/samples");
    let scanner = codebase_summarizer::scanner::Scanner::default_config();
    let files = scanner.scan(&samples_dir).unwrap();

    assert!(files.len() >= 12, "Should find at least 12 sample files");
}

#[test]
fn test_parse_go_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.go");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GoParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Go);
    assert!(summary.symbols.len() >= 4, "Should find functions, structs, const");
}

#[test]
fn test_parse_rust_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.rs");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::RustParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Rust);
    assert!(summary.symbols.len() >= 5, "Should find struct, functions, const, type");
}

#[test]
fn test_parse_python_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.py");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::PythonParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Python);
    assert!(summary.symbols.len() >= 3, "Should find functions and class");
}

#[test]
fn test_parse_dart_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.dart");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::DartParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Dart);
    assert!(summary.symbols.len() >= 4, "Should find class, enum, methods");
}

#[test]
fn test_parse_typescript_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.ts");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::TypeScriptParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::TypeScript);
    assert!(summary.symbols.len() >= 5, "Should find class, interface, type, enum, const");
}

#[test]
fn test_parse_r_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.r");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::RParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::R);
    assert!(summary.symbols.len() >= 2, "Should find function and class");
}

#[test]
fn test_parse_java_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.java");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GenericParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Java);
    assert!(summary.symbols.len() >= 3, "Should find class, interface, enum");
}

#[test]
fn test_parse_c_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.c");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GenericParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::C);
    assert!(summary.symbols.len() >= 3, "Should find struct, functions, const");
}

#[test]
fn test_parse_ruby_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.rb");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GenericParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Ruby);
    assert!(summary.symbols.len() >= 2, "Should find class and module");
}

#[test]
fn test_parse_php_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.php");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GenericParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Php);
    assert!(summary.symbols.len() >= 2, "Should find class and interface");
}

#[test]
fn test_parse_swift_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.swift");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GenericParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Swift);
    assert!(summary.symbols.len() >= 2, "Should find struct and func");
}

#[test]
fn test_parse_kotlin_sample() {
    use codebase_summarizer::parser::LanguageParser;
    let path = PathBuf::from("tests/samples/sample.kt");
    let content = std::fs::read_to_string(&path).unwrap();
    let parser = codebase_summarizer::parser::GenericParser;
    let summary = parser.parse(&path, &content);

    assert_eq!(summary.language, codebase_summarizer::models::Language::Kotlin);
    assert!(summary.symbols.len() >= 3, "Should find data class, functions, enum");
}

#[test]
fn test_parser_factory() {
    use codebase_summarizer::parser::{get_parser, LanguageParser};

    let go_parser = get_parser(&codebase_summarizer::models::Language::Go);
    let rust_parser = get_parser(&codebase_summarizer::models::Language::Rust);
    let python_parser = get_parser(&codebase_summarizer::models::Language::Python);
    let generic_parser = get_parser(&codebase_summarizer::models::Language::Cpp);

    assert!(go_parser.parse(&PathBuf::from("test.go"), "").language == codebase_summarizer::models::Language::Go);
    assert!(rust_parser.parse(&PathBuf::from("test.rs"), "").language == codebase_summarizer::models::Language::Rust);
    assert!(python_parser.parse(&PathBuf::from("test.py"), "").language == codebase_summarizer::models::Language::Python);
    assert!(generic_parser.parse(&PathBuf::from("test.cpp"), "").language == codebase_summarizer::models::Language::Cpp);
}

#[test]
fn test_writer_generates_markdown() {
    use codebase_summarizer::models::{CodebaseSummary, FileSummary, Symbol, SymbolKind};
    use codebase_summarizer::writer::MarkdownWriter;

    let temp_dir = TempDir::new().unwrap();
    let output_path = temp_dir.path().join("summary.md");

    let symbols = vec![
        Symbol {
            kind: SymbolKind::Function,
            name: "test_func".to_string(),
            signature: "fn test_func()".to_string(),
            doc: Some("Test function".to_string()),
            line: 1,
        },
    ];

    let file_summary = FileSummary {
        path: PathBuf::from("test.rs"),
        language: codebase_summarizer::models::Language::Rust,
        symbols,
    };

    let summary = CodebaseSummary::new(temp_dir.path().to_path_buf());
    let mut summary = summary;
    summary.add_file(file_summary);

    let writer = MarkdownWriter::new();
    writer.write_summary(&summary, &output_path).unwrap();

    assert!(output_path.exists());
    let content = std::fs::read_to_string(&output_path).unwrap();
    assert!(content.contains("test_func"));
}

#[test]
fn test_language_from_extension() {
    use codebase_summarizer::models::Language;

    assert_eq!(Language::from_extension("go"), Language::Go);
    assert_eq!(Language::from_extension("rs"), Language::Rust);
    assert_eq!(Language::from_extension("py"), Language::Python);
    assert_eq!(Language::from_extension("dart"), Language::Dart);
    assert_eq!(Language::from_extension("ts"), Language::TypeScript);
    assert_eq!(Language::from_extension("r"), Language::R);
    assert_eq!(Language::from_extension("R"), Language::R);
    assert_eq!(Language::from_extension("java"), Language::Java);
    assert_eq!(Language::from_extension("c"), Language::C);
    assert_eq!(Language::from_extension("cpp"), Language::Cpp);
    assert_eq!(Language::from_extension("rb"), Language::Ruby);
    assert_eq!(Language::from_extension("php"), Language::Php);
    assert_eq!(Language::from_extension("swift"), Language::Swift);
    assert_eq!(Language::from_extension("kt"), Language::Kotlin);
    assert_eq!(Language::from_extension("unknown"), Language::Unknown);
}