# Ключевые отличия Enterprise AI-агентов от стартап-решений:
# 1. Данные не покидают периметр компании (VPC / on-premise)
# 2. Полный аудит каждого действия агента (immutable log)
# 3. SOC2 / GDPR / PCI-DSS / ФЗ-152 compliance
# 4. Role-Based Access Control (RBAC) + SSO интеграция
# 5. Горизонтальное масштабирование на тысячи параллельных сессий
# 6. Disaster recovery и 99.95% SLA

# ============= ENTERPRISE AGENT ARCHITECTURE =============
# Layer 0 (ядро):     LLM Inference Engine (vLLM / TGI on-premise)
# Layer 1 (обвязка):   Agent Runtime (LangGraph / custom orchestrator)
# Layer 2 (безопасность): Input/Output Guardrails + PII Detection
# Layer 3 (аудит):      Immutable Audit Trail (hash chain)
# Layer 4 (доступ):     RBAC + Policy Engine (Open Policy Agent)
# Layer 5 (трафик):     API Gateway (rate limiting, auth, routing)
# Layer 6 (наблюдение): Metrics, Tracing, Alerting (Prometheus/Grafana)

from dataclasses import dataclass
from typing import Any, Optional
import hashlib, json, time
from enum import Enum

class AgentAction(Enum):
    THINK      = "think"
    TOOL_CALL  = "tool_call"
    RESPOND    = "respond"
    DELEGATE   = "delegate"

@dataclass
class EnterpriseConfig:
    """Конфигурация enterprise-агента."""
    llm_endpoint: str                     # Internal vLLM/TGI endpoint
    llm_model: str                       # e.g. 'meta-llama-3.1-70b'
    auth_provider: str = "keycloak"  # Identity provider
    pii_enabled: bool = True             # Детекция персональных данных
    audit_enabled: bool = True           # Аудит каждого действия
    rate_limit_per_user: int = 30       # Запросов в минуту на пользователя
    max_concurrent_sessions: int = 1000 # Максимум параллельных сессий
    data_residency: str = "eu-west-1" # Регион хранения данных

import re
from presidio_analyzer import AnalyzerEngine
from presidio_anonymizer import AnonymizerEngine
from presidio_anonymizer.entities import OperatorConfig

class EnterprisePIIGuard:
    """GDPR/ФЗ-152 PII фильтр для AI-агента."""

    # Категории PII для enterprise
    PII_ENTITIES = [
        "PERSON", "EMAIL_ADDRESS", "PHONE_NUMBER",
        "CREDIT_CARD", "IBAN_CODE", "PASSPORT_NUMBER",
        "RUSSIAN_PASSPORT_NUMBER", "INN", "SNILS",
        "IP_ADDRESS", "LOCATION", "DATE_OF_BIRTH",
    ]

    def __init__(self):
        self.analyzer = AnalyzerEngine()
        self.anonymizer = AnonymizerEngine()
        # Дополнительные regex-паттерны для РФ
        self.patterns_ru = {
            "inn": r'\b\d{10}(?:\d{2})?\b',
            "snils": r'\b\d{3}[-]\d{3}[-]\d{3}\s?\d{2}\b',
            "passport_ru": r'\b\d{2}\s?\d{2}\s?\d{6}\b',
            "credit_card": r'\b(?:\d{4}[\s-]?){3}\d{4}\b',
        }

    def anonymize(self, text: str) -> (str, dict):
        """Замена PII на псевдонимы перед отправкой в LLM."""
        # 1. Presidio анализ
        results = self.analyzer.analyze(
            text=text,
            entities=self.PII_ENTITIES,
            language="ru"
        )
        # 2. Presidio анонимизация
        anonymized = self.anonymizer.anonymize(
            text=text,
            analyzer_results=results,
            operators={"DEFAULT": OperatorConfig("replace", {"new_value": ""})}
        )
        return anonymized.text, anonymized.items

    def block_sensitive(self, text: str) -> bool:
        """Блокировать запрос, если содержит критически чувствительные данные."""
        for name, pattern in self.patterns_ru.items():
            if re.search(pattern, text):
                return True  # Критические данные — блокируем
        return False

# Тест
guard = EnterprisePIIGuard()
text_with_pii = "Клиент Иванов Иван, паспорт 4510 123456, ИНН 7707083893"
if guard.block_sensitive(text_with_pii):
    print("BLOCKED: sensitive data detected")
else:
    clean, _ = guard.anonymize(text_with_pii)
    print(f"Anonymized: {clean}")

# Audit Trail: hash-linked, append-only, immutable
# Каждая запись содержит: prev_hash → hash(current + prev_hash)

@dataclass
class AuditEntry:
    entry_id: str          # UUID
    session_id: str        # ID сессии агента
    user_id: str           # Кто инициировал (из SSO)
    action: AgentAction    # THINK / TOOL_CALL / RESPOND
    input_hash: str       # SHA-256 от входа (без PII!)
    output_hash: str      # SHA-256 от выхода
    tool_name: Optional[str] = None
    tool_args_hash: Optional[str] = None
    timestamp: float = time.time()
    prev_hash: str = ""
    chain_hash: str = ""

class ImmutableAuditTrail:
    """Append-only, hash-linked audit trail."""

    def __init__(self, db_url: str):
        self.entries: list[AuditEntry] = []
        self.last_hash = "genesis_block_00000000"
        # В продакшене: async запись в PostgreSQL с триггером

    def record(
        self,
        session_id: str,
        user_id: str,
        action: AgentAction,
        input_data: str,
        output_data: str,
        tool_name: Optional[str] = None,
        tool_args: Optional[str] = None,
    ) -> AuditEntry:
        """Создать и добавить запись в цепочку."""
        entry = AuditEntry(
            entry_id=f"audit_{uuid.uuid4().hex[:12]}",
            session_id=session_id,
            user_id=user_id,
            action=action,
            input_hash=hashlib.sha256(input_data.encode()).hexdigest(),
            output_hash=hashlib.sha256(output_data.encode()).hexdigest(),
            tool_name=tool_name,
            tool_args_hash=hashlib.sha256((tool_args or "").encode()).hexdigest(),
            prev_hash=self.last_hash,
        )
        # Цепной хеш: SHA-256(entry_data + prev_hash)
        entry_data = f"{entry.entry_id}|{entry.action.value}|{entry.input_hash}"
        entry.chain_hash = hashlib.sha256(
            (entry_data + self.last_hash).encode()
        ).hexdigest()
        self.last_hash = entry.chain_hash
        self.entries.append(entry)
        return entry

    def verify_integrity(self) -> bool:
        """Проверить, что цепочка не была изменена."""
        prev = "genesis_block_00000000"
        for entry in self.entries:
            if entry.prev_hash != prev:
                return False
            entry_data = f"{entry.entry_id}|{entry.action.value}|{entry.input_hash}"
            expected = hashlib.sha256(
                (entry_data + prev).encode()
            ).hexdigest()
            if entry.chain_hash != expected:
                return False
            prev = entry.chain_hash
        return True

    def reconstruct_session(self, session_id: str) -> list[AuditEntry]:
        """Восстановить полную историю сессии (для compliance officer)."""
        return [e for e in self.entries if e.session_id == session_id]

# policy.rego — пример политики OPA для AI-агента
# Хранится в Git → CI/CD → OPA sidecar

package agent.rbac

# Разрешённые роли
allowed_roles = {"support_agent", "team_lead", "admin", "compliance_officer"}

# Маппинг ролей на права использования инструментов
tool_permissions[role] = tools {
    role == "support_agent"
    tools = {"read_ticket", "search_kb", "respond_to_customer"}
}

tool_permissions[role] = tools {
    role == "team_lead"
    tools = {"read_ticket", "edit_ticket", "escalate", "search_kb", "assign_agent"}
}

tool_permissions[role] = tools {
    role == "admin"
    tools = {"read_ticket", "edit_ticket", "delete_ticket", "create_user", "view_analytics"}
}

tool_permissions[role] = tools {
    role == "compliance_officer"
    tools = {"view_audit_log", "export_report"}
}

# Правило: может ли пользователь использовать instrument?
default allow = false
allow {
    input.role = role
    input.tool = tool
    tool_permissions[role][_] = tool
}

# Правило: может ли пользователь читать данные клиента?
default can_access_customer_data = false
can_access_customer_data {
    input.role in {"support_agent", "team_lead", "admin"}
    input.data_classification != "RESTRICTED"
}

# Правило: автоматическая эскалация при обнаружении sensitive
default require_human_approval = false
require_human_approval {
    input.tool in {"delete_ticket", "refund_customer", "change_pricing"}
    input.amount > 1000
}

# values.yaml — Helm чарт для on-premise развёртывания
global:
  environment: "production"
  dataCenter: "dc1-msk"
  imageRegistry: "registry.internal.corp:5000"

# LLM Inference (GPU)
llm:
  replicas: 4
  gpu:
    type: "nvidia.com/gpu"
    count: 1  # Один A100 на реплику
  model:
    name: "qwen-2.5-72b-instruct"
    tensor_parallel: 1
    max_model_len: 32768
  autoscaling:
    enabled: true
    minReplicas: 2
    maxReplicas: 10
    targetGPUUtilization: 80

# Agent Runtime (CPU)
agent:
  replicas: 6
  resources:
    requests:
      cpu: "2"
      memory: "4Gi"
    limits:
      cpu: "4"
      memory: "8Gi"
  autoscaling:
    enabled: true
    minReplicas: 3
    maxReplicas: 20
    targetCPUUtilization: 70
  env:
    LLM_ENDPOINT: "http://llm-inference.svc.cluster.local:8000"
    DB_URL: "postgresql://agent:pass@postgres-master:5432/agentdb"
    VECTOR_DB_URL: "http://qdrant:6333"
    OPA_URL: "http://localhost:8181"

# Redis для кэша сессий и rate limiting
redis:
  architecture: "replication"
  sentinel:
    enabled: true
  master:
    persistence:
      enabled: true
      size: "20Gi"

# PostgreSQL с pgvector и аудит-триггерами
postgresql:
  replication:
    enabled: true
    readReplicas: 2
  extensions:
    - pgvector
    - pgcrypto
  audit:
    appendOnlyTable: true
    blockDelete: true

# Мониторинг
monitoring:
  prometheus:
    enabled: true
    retention: "30d"
  grafana:
    enabled: true
  elk:
    enabled: true
    retention: "90d"

from enum import Enum
from dataclasses import dataclass

class ApprovalStatus(Enum):
    PENDING = "pending"
    APPROVED = "approved"
    REJECTED = "rejected"
    TIMEOUT = "timeout"

@dataclass
class ApprovalRequest:
    request_id: str
    tool_name: str
    tool_args: dict
    risk_level: str  # LOW, MEDIUM, HIGH, CRITICAL
    reason: str     # Почему агент хочет выполнить действие
    created_by: str # session_id агента

class HumanInTheLoop:
    """Enterprise HITL с маршрутизацией по уровню риска."""

    # Какие действия требуют подтверждения
    REQUIRES_APPROVAL = {
        "refund_customer": ("HIGH", "finance"),
        "delete_user_data": ("CRITICAL", "compliance"),
        "change_pricing": ("HIGH", "finance"),
        "deploy_config": ("MEDIUM", "devops"),
        "send_mass_email": ("MEDIUM", "marketing"),
        "block_user": ("MEDIUM", "security"),
    }

    # Пороги для авто-отклонения (суммы)
    AUTO_DENY_THRESHOLDS = {
        "refund_customer": 50000,   # > 50k всегда требует C-level
        "delete_user_data": 1, # всегда ручное подтверждение
    }

    def needs_approval(self, tool_name: str, args: dict) -> Optional[ApprovalRequest]:
        """Проверить, нужно ли human approval."""
        if tool_name not in self.REQUIRES_APPROVAL:
            return None  # Действие не требует подтверждения

        risk, team = self.REQUIRES_APPROVAL[tool_name]

        # Проверяем пороги авто-отклонения
        amount = args.get("amount", 0)
        if amount >= self.AUTO_DENY_THRESHOLDS.get(tool_name, float('inf')):
            return ApprovalRequest(
                request_id=f"aprv-{uuid.uuid4().hex[:8]}",
                tool_name=tool_name,
                tool_args=args,
                risk_level="CRITICAL",
                reason=f"Amount {amount} exceeds auto-deny threshold",
                created_by="agent-system",
            )

        return ApprovalRequest(
            request_id=f"aprv-{uuid.uuid4().hex[:8]}",
            tool_name=tool_name,
            tool_args=args,
            risk_level=risk,
            reason=f"Agent requests {tool_name} ({risk} risk) — review by {team}",
            created_by="agent-system",
        )

    async def wait_for_approval(self, request: ApprovalRequest, timeout=300) -> ApprovalStatus:
        """Ждать ответа оператора с таймаутом (default: 5 минут)."""
        # В продакшене: отправка в очередь Slack/Jira/кастомный dashboard
        # и ожидание callback через WebSocket/Polling
        try:
            result = await asyncio.wait_for(
                self._poll_approval_queue(request.request_id),
                timeout=timeout
            )
            return result
        except asyncio.TimeoutError:
            return ApprovalStatus.TIMEOUT