"""JSON-based subtitle repository implementation."""
from typing import List, Optional, Dict, Any
import logging

from domain.subtitles.repositories import SubtitleRepository
from domain.subtitles.entities import Subtitle
from domain.subtitles.value_objects import Language, SubtitleFormat, TimingOffset
from domain.shared.value_objects import ImdbId, FilePath
from ..memory import Memory

logger = logging.getLogger(__name__)


class JsonSubtitleRepository(SubtitleRepository):
    """
    JSON-based implementation of SubtitleRepository.
    
    Stores subtitles in the memory.json file.
    """
    
    def __init__(self, memory: Memory):
        """
        Initialize repository.
        
        Args:
            memory: Memory instance for persistence
        """
        self.memory = memory
    
    def save(self, subtitle: Subtitle) -> None:
        """Save a subtitle to the repository."""
        subtitles = self._load_all()
        
        # Add new subtitle (we allow multiple subtitles for same media)
        subtitles.append(self._to_dict(subtitle))
        
        # Save to memory
        self.memory.set('subtitles', subtitles)
        logger.debug(f"Saved subtitle for: {subtitle.media_imdb_id}")
    
    def find_by_media(
        self,
        media_imdb_id: ImdbId,
        language: Optional[Language] = None,
        season: Optional[int] = None,
        episode: Optional[int] = None
    ) -> List[Subtitle]:
        """Find subtitles for a media item."""
        subtitles = self._load_all()
        results = []
        
        for sub_dict in subtitles:
            # Filter by IMDb ID
            if sub_dict.get('media_imdb_id') != str(media_imdb_id):
                continue
            
            # Filter by language if specified
            if language and sub_dict.get('language') != language.value:
                continue
            
            # Filter by season/episode if specified
            if season is not None and sub_dict.get('season_number') != season:
                continue
            if episode is not None and sub_dict.get('episode_number') != episode:
                continue
            
            results.append(self._from_dict(sub_dict))
        
        return results
    
    def delete(self, subtitle: Subtitle) -> bool:
        """Delete a subtitle from the repository."""
        subtitles = self._load_all()
        initial_count = len(subtitles)
        
        # Filter out the subtitle (match by file path)
        subtitles = [
            s for s in subtitles 
            if s.get('file_path') != str(subtitle.file_path)
        ]
        
        if len(subtitles) < initial_count:
            self.memory.set('subtitles', subtitles)
            logger.debug(f"Deleted subtitle: {subtitle.file_path}")
            return True
        
        return False
    
    def _load_all(self) -> List[Dict[str, Any]]:
        """Load all subtitles from memory."""
        return self.memory.get('subtitles', [])
    
    def _to_dict(self, subtitle: Subtitle) -> Dict[str, Any]:
        """Convert Subtitle entity to dict for storage."""
        return {
            'media_imdb_id': str(subtitle.media_imdb_id),
            'language': subtitle.language.value,
            'format': subtitle.format.value,
            'file_path': str(subtitle.file_path),
            'season_number': subtitle.season_number,
            'episode_number': subtitle.episode_number,
            'timing_offset': subtitle.timing_offset.milliseconds,
            'hearing_impaired': subtitle.hearing_impaired,
            'forced': subtitle.forced,
            'source': subtitle.source,
            'uploader': subtitle.uploader,
            'download_count': subtitle.download_count,
            'rating': subtitle.rating,
        }
    
    def _from_dict(self, data: Dict[str, Any]) -> Subtitle:
        """Convert dict from storage to Subtitle entity."""
        return Subtitle(
            media_imdb_id=ImdbId(data['media_imdb_id']),
            language=Language.from_code(data['language']),
            format=SubtitleFormat.from_extension(data['format']),
            file_path=FilePath(data['file_path']),
            season_number=data.get('season_number'),
            episode_number=data.get('episode_number'),
            timing_offset=TimingOffset(data.get('timing_offset', 0)),
            hearing_impaired=data.get('hearing_impaired', False),
            forced=data.get('forced', False),
            source=data.get('source'),
            uploader=data.get('uploader'),
            download_count=data.get('download_count'),
            rating=data.get('rating'),
        )