from langchain_anthropic import ChatAnthropic
from langchain_community.vectorstores import PGVector
from langchain.chains import RetrievalQA

# Indexação de contratos
def index_contract(contract_pdf: bytes, contract_id: str):
    text = extract_text_from_pdf(contract_pdf)
    chunks = semantic_chunker.split_text(text)
    
    documents = [
        Document(
            page_content=chunk,
            metadata={
                "contract_id": contract_id,
                "chunk_index": i,
                "indexed_at": datetime.now().isoformat(),
            }
        )
        for i, chunk in enumerate(chunks)
    ]
    
    vectorstore.add_documents(documents)

# Análise de contrato
async def analyze_contract(contract_id: str) -> ContractAnalysis:
    retriever = vectorstore.as_retriever(
        search_kwargs={
            "filter": {"contract_id": contract_id},
            "k": 10,
        }
    )
    
    qa_chain = RetrievalQA.from_chain_type(
        llm=ChatAnthropic(model="claude-3-5-sonnet-20241022"),
        retriever=retriever,
        return_source_documents=True,
    )
    
    analysis = await qa_chain.ainvoke({
        "query": ANALYSIS_PROMPT
    })
    
    return parse_analysis(analysis["result"])

SYSTEM_PROMPT = """
Você é um assistente interno do Detran-RJ especializado em procedimentos e normas.

IMPORTANTE:
- Responda APENAS com base nos documentos fornecidos
- Se não souber a resposta, diga claramente que não encontrou a informação
- Sempre cite o documento e seção de onde veio a informação
- Não faça suposições sobre procedimentos não documentados
- Para questões legais complexas, sempre recomende consulta ao setor jurídico

Contexto dos documentos:
{context}
"""

class LGPDCompliantProcessor:
    SENSITIVE_FIELDS = ["cpf", "rg", "nome_completo", "endereco", "telefone"]
    
    def anonymize_for_llm(self, data: dict) -> dict:
        """Remove/mascara dados pessoais antes de enviar ao LLM"""
        anonymized = data.copy()
        for field in self.SENSITIVE_FIELDS:
            if field in anonymized:
                anonymized[field] = self._mask(anonymized[field], field)
        return anonymized
    
    def _mask(self, value: str, field_type: str) -> str:
        if field_type == "cpf":
            return f"***.***.{value[-6:-3]}-**"
        elif field_type == "nome_completo":
            parts = value.split()
            return f"{parts[0]} {'*' * len(parts[-1])}"
        return "***REDACTED***"

# Wrapper para sistema legado via API REST intermediária
class LegacySystemAdapter:
    async def get_vehicle_data(self, placa: str) -> VehicleData:
        # Sistema legado expõe dados via endpoint REST customizado
        response = await self.http_client.get(
            f"{LEGACY_API_URL}/veiculos/{placa}",
            headers={"Authorization": f"Bearer {LEGACY_TOKEN}"},
            timeout=30.0,
        )
        
        # Transforma formato legado para modelo moderno
        raw = response.json()
        return VehicleData(
            placa=raw["VCL_PLACA"],
            chassi=raw["VCL_CHASSI"],
            proprietario=raw["PROP_NOME"],
            # ... mapeamento de campos
        )

@dataclass
class AIDecisionLog:
    decision_id: str
    timestamp: datetime
    user_id: str
    input_data: dict  # Anonimizado
    llm_response: str
    final_decision: str
    human_override: bool
    override_reason: str | None

async def log_ai_decision(decision: AIDecisionLog):
    await audit_db.insert("ai_decisions", asdict(decision))
    
    # Notifica supervisor para decisões de alto impacto
    if decision.final_decision in HIGH_IMPACT_DECISIONS:
        await notify_supervisor(decision)