"""Property-based tests for the analysis engine.

Tests universal correctness properties using Hypothesis with minimum 100 iterations.
Each test validates a specific property from the design document.
"""

import pytest
from pathlib import Path
from datetime import datetime, timezone
from hypothesis import given, strategies as st, settings
from vlm.models import (
    SeriesIdentity, SeasonCompleteness, MovieIdentity, VideoFile, DuplicateGroup
)
from vlm.analysis import analyze_series_completeness, detect_duplicates, compare_quality
from vlm.reports import (
    generate_completeness_report, generate_duplicate_report, generate_summary_report
)


# Custom strategies for generating test data

@st.composite
def series_identity_strategy(draw, title=None, season=None):
    """Generate a SeriesIdentity with optional fixed title and season."""
    if title is None:
        title = draw(st.text(min_size=1, max_size=50, alphabet=st.characters(
            whitelist_categories=('Lu', 'Ll', 'Nd'), whitelist_characters=' '
        )))
    
    if season is None:
        season = draw(st.integers(min_value=1, max_value=20))
    
    # Generate 1-3 episode numbers
    episode_count = draw(st.integers(min_value=1, max_value=3))
    episodes = draw(st.lists(
        st.integers(min_value=1, max_value=50),
        min_size=episode_count,
        max_size=episode_count,
        unique=True
    ))
    
    confidence = draw(st.floats(min_value=0.5, max_value=1.0))
    needs_review = False
    original_filename = f"{title.replace(' ', '.')}.S{season:02d}E{episodes[0]:02d}.mkv"
    
    return SeriesIdentity(title, season, sorted(episodes), confidence, needs_review, original_filename)


@st.composite
def movie_identity_strategy(draw, title=None, year=None):
    """Generate a MovieIdentity with optional fixed title and year."""
    if title is None:
        title = draw(st.text(min_size=1, max_size=50, alphabet=st.characters(
            whitelist_categories=('Lu', 'Ll', 'Nd'), whitelist_characters=' '
        )))
    
    if year is None:
        year = draw(st.integers(min_value=1900, max_value=2030))
    
    confidence = draw(st.floats(min_value=0.5, max_value=1.0))
    needs_review = False
    original_filename = f"{title.replace(' ', '.')}.{year}.mkv"
    
    return MovieIdentity(title, year, confidence, needs_review, original_filename)


@st.composite
def video_file_strategy(draw, filename=None, category="movie"):
    """Generate a VideoFile with optional fixed filename."""
    if filename is None:
        filename = draw(st.text(min_size=5, max_size=50, alphabet=st.characters(
            whitelist_categories=('Lu', 'Ll', 'Nd'), whitelist_characters='.-_'
        ))) + ".mkv"
    
    path = Path(f"/{category}/{filename}")
    size_bytes = draw(st.integers(min_value=1000000, max_value=10000000000))
    modified_timestamp = datetime.now(timezone.utc)
    
    # Optional metadata
    has_metadata = draw(st.booleans())
    if has_metadata:
        resolution = draw(st.sampled_from(["1920x1080", "1280x720", "3840x2160", "720x480"]))
        codec = draw(st.sampled_from(["h264", "h265", "vp9", "av1"]))
        duration_seconds = draw(st.floats(min_value=300, max_value=10800))
        bitrate_kbps = draw(st.integers(min_value=500, max_value=20000))
        return VideoFile(path, filename, size_bytes, modified_timestamp, category,
                        resolution, codec, duration_seconds, bitrate_kbps)
    else:
        return VideoFile(path, filename, size_bytes, modified_timestamp, category)


# Property 10: Gap detection
# Feature: video-library-manager, Property 10: Gap detection
@settings(max_examples=100)
@given(
    title=st.text(min_size=1, max_size=30, alphabet=st.characters(
        whitelist_categories=('Lu', 'Ll'), whitelist_characters=' '
    )),
    season=st.integers(min_value=1, max_value=10),
    # Generate a list of episode numbers with guaranteed gaps
    episodes_data=st.lists(
        st.integers(min_value=1, max_value=30),
        min_size=3,
        max_size=15,
        unique=True
    )
)
def test_property_10_gap_detection(title, season, episodes_data):
    """Property 10: For any set of episodes within season, analysis SHALL detect
    missing episode numbers in range [min, max].
    
    Validates: Requirements 4.1, 4.2
    """
    # Sort episodes and ensure there's at least one gap
    sorted_episodes = sorted(episodes_data)
    
    # Create episodes, intentionally removing one to create a gap
    if len(sorted_episodes) >= 3:
        # Remove a middle episode to guarantee a gap
        gap_index = len(sorted_episodes) // 2
        removed_episode = sorted_episodes[gap_index]
        episodes_with_gap = sorted_episodes[:gap_index] + sorted_episodes[gap_index + 1:]
        
        # Create SeriesIdentity objects
        episode_identities = [
            SeriesIdentity(title, season, [ep], 0.9, False, f"{title}.S{season:02d}E{ep:02d}.mkv")
            for ep in episodes_with_gap
        ]
        
        # Analyze completeness
        result = analyze_series_completeness(episode_identities)
        
        # Should detect the gap
        if len(result) > 0:
            assert result[0].series_title == title
            assert result[0].season == season
            
            # The missing episode should be in the detected gaps
            min_ep = min(episodes_with_gap)
            max_ep = max(episodes_with_gap)
            expected_missing = set(range(min_ep, max_ep + 1)) - set(episodes_with_gap)
            
            assert set(result[0].episodes_missing) == expected_missing
            assert removed_episode in result[0].episodes_missing


# Property 11: Multi-season independence
# Feature: video-library-manager, Property 11: Multi-season independence
@settings(max_examples=100)
@given(
    title=st.text(min_size=1, max_size=30, alphabet=st.characters(
        whitelist_categories=('Lu', 'Ll'), whitelist_characters=' '
    )),
    season1_episodes=st.lists(st.integers(min_value=1, max_value=20), min_size=2, max_size=10, unique=True),
    season2_episodes=st.lists(st.integers(min_value=1, max_value=20), min_size=2, max_size=10, unique=True),
)
def test_property_11_multi_season_independence(title, season1_episodes, season2_episodes):
    """Property 11: For any series with multiple seasons, gap detection of one
    season SHALL not affect others.
    
    Validates: Requirements 4.4
    """
    # Create episodes for season 1 with a gap
    s1_sorted = sorted(season1_episodes)
    if len(s1_sorted) >= 3:
        gap_index = len(s1_sorted) // 2
        s1_with_gap = s1_sorted[:gap_index] + s1_sorted[gap_index + 1:]
        s1_missing = s1_sorted[gap_index]
    else:
        s1_with_gap = s1_sorted
        s1_missing = None
    
    # Create episodes for season 2 (complete, no gaps)
    s2_sorted = sorted(season2_episodes)
    s2_complete = list(range(min(s2_sorted), max(s2_sorted) + 1))
    
    # Create SeriesIdentity objects
    episode_identities = []
    for ep in s1_with_gap:
        episode_identities.append(
            SeriesIdentity(title, 1, [ep], 0.9, False, f"{title}.S01E{ep:02d}.mkv")
        )
    for ep in s2_complete:
        episode_identities.append(
            SeriesIdentity(title, 2, [ep], 0.9, False, f"{title}.S02E{ep:02d}.mkv")
        )
    
    # Analyze completeness
    result = analyze_series_completeness(episode_identities)
    
    # Season 2 should not appear in results (it's complete)
    season2_results = [r for r in result if r.season == 2]
    assert len(season2_results) == 0
    
    # Season 1 should appear if there's a gap
    if s1_missing is not None:
        season1_results = [r for r in result if r.season == 1]
        if len(season1_results) > 0:
            assert s1_missing in season1_results[0].episodes_missing


# Property 12: Duplicate detection for movies
# Feature: video-library-manager, Property 12: Duplicate detection for movies
@settings(max_examples=100)
@given(
    title=st.text(min_size=1, max_size=30, alphabet=st.characters(
        whitelist_categories=('Lu', 'Ll'), whitelist_characters=' '
    )),
    year=st.integers(min_value=1900, max_value=2030),
    duplicate_count=st.integers(min_value=2, max_value=5)
)
def test_property_12_duplicate_detection_movies(title, year, duplicate_count):
    """Property 12: For any set of movies with identical normalized titles and years,
    all SHALL be grouped as duplicates.
    
    Validates: Requirements 5.1
    """
    # Create multiple movie identities with same title and year
    identities = []
    files = []
    
    for i in range(duplicate_count):
        filename = f"{title.replace(' ', '.')}.{year}.{i}.mkv"
        identities.append(MovieIdentity(title, year, 0.9, False, filename))
        files.append(VideoFile(
            Path(f"/movies/{filename}"),
            filename,
            1000000000 + i * 100000000,
            datetime.now(timezone.utc),
            "movie"
        ))
    
    # Detect duplicates
    result = detect_duplicates(list(zip(identities, files)))
    
    # Should find exactly one duplicate group
    assert len(result) == 1
    
    # The group should contain all files
    assert len(result[0].files) == duplicate_count
    
    # Identity should match
    assert result[0].identity.title == title
    assert result[0].identity.year == year


# Property 13: Duplicate detection for series
# Feature: video-library-manager, Property 13: Duplicate detection for series
@settings(max_examples=100)
@given(
    title=st.text(min_size=1, max_size=30, alphabet=st.characters(
        whitelist_categories=('Lu', 'Ll'), whitelist_characters=' '
    )),
    season=st.integers(min_value=1, max_value=10),
    episode=st.integers(min_value=1, max_value=30),
    duplicate_count=st.integers(min_value=2, max_value=5)
)
def test_property_13_duplicate_detection_series(title, season, episode, duplicate_count):
    """Property 13: For any set of series files with identical normalized titles,
    seasons, and episodes, all SHALL be grouped as duplicates.
    
    Validates: Requirements 5.2
    """
    # Create multiple series identities with same title, season, and episode
    identities = []
    files = []
    
    for i in range(duplicate_count):
        filename = f"{title.replace(' ', '.')}.S{season:02d}E{episode:02d}.{i}.mkv"
        identities.append(SeriesIdentity(title, season, [episode], 0.9, False, filename))
        files.append(VideoFile(
            Path(f"/series/{filename}"),
            filename,
            1000000000 + i * 100000000,
            datetime.now(timezone.utc),
            "series"
        ))
    
    # Detect duplicates
    result = detect_duplicates(list(zip(identities, files)))
    
    # Should find exactly one duplicate group
    assert len(result) == 1
    
    # The group should contain all files
    assert len(result[0].files) == duplicate_count
    
    # Identity should match
    assert result[0].identity.title == title
    assert result[0].identity.season == season
    assert episode in result[0].identity.episodes


# Property 14: Duplicate quality comparison
# Feature: video-library-manager, Property 14: Duplicate quality comparison
@settings(max_examples=100)
@given(
    title=st.text(min_size=1, max_size=30, alphabet=st.characters(
        whitelist_categories=('Lu', 'Ll'), whitelist_characters=' '
    )),
    year=st.integers(min_value=1900, max_value=2030),
    file_count=st.integers(min_value=2, max_value=4)
)
def test_property_14_duplicate_quality_comparison(title, year, file_count):
    """Property 14: For any duplicate group, comparison data SHALL include
    available metadata for each file.
    
    Validates: Requirements 5.3
    """
    # Create movie identities and files with varying metadata
    identities = []
    files = []
    
    for i in range(file_count):
        filename = f"{title.replace(' ', '.')}.{year}.{i}.mkv"
        identities.append(MovieIdentity(title, year, 0.9, False, filename))
        
        # Some files have full metadata, some don't
        if i % 2 == 0:
            files.append(VideoFile(
                Path(f"/movies/{filename}"),
                filename,
                1000000000 + i * 100000000,
                datetime.now(timezone.utc),
                "movie",
                resolution="1920x1080",
                codec="h264",
                duration_seconds=7200.0,
                bitrate_kbps=5000
            ))
        else:
            files.append(VideoFile(
                Path(f"/movies/{filename}"),
                filename,
                1000000000 + i * 100000000,
                datetime.now(timezone.utc),
                "movie"
            ))
    
    # Detect duplicates
    result = detect_duplicates(list(zip(identities, files)))
    
    # Should have quality comparison data
    assert len(result) == 1
    assert len(result[0].quality_comparison) == file_count
    
    # Each comparison entry should have at least filename and size
    for comparison in result[0].quality_comparison:
        assert 'filename' in comparison
        assert 'size_bytes' in comparison
        assert 'path' in comparison
        
        # Files with metadata should have those fields
        if comparison['filename'].endswith('.0.mkv') or comparison['filename'].endswith('.2.mkv'):
            assert 'resolution' in comparison
            assert 'codec' in comparison
            assert 'duration_seconds' in comparison
            assert 'bitrate_kbps' in comparison


# Property 42: Completeness report
# Feature: video-library-manager, Property 42: Completeness report
@settings(max_examples=100)
@given(
    series_count=st.integers(min_value=1, max_value=5),
    format=st.sampled_from(["text", "json"])
)
def test_property_42_completeness_report(series_count, format):
    """Property 42: For any set of analyzed series, completeness report SHALL
    include all series with detected gaps.
    
    Validates: Requirements 11.2
    """
    # Create series with gaps
    analysis_results = []
    
    for i in range(series_count):
        title = f"Series {i}"
        season = 1
        episodes_found = [1, 2, 4, 5]  # Gap at episode 3
        episodes_missing = [3]
        
        analysis_results.append(SeasonCompleteness(
            series_title=title,
            season=season,
            episodes_found=episodes_found,
            episodes_missing=episodes_missing
        ))
    
    # Generate report
    library_root = Path("/test/library")
    report = generate_completeness_report(analysis_results, format, library_root)
    
    # Report should include all series
    for i in range(series_count):
        assert f"Series {i}" in report
    
    # Report should include metadata
    assert str(library_root) in report


# Property 43: Duplicate report grouping
# Feature: video-library-manager, Property 43: Duplicate report grouping
@settings(max_examples=100)
@given(
    duplicate_count=st.integers(min_value=1, max_value=5),
    format=st.sampled_from(["text", "json"])
)
def test_property_43_duplicate_report_grouping(duplicate_count, format):
    """Property 43: For any set of detected duplicates, duplicate report SHALL
    group files by identity with comparison data.
    
    Validates: Requirements 11.3
    """
    # Create duplicate groups
    duplicate_groups = []
    
    for i in range(duplicate_count):
        title = f"Movie {i}"
        year = 2020 + i
        
        # Create 2 files for each duplicate group
        files = []
        quality_comparison = []
        
        for j in range(2):
            filename = f"{title.replace(' ', '.')}.{year}.{j}.mkv"
            file = VideoFile(
                Path(f"/movies/{filename}"),
                filename,
                1000000000 + j * 500000000,
                datetime.now(timezone.utc),
                "movie",
                resolution="1920x1080" if j == 0 else "1280x720",
                codec="h264"
            )
            files.append(file)
            quality_comparison.append({
                'filename': filename,
                'path': str(file.path),
                'size_bytes': file.size_bytes,
                'resolution': file.resolution,
                'codec': file.codec
            })
        
        identity = MovieIdentity(title, year, 0.9, False, files[0].filename)
        duplicate_groups.append(DuplicateGroup(identity, files, quality_comparison))
    
    # Generate report
    library_root = Path("/test/library")
    report = generate_duplicate_report(duplicate_groups, format, library_root)
    
    # Report should include all duplicate groups
    for i in range(duplicate_count):
        assert f"Movie {i}" in report
    
    # Report should include comparison data (file sizes, resolutions)
    assert "1920x1080" in report or "resolution" in report.lower()
    
    # Report should include metadata
    assert str(library_root) in report


# Property 44: Summary report accuracy
# Feature: video-library-manager, Property 44: Summary report accuracy
@settings(max_examples=100)
@given(
    file_count=st.integers(min_value=1, max_value=20),
    categories=st.lists(
        st.sampled_from(["movie", "series", "anime", "other"]),
        min_size=1,
        max_size=4
    )
)
def test_property_44_summary_report_accuracy(file_count, categories):
    """Property 44: For any scanned library, summary report SHALL contain
    accurate counts and sizes.
    
    Validates: Requirements 11.4
    """
    # Create video files
    files = []
    total_size = 0
    category_counts = {}
    
    for i in range(file_count):
        category = categories[i % len(categories)]
        size = 1000000000 + i * 100000000
        filename = f"file_{i}.mkv"
        
        files.append(VideoFile(
            Path(f"/{category}/{filename}"),
            filename,
            size,
            datetime.now(timezone.utc),
            category
        ))
        
        total_size += size
        category_counts[category] = category_counts.get(category, 0) + 1
    
    # Generate summary report
    library_root = Path("/test/library")
    report = generate_summary_report(files, library_root)
    
    # Report should include total file count
    assert f"Total Files: {file_count}" in report
    
    # Report should include category breakdown
    for category, count in category_counts.items():
        assert category.capitalize() in report
        assert f"Files: {count}" in report
    
    # Report should include metadata
    assert str(library_root) in report