Rules Engine

class RulesCoordinator:
    """
    🎯 Coordenador Central de Regras
    
    Responsibilities:
    1. Proxy inteligente para Rules Engine com <50ms target
    2. Cache Redis para performance otimizada
    3. Integração com Memory Coordinator para contexto enriquecido
    4. Fallback quando Rules Engine falha
    5. Circuit breaker para proteção contra falhas
    """

    async def evaluate_rules_for_conversation(
        self,
        tenant_id: str,
        conversation_data: dict,
        message_content: str,
        memory_context: dict | None = None,
    ) -> dict:
        
        # 1. 🧠 Enriquecer dados com Memory Coordinator
        enriched_facts = await self._enrich_with_memory_context(
            tenant_id, conversation_data, message_content, memory_context
        )

        # 2. 🎯 Tentar Rules Engine (primary)
        try:
            async with circuit_breaker_context("rules_engine_evaluate"):
                response = await self.rules_client.post(
                    "/api/evaluation/evaluate",
                    json={
                        "tenant_id": tenant_id,
                        "event_type": "message_received",
                        "facts": enriched_facts,
                    }
                )
                
                if response.status_code == 200:
                    result = response.json()
                    # Cache para reuso futuro
                    await self._cache_evaluation_result(tenant_id, enriched_facts, result)
                    return result

        except Exception as e:
            logger.warning(f"Rules Engine failed: {e}")

        # 3. 🔄 Fallback para Redis cache
        cache_result = await self._evaluate_via_redis_cache(tenant_id, enriched_facts)
        if cache_result:
            return cache_result

        # 4. 🚨 Basic fallback (keyword-based, nunca falha)
        return await self._evaluate_basic_fallback(tenant_id, enriched_facts)

def _extract_intelligent_patterns(self, memory_context: dict) -> dict:
    """
    Extrai padrões inteligentes do contexto de memória para regras mais sofisticadas
    """
    patterns = {
        "interaction_frequency": "new",      # new | regular | frequent
        "customer_urgency_level": "normal",  # normal | high
        "preferred_communication_style": "formal",
        "likely_appointment_need": False,
        "pain_indicators": False,
        "satisfaction_level": "neutral",
    }

    context_content = memory_context.get("context", "").lower()
    memory_items = memory_context.get("memory_items", [])

    # Detecta urgência (dor, emergência, sangramento)
    if any(word in context_content for word in ["pain", "urgent", "emergency"]):
        patterns["customer_urgency_level"] = "high"
        patterns["pain_indicators"] = True

    # Detecta necessidade de agendamento
    if any(word in context_content for word in ["schedule", "appointment", "book"]):
        patterns["likely_appointment_need"] = True

    # Analisa frequência de interação
    if len(memory_items) > 5:
        patterns["interaction_frequency"] = "frequent"
    elif len(memory_items) > 2:
        patterns["interaction_frequency"] = "regular"

    return patterns

# Resultado: regras podem usar facts enriquecidos
# facts = {
#     "message_content": "I have tooth pain",
#     "customer_urgency_level": "high",
#     "pain_indicators": True,
#     "interaction_frequency": "regular",
#     "has_previous_appointments": True
# }