import hashlib

def get_bucket(flag_key: str, bucket_by_value: str) -> float:
    """Returns a float in [0, 1) for consistent bucketing."""
    hash_input = f"{flag_key}:{bucket_by_value}".encode("utf-8")
    hash_bytes = hashlib.md5(hash_input).digest()
    # Use first 4 bytes as an unsigned int
    bucket_int = int.from_bytes(hash_bytes[:4], byteorder='big')
    return bucket_int / (2**32)

def evaluate_percentage_rule(
    flag_key: str,
    context: EvaluationContext,
    rule: EvaluationRule
) -> bool:
    bucket_value = getattr(context, rule.bucket_by, context.user_id)
    bucket = get_bucket(flag_key, str(bucket_value))
    return bucket < (rule.percentage / 100.0)

def evaluate_flag(flag: FeatureFlag, context: EvaluationContext) -> FlagValue:
    # Check for forced override (QA/debugging)
    if context.forced_variations and flag.key in context.forced_variations:
        return context.forced_variations[flag.key]
    
    # Evaluate rules in order
    for rule in flag.rules:
        if all(evaluate_condition(c, context) for c in rule.conditions):
            if rule.percentage is None:
                return rule.variation
            
            bucket_by = getattr(context, rule.bucket_by or 'user_id', context.user_id)
            bucket = get_bucket(flag.key, str(bucket_by))
            
            if bucket < rule.percentage / 100.0:
                return rule.variation
    
    return flag.default_value

def evaluate_condition(condition: Condition, context: EvaluationContext) -> bool:
    attribute_value = resolve_attribute(context, condition.attribute)
    
    match condition.operator:
        case "equals":
            return attribute_value == condition.value
        case "in":
            return attribute_value in condition.value
        case "not_in":
            return attribute_value not in condition.value
        case "contains":
            return condition.value in str(attribute_value)
        case "semver_gte":
            return semver_compare(attribute_value, condition.value) >= 0
        case "before":
            return parse_date(attribute_value) < parse_date(condition.value)
        _:
            return False

class FlagEvaluator:
    def __init__(self, remote_source: FlagSource):
        self._remote = remote_source
        self._cache: dict[str, FeatureFlag] = {}
        self._last_sync: float = 0
        self._sync_interval = 30.0  # seconds
    
    def evaluate(self, flag_key: str, context: EvaluationContext) -> FlagValue:
        flag = self._cache.get(flag_key)
        
        if flag is None:
            # Unknown flag — return safe default, never raise
            logger.warning(f"Unknown flag: {flag_key}")
            return False
        
        try:
            return evaluate_flag(flag, context)
        except Exception as e:
            # Evaluation error — fall back to default, never propagate
            logger.error(f"Flag evaluation error for {flag_key}: {e}")
            return flag.default_value
    
    async def sync(self):
        """Called by background thread; failures don't affect evaluation."""
        try:
            flags = await self._remote.fetch_all()
            self._cache = {f.key: f for f in flags}
            self._last_sync = time.time()
        except Exception as e:
            logger.error(f"Flag sync failed: {e}")
            # Keep stale cache — degraded but functional

def evaluate_with_tracking(
    flag_key: str,
    context: EvaluationContext
) -> FlagValue:
    result = self.evaluate(flag_key, context)
    
    # Emit to metrics/analytics
    metrics.increment(
        "feature_flag.evaluation",
        tags={
            "flag_key": flag_key,
            "variation": str(result),
            "user_plan": context.user_attributes.get("plan", "unknown"),
        }
    )
    
    return result

def check_stale_flags():
    for flag in flag_store.all():
        if flag.expires_at and flag.expires_at < datetime.now():
            notify_owner(
                flag.owner,
                f"Flag '{flag.key}' expired {flag.expires_at}. "
                f"Please remove it: {flag.cleanup_ticket}"
            )

def get_recommendations(user_id: str) -> list[Product]:
    if not flags.evaluate("recs_service_enabled", context):
        # Graceful degradation: return popular items
        return product_store.get_popular(limit=10)
    
    try:
        return recommendations_service.get(user_id)
    except ServiceUnavailableError:
        return product_store.get_popular(limit=10)