"""User simulator for evaluation."""

import logging
from typing import Dict, List, Set, Any

logger = logging.getLogger(__name__)


class UserSimulator:
    """Simulates a user with predefined preferences."""

    def __init__(
        self,
        liked_features: Set[str],
        disliked_features: Set[str] | None = None
    ):
        """Initialize user simulator.
        
        Args:
            liked_features: Set of feature types the user likes
            disliked_features: Set of feature types the user dislikes (optional)
        """
        self.liked = liked_features
        self.disliked = disliked_features or set()
        logger.info(f"UserSimulator initialized: liked={self.liked}, disliked={self.disliked}")

    def label_pattern(self, pattern: Dict[str, Any]) -> int:
        """Label a pattern based on ground truth preferences.
        
        A pattern is liked iff:
        - contains at least one liked feature
        - does not contain any disliked feature
        
        If a pattern does not contain any liked feature, it is marked as not interested (0).
        
        Args:
            pattern: Pattern dictionary with 'pattern' key containing list of features
            
        Returns:
            1 if pattern is liked, 0 if not interested or disliked
        """
        pattern_features = pattern.get('pattern', [])
        if isinstance(pattern_features, str):
            pattern_features = pattern_features.split(',')
        
        # Check if pattern contains any liked feature
        has_liked = any(feature in self.liked for feature in pattern_features)
        
        # If no liked features, mark as not interested
        if not has_liked:
            return 0
        
        # Check if pattern contains any disliked feature
        has_disliked = any(feature in self.disliked for feature in pattern_features)
        
        # Pattern is liked if it has liked features and no disliked features
        label = 1 if (has_liked and not has_disliked) else 0
        return label

    def build_ground_truth(self, patterns: List[Dict[str, Any]]) -> Dict[int, int]:
        """Build ground truth labels for all patterns.
        
        Args:
            patterns: List of pattern dictionaries
            
        Returns:
            Dictionary mapping pattern index to label (0 or 1)
        """
        ground_truth = {}
        for idx, pattern in enumerate(patterns):
            ground_truth[idx] = self.label_pattern(pattern)
        
        liked_count = sum(1 for v in ground_truth.values() if v == 1)
        logger.info(f"Built ground truth: {liked_count}/{len(patterns)} patterns liked")
        return ground_truth