use anagram_generator::{
    analyzer::PronounceabilityAnalyzer, generator::AnagramGenerator, generator::GenerationConfig,
    scorer::PronounceabilityScorer,
};
use rand::thread_rng;

#[test]
fn test_end_to_end_anagram_generation() {
    let rng = thread_rng();
    let scorer = PronounceabilityAnalyzer::with_defaults();
    let mut generator = AnagramGenerator::new(rng, scorer);

    let config = GenerationConfig::new(50, 1000);
    let anagrams = generator.generate("example", 5, &config);

    assert!(!anagrams.is_empty());
    assert!(anagrams.len() <= 5);

    for anagram in &anagrams {
        assert!(anagram.score().value() >= 50);
        assert_eq!(anagram.text().len(), "example".len());
    }
}

#[test]
fn test_high_quality_anagrams_only() {
    let rng = thread_rng();
    let scorer = PronounceabilityAnalyzer::with_defaults();
    let mut generator = AnagramGenerator::new(rng, scorer);

    let config = GenerationConfig::new(80, 5000);
    let anagrams = generator.generate("lawrence", 10, &config);

    for anagram in &anagrams {
        assert!(anagram.score().value() >= 80);
    }
}

#[test]
fn test_generation_with_difficult_word() {
    let rng = thread_rng();
    let scorer = PronounceabilityAnalyzer::with_defaults();
    let mut generator = AnagramGenerator::new(rng, scorer);

    // A word with few vowels is harder to generate pronounceable anagrams from
    let config = GenerationConfig::new(30, 5000);
    let anagrams = generator.generate("rhythm", 3, &config);

    // Should still be able to generate some anagrams
    assert!(!anagrams.is_empty());
}

#[test]
fn test_customizable_scoring_via_trait() {
    // Test that we can use the trait abstraction
    struct SimpleScorer;

    impl PronounceabilityScorer for SimpleScorer {
        fn score(&self, text: &str) -> anagram_generator::PronouncabilityScore {
            // Simple scorer: just count vowels
            let vowel_count = text
                .chars()
                .filter(|c| matches!(c, 'a' | 'e' | 'i' | 'o' | 'u'))
                .count();
            anagram_generator::PronouncabilityScore::new((vowel_count * 20) as u32)
        }
    }

    let rng = thread_rng();
    let scorer = SimpleScorer;
    let mut generator = AnagramGenerator::new(rng, scorer);

    let config = GenerationConfig::new(0, 100);
    let anagrams = generator.generate("aeiou", 5, &config);

    assert!(!anagrams.is_empty());
}

#[test]
fn test_analyzer_with_custom_configuration() {
    use anagram_generator::scorer::{
        CharacterClassifier, ConsonantClusterRules, PatternAnalysisConfig, ScoringPenalties,
    };

    let classifier = CharacterClassifier::default_french();
    let cluster_rules = ConsonantClusterRules::default_french();
    let penalties = ScoringPenalties::default();
    let config = PatternAnalysisConfig::default();

    let analyzer = PronounceabilityAnalyzer::new(classifier, cluster_rules, penalties, config);

    let score = analyzer.score("hello");
    assert!(score.value() > 0);
}

#[test]
fn test_generation_config_builder_pattern() {
    let config = GenerationConfig::default()
        .with_min_score(70)
        .with_max_attempts(3000);

    assert_eq!(config.min_score.value(), 70);
    assert_eq!(config.max_attempts_per_anagram, 3000);

    let rng = thread_rng();
    let scorer = PronounceabilityAnalyzer::with_defaults();
    let mut generator = AnagramGenerator::new(rng, scorer);

    let anagrams = generator.generate("test", 5, &config);
    for anagram in &anagrams {
        assert!(anagram.score().value() >= 70);
    }
}