tasklet_leitura_de_boleto.py

from abstra.tasks import get_trigger_task, send_task
from abstra.ai import parse_boleto, prompt

from datetime import datetime
from pathlib import Path
from collections import Counter
import re
import json
import unicodedata
import requests
from validate_docbr import CNPJ

# ==== Helpers para validação de CNPJ ====
def _only_digits(s):
    return "".join(c for c in (s or "") if c.isdigit())

def _norm_name(s: str) -> str:
    if not s:
        return ""
    s = unicodedata.normalize("NFKD", s.upper().strip())
    s = "".join(ch for ch in s if not unicodedata.combining(ch))
    s = re.sub(r"[^A-Z0-9\s]", " ", s)
    s = re.sub(r"\s+", " ", s).strip()
    s = re.sub(r"\b(LTDA|EPP|ME|S\.?A\.?|S\/A|EI|EIRELI|MEI)\b", "", s).strip()
    return s

def _simple_similarity(a: str, b: str) -> int:
    """0..100 – token Jaccard + bônus de substring."""
    a, b = _norm_name(a), _norm_name(b)
    if not a or not b:
        return 0
    ta, tb = set(a.split()), set(b.split())
    j = 100 * len(ta & tb) / max(1, len(ta | tb))
    bonus = 20 if (a in b or b in a) else 0
    return int(min(100, j + bonus))

def _brasilapi(cnpj_digits: str):
    try:
        r = requests.get(f"https://brasilapi.com.br/api/cnpj/v1/{cnpj_digits}", timeout=6)
        return r.json() if r.status_code == 200 else None
    except Exception:
        return None

def validar_cnpj_razao(cnpj_str: str, razao_extr: str, min_name_score=80):
    """
    Valida CNPJ e razão social:
      1) valida DV
      2) consulta BrasilAPI
      3) compara razão social
    Retorna: {decision, reason, official}
    """
    val = CNPJ()
    digits = _only_digits(cnpj_str)

    if len(digits) != 14 or not val.validate(digits):
        return {"decision": "RETRY_PROMPT", "reason": "CNPJ com dígito inválido.", "official": None}

    data = _brasilapi(digits)
    if not data:
        return {"decision": "TRY_NAME_SEARCH", "reason": "CNPJ válido, porém não encontrado na base pública.", "official": None}

    score = _simple_similarity(razao_extr or "", data.get("razao_social", ""))
    if score >= min_name_score:
        return {
            "decision": "ACCEPT",
            "reason": f"Nome compatível (score {score}).",
            "official": {"cnpj": digits, "razao": data.get("razao_social"), "situacao": data.get("situacao")}
        }
    else:
        return {"decision": "RETRY_PROMPT", "reason": f"Razão social divergente (score {score}).", "official": None}

def _reextrair_cnpj_focado(pdf_path_obj, razao_anchor: str):
    """
    Re-extrai APENAS o CNPJ do BENEFICIÁRIO usando prompt focado.
    Retorna: '14 dígitos' ou None
    """
    prompt_focus = f"""
    Você vai ler um PDF de boleto. Retorne APENAS o CNPJ do BENEFICIÁRIO em 14 dígitos contínuos (ex.: 31882925000137).
    Regras:
    - Use a razão social do BENEFICIÁRIO como âncora: "{razao_anchor or ''}".
    - NÃO retorne o CNPJ do pagador/sacado.
    - Se houver variações (formatado vs sem máscara), normalize para 14 dígitos.
    - Se não encontrar com segurança, retorne exatamente: NONE
    Responda apenas com os 14 dígitos ou NONE. Nada além disso.
    """
    try:
        out = prompt([prompt_focus, pdf_path_obj]).strip()
        m = re.search(r'\b(\d{14})\b', out)
        if m:
            return m.group(1)
        return None
    except Exception:
        return None

print("💰 Tasklet Leitura de Boleto iniciado...")

# 1. Obter a task que disparou este tasklet
task = get_trigger_task()
print(f"📥 Task recebida: {task.type}")
print(f"📋 Payload: {task.payload}")

# 2. Extrair informações da task
pdf_path_str = task.payload.get("pdf_path")
pdf_path = Path(pdf_path_str) if pdf_path_str else None
filename = task.payload.get("filename", "boleto_desconhecido.pdf")
classificacao = task.payload.get("classificacao", "boleto")
identificador_processo = task.payload.get("identificador_processo")

if not pdf_path:
    print("❌ Erro: Nenhum caminho de PDF encontrado na task.")
    # Enviar task de erro
    error_payload = {
        "identificador_processo": identificador_processo,
        "erro": "Nenhum caminho de PDF encontrado na task",
        "filename": filename,
        "source": task.payload.get("source", "email")
    }
    send_task("erro", error_payload)
    print("📤 Task de erro enviada")
else:
    print(f"📄 Processando boleto: {filename}")
    print(f"📂 Caminho: {pdf_path}")

    try:
        # 3. Tentar parse_boleto 3 vezes para verificar consistência
        print("🤖 Iniciando parse do boleto com IA (3 tentativas)...")
        numero_de_tentativas = 3
        resultados_parse = []
        
        for i in range(numero_de_tentativas):
            print(f"🔄 Tentativa {i+1}/{numero_de_tentativas} com parse_boleto...")
            try:
                boleto_obj = parse_boleto(pdf_path)
                
                # Se for objeto, converte para dict
                if hasattr(boleto_obj, '__dict__'):
                    boleto_data_temp = vars(boleto_obj)
                elif isinstance(boleto_obj, dict):
                    boleto_data_temp = boleto_obj
                else:
                    boleto_data_temp = {}
                
                resultados_parse.append(boleto_data_temp)
                print(f"✅ Tentativa {i+1} bem-sucedida")
            except Exception as e:
                print(f"⚠️ Erro na tentativa {i+1} com parse_boleto: {e}")
                resultados_parse.append({})
        
        # Verificar consistência dos dados principais
        campos_principais = ['cpf_cnpj_beneficiario', 'beneficiario', 'valor']
        boleto_data = {}
        
        for campo in campos_principais:
            valores = [r.get(campo) for r in resultados_parse if r.get(campo) not in [None, '', 'null']]
            if valores:
                # Usar o valor mais comum
                valor_mais_comum = Counter(valores).most_common(1)[0][0]
                boleto_data[campo] = valor_mais_comum
                print(f"📊 Campo '{campo}': {len([v for v in valores if v == valor_mais_comum])}/{len(valores)} concordam com '{valor_mais_comum}'")
            else:
                boleto_data[campo] = None
                print(f"⚠️ Campo '{campo}': nenhum valor encontrado")
        
        # Para os demais campos, usar o primeiro resultado válido
        todos_campos = set()
        for r in resultados_parse:
            todos_campos.update(r.keys())
        
        for campo in todos_campos:
            if campo not in boleto_data:
                for r in resultados_parse:
                    valor = r.get(campo)
                    if valor not in [None, '', 'null']:
                        boleto_data[campo] = valor
                        break
        
        print(f"✅ Parse consolidado. Dados extraídos: {boleto_data}")

        # 4. Extrair e processar as informações do boleto
        cnpj_pagador = None
        cnpj_fornecedor = None
        razao_social = None
        valor = None
        vencimento_info = None
        instrucoes = None

        # O parse_boleto retorna os campos diretamente no dicionário raiz
        cnpj_fornecedor = boleto_data.get('cpf_cnpj_beneficiario')
        cnpj_pagador = boleto_data.get('cpf_cnpj_pagador')
        razao_social = boleto_data.get('beneficiario')
        
        # Limpar formatação dos CNPJs se necessário
        if cnpj_fornecedor:
            cnpj_fornecedor = re.sub(r'[^0-9]', '', str(cnpj_fornecedor))
        if cnpj_pagador:
            cnpj_pagador = re.sub(r'[^0-9]', '', str(cnpj_pagador))

        # Extrair valor (parse_boleto retorna em centavos)
        valor_raw = boleto_data.get('valor')
        if valor_raw is not None:
            try:
                if isinstance(valor_raw, (int, float)):
                    # Converter de centavos para reais e manter como string
                    valor = str(float(valor_raw) / 100)
                elif isinstance(valor_raw, str):
                    valor_clean = re.sub(r'[^\d,.]', '', valor_raw)
                    valor_clean = valor_clean.replace(',', '.')
                    valor = str(float(valor_clean))
            except Exception as e:
                print(f"⚠️ Erro ao processar valor: {e}")
                valor = None

        # Extrair data de vencimento
        vencimento_raw = boleto_data.get('vencimento')
        if vencimento_raw:
            # Verifica se já é um objeto date/datetime
            if isinstance(vencimento_raw, datetime):
                vencimento_info = vencimento_raw.date()
            elif hasattr(vencimento_raw, 'year'):  # É um objeto date
                vencimento_info = vencimento_raw
            else:
                # Tenta fazer parse se for string
                date_formats = ['%d/%m/%Y', '%Y-%m-%d', '%d-%m-%Y']
                for fmt in date_formats:
                    try:
                        vencimento_info = datetime.strptime(str(vencimento_raw), fmt).date()
                        break
                    except Exception:
                        continue

        # Extrair instruções e informações adicionais
        instrucoes_fields = ['instrucoes', 'observacoes', 'mensagem', 'descricao']
        for field in instrucoes_fields:
            if boleto_data.get(field):
                instrucoes = str(boleto_data[field])
                break
        
        # Se não encontrou instruções específicas, montar com campos relevantes
        if not instrucoes:
            info_parts = []
            # Adicionar campos mais relevantes primeiro
            campos_relevantes = [
                ('numero_documento', 'Nº Doc'),
                ('nosso_numero', 'Nosso Nº'),
                ('codigo_de_barras', 'Cód. Barras'),
                ('agencia_cod_beneficiario', 'Agência'),
                ('carteira', 'Carteira')
            ]
            for campo, label in campos_relevantes:
                if boleto_data.get(campo):
                    info_parts.append(f"{label}: {boleto_data[campo]}")
            
            if info_parts:
                instrucoes = " | ".join(info_parts)

        # Se todos os campos relevantes vierem None, acione abstra.ai.prompt para tentar extrair
        usar_fallback = all(x is None for x in [cnpj_fornecedor, cnpj_pagador, razao_social, valor, vencimento_info])
        
        if usar_fallback:
            print("⚡️ Dados principais não encontrados, acionando abstra.ai.prompt (3 tentativas)...")
            
            prompt_text = '''
            Extraia do PDF de boleto as seguintes informações:
            - cnpj_beneficiario: CNPJ do beneficiário (14 dígitos, formato XX.XXX.XXX/XXXX-XX ou apenas números)
            - cnpj_pagador: CNPJ do pagador (14 dígitos, formato XX.XXX.XXX/XXXX-XX ou apenas números)
            - razao_social_beneficiario: Razão social do beneficiário
            - valor: Valor do boleto em reais (número decimal)
            - vencimento: Data de vencimento (formato DD/MM/YYYY)
            
            Leia o conteúdo cuidadosamente e mantenha a compatibilidade entre os números.
            Responda em JSON com as chaves: cnpj_beneficiario, cnpj_pagador, razao_social_beneficiario, valor, vencimento.
            '''
            
            resultados_prompt = []
            for i in range(3):
                print(f"🔄 Tentativa {i+1}/3 com ai.prompt...")
                try:
                    resultado = prompt([prompt_text, pdf_path])
                    match = re.search(r'\{[\s\S]*\}', resultado)
                    if match:
                        dados = json.loads(match.group(0))
                        resultados_prompt.append(dados)
                        print(f"✅ Tentativa {i+1} bem-sucedida")
                    else:
                        resultados_prompt.append({})
                except Exception as e:
                    print(f"⚠️ Erro na tentativa {i+1}: {e}")
                    resultados_prompt.append({})
            
            # Consolidar resultados do prompt
            campos_prompt = ['cnpj_beneficiario', 'cnpj_pagador', 'razao_social_beneficiario', 'valor', 'vencimento']
            dados_consolidados = {}
            
            for campo in campos_prompt:
                valores = [r.get(campo) for r in resultados_prompt if r.get(campo) not in [None, '', 'null']]
                if valores:
                    valor_mais_comum = Counter(valores).most_common(1)[0][0]
                    dados_consolidados[campo] = valor_mais_comum
                    print(f"📊 Campo '{campo}': {len([v for v in valores if v == valor_mais_comum])}/{len(valores)} concordam")
            
            # Aplicar dados consolidados
            if dados_consolidados.get('cnpj_pagador'):
                cnpj_pagador = re.sub(r'[^0-9]', '', str(dados_consolidados['cnpj_pagador']))
            if dados_consolidados.get('cnpj_beneficiario'):
                cnpj_fornecedor = re.sub(r'[^0-9]', '', str(dados_consolidados['cnpj_beneficiario']))
            if dados_consolidados.get('razao_social_beneficiario'):
                razao_social = dados_consolidados['razao_social_beneficiario']
            if dados_consolidados.get('valor'):
                valor = str(dados_consolidados['valor'])
            if dados_consolidados.get('vencimento'):
                vencimento_info = dados_consolidados['vencimento']
            
            print("✅ Dados extraídos via prompt.ai aplicados ao processamento.")

        print(f"📊 Dados processados:")
        print(f"   CNPJ Fornecedor/ Beneficiário: {cnpj_fornecedor}")
        print(f"   CNPJ Pagador: {cnpj_pagador}")
        print(f"   Razão Social: {razao_social}")
        print(f"   Valor: R$ {valor}")
        print(f"   Data Vencimento: {vencimento_info}")
        print(f"   Instruções: {instrucoes[:100] if instrucoes else None}...")
        
        # ==== Validação de CNPJ do Beneficiário ====
        if cnpj_fornecedor and razao_social:
            print("🔎 Validando CNPJ do beneficiário...")
            check = validar_cnpj_razao(cnpj_fornecedor, razao_social, min_name_score=80)
            print(f"🔎 Validação: {check['decision']} — {check['reason']}")
            
            # Se precisar retry, tenta re-extrair com prompt focado
            if check["decision"] == "RETRY_PROMPT":
                print("↩️ RETRY_PROMPT: tentando re-extrair CNPJ do beneficiário com prompt focado...")
                cnpj_focado = _reextrair_cnpj_focado(pdf_path, razao_social)
                if cnpj_focado:
                    check2 = validar_cnpj_razao(cnpj_focado, razao_social, min_name_score=80)
                    print(f"🔁 Pós-reprompt focado: {check2['decision']} — {check2['reason']}")
                    if check2["decision"] == "ACCEPT" and check2.get("official"):
                        # Corrige o CNPJ/razão
                        cnpj_fornecedor = check2["official"]["cnpj"]
                        razao_social = check2["official"]["razao"]
                        print(f"✅ CNPJ corrigido: {cnpj_fornecedor}")
                        print(f"✅ Razão social corrigida: {razao_social}")
                else:
                    print("⛔ Não foi possível re-extrair um CNPJ confiável")
                
                # Se ainda não for aceitável, dispara task auxiliar
                cnpj_final = cnpj_fornecedor
                digits_final = _only_digits(cnpj_final or "")
                val_tmp = CNPJ().validate(digits_final) if len(digits_final) == 14 else False
                data_tmp = _brasilapi(digits_final) if val_tmp else None
                ok_tmp = (val_tmp and data_tmp and _simple_similarity(razao_social or "", data_tmp.get("razao_social", "")) >= 80)
                
                if not ok_tmp:
                    print("📣 Disparando task auxiliar 'solicitar_cnpj_correto' para revisão humana")
                    try:
                        send_task(
                            "solicitar_cnpj_correto",
                            {
                                "cnpj_suspeito": cnpj_fornecedor,
                                "razao_social_beneficiario": razao_social,
                                "arquivo": filename,
                                "pdf_path": str(pdf_path),
                                "email_from": task.payload.get("email_from", ""),
                                "email_subject": task.payload.get("email_subject", ""),
                                "identificador_processo": identificador_processo,
                                "motivo": "CNPJ inválido ou divergente após re-prompt focado.",
                                "tipo_documento": "boleto"
                            }
                        )
                    except Exception as _e:
                        print(f"⚠️ Falha ao enviar task 'solicitar_cnpj_correto': {_e}")
            elif check["decision"] == "ACCEPT" and check.get("official"):
                # Atualiza com dados oficiais
                cnpj_fornecedor = check["official"]["cnpj"]
                razao_social = check["official"]["razao"]
                print(f"✅ CNPJ validado: {cnpj_fornecedor}")
                print(f"✅ Razão social oficial: {razao_social}")
        else:
            print("⚠️ CNPJ ou razão social não disponíveis para validação")

        # 5. Preparar dados no formato estruturado
        dados_boleto = {
            "beneficiary_document": cnpj_fornecedor,
            "beneficiary_name": razao_social,
            "cost": valor,  # Já é string ou None
            "due_date": vencimento_info.isoformat() if vencimento_info else None,
            "boleto_filepath": str(pdf_path),  # Campo esperado pelo tasklet_extrair_informacoes_da_nota
            "pdf_path": str(pdf_path),  # Compatibilidade adicional
            "dados_completos": boleto_data
        }
        # Remove campos None
        dados_boleto = {k: v for k, v in dados_boleto.items() if v is not None}

        # 6. Verificar se há menção a "Barueri" no endereço do beneficiário
        municipio_estado_prestador = None
        endereco_beneficiario = None
        
        # Buscar endereço do beneficiário nos dados do boleto
        campos_endereco = ['endereco_beneficiario', 'endereco', 'logradouro_beneficiario', 'address']
        for campo in campos_endereco:
            if boleto_data.get(campo):
                endereco_beneficiario = str(boleto_data[campo])
                break
        
        # Se encontrou endereço, verificar se contém "Barueri"
        if endereco_beneficiario:
            endereco_upper = endereco_beneficiario.upper()
            if "BARUERI" in endereco_upper:
                municipio_estado_prestador = {
                    "estado": "SP",
                    "municipio": "Barueri"
                }
                print(f"✅ Detectado Barueri no endereço: {endereco_beneficiario}")
            else:
                print(f"ℹ️ Barueri não encontrado no endereço: {endereco_beneficiario}")
        else:
            print("ℹ️ Endereço do beneficiário não encontrado nos dados")

        # 7. Preparar dados para próximo estágio
        task_payload = {
            **task.payload,  # Manter todos os dados originais da task recebida
            "cnpj_prestador": cnpj_fornecedor,  # CNPJ do beneficiário/fornecedor
            "cnpj_tomador": cnpj_pagador,       # CNPJ do pagador/tomador
            "tipo_documento": classificacao,
            "valor_total": valor,  # Já é string ou None
            "dados_boleto": dados_boleto,
            "file_path": str(pdf_path),
            "source": "boleto"
        }
        
        # Adicionar municipio_estado_prestador apenas se encontrou Barueri
        if municipio_estado_prestador:
            task_payload["municipio_estado_prestador"] = municipio_estado_prestador

        # 7. Enviar task para próximo estágio (Verificar Duplicatas)
        send_task("boleto_processado", task_payload)
        print("📤 Task enviada para verificação de duplicatas")
        
    except Exception as e:
        print(f"❌ Erro durante processamento do boleto: {str(e)}")
        print(f"📋 Detalhes do erro: {type(e).__name__}")
        
        try:
            # Enviar task com erro para próximo estágio
            error_payload = {
                "identificador_processo": identificador_processo,
                "erro": str(e),
                "filename": filename,
                "path": str(pdf_path) if pdf_path else None,
                "source": task.payload.get("source", "email")
            }
            send_task("erro", error_payload)
            print("📤 Task de erro enviada")
        except Exception as save_error:
            print(f"❌ Erro crítico ao salvar registro de erro: {str(save_error)}")

    finally:
        task.complete()
        print("🏁 Processamento de boleto concluído!")