# -*- coding: utf-8 -*-
# /var/www/html/fluxo_identificacao.py

import json
import re
import importlib
from utils_hibrido import (
    registrar_log, enviar_whatsapp, obter_mensagem_db,
    limpar_cpf_cnpj, consultar_cliente_por_cpf, consultar_cliente_por_id
)

def buscar_cadastros_radiusnet(cursor, cpf_cnpj):
    """Busca cadastros e filtra apenas os que NÃO são Arquivados."""
    cadastros = consultar_cliente_por_cpf(cursor, cpf_cnpj)
    
    # Filtra: remove status "Arquivado" (case insensitive)
    cadastros_filtrados = []
    status_ignorados = ['arquivado', 'inativo', 'cancelado']
    
    for c in cadastros:
        status = c.get('status_cliente', '').lower()
        if status not in status_ignorados:
            cadastros_filtrados.append(c)
        else:
            registrar_log('FLUXO_IDENTIFICACAO', f"Ignorando cadastro arquivado: {c.get('nome_razao')}")
    
    registrar_log('FLUXO_IDENTIFICACAO', f"Encontrados {len(cadastros_filtrados)} cadastros ativos (ignorados: {len(cadastros) - len(cadastros_filtrados)})")
    return cadastros_filtrados

def formatar_contatos(dados_cliente):
    """
    Formata emails e telefones no formato vertical para melhor visualização no celular.
    Retorna (email_str, telefone_str) prontos para exibição.
    """
    email_str = 'não informado'
    telefone_str = 'não informado'
    
    if not dados_cliente:
        return email_str, telefone_str
    
    # Extrai emails - pode ser lista de dicts ou lista de strings
    emails = dados_cliente.get('emails', [])
    if emails:
        lista_emails = []
        if isinstance(emails[0], dict):
            for e in emails:
                if e.get('email'):
                    lista_emails.append(e.get('email'))
        else:
            lista_emails = emails
        
        if lista_emails:
            email_str = "\n".join(lista_emails)
    
    # Extrai telefones - pode ser lista de dicts ou lista de strings
    telefones = dados_cliente.get('telefones', [])
    if telefones:
        lista_telefones = []
        if isinstance(telefones[0], dict):
            for t in telefones:
                ddd = t.get('ddd', '')
                tel = t.get('telefone', '')
                if tel:
                    # Formata telefone: (XX) XXXXX-XXXX ou (XX) XXXX-XXXX
                    tel_limpo = re.sub(r'\D', '', tel)
                    if len(tel_limpo) == 9:
                        tel_formatado = f"{tel_limpo[:5]}-{tel_limpo[5:]}"
                    elif len(tel_limpo) == 8:
                        tel_formatado = f"{tel_limpo[:4]}-{tel_limpo[4:]}"
                    else:
                        tel_formatado = tel_limpo
                    lista_telefones.append(f"({ddd}) {tel_formatado}")
        else:
            for t in telefones:
                if t:
                    # Remove formatação existente e aplica a padrão
                    tel_limpo = re.sub(r'\D', '', t)
                    if len(tel_limpo) == 11:
                        tel_formatado = f"({tel_limpo[:2]}) {tel_limpo[2:7]}-{tel_limpo[7:]}"
                    elif len(tel_limpo) == 10:
                        tel_formatado = f"({tel_limpo[:2]}) {tel_limpo[2:6]}-{tel_limpo[6:]}"
                    else:
                        tel_formatado = t
                    lista_telefones.append(tel_formatado)
        
        if lista_telefones:
            telefone_str = "\n".join(lista_telefones)
    
    return email_str, telefone_str

def processar(conn, cursor, job, atendimento, configs, mensagem_bruta):
    atendimento_id = atendimento['id']
    numero = atendimento['cliente_numero']
    estado = atendimento.get('estado_atual', 'PROCESSAR_DOCUMENTO')
    
    raw_ctx = atendimento.get('contexto_json')
    ctx = json.loads(raw_ctx) if raw_ctx else {}
    
    registrar_log('FLUXO_IDENTIFICACAO', f"Estado: {estado}")
    
    # Estado: Processar documento (já tem CPF)
    if estado == 'PROCESSAR_DOCUMENTO':
        cpf = ctx.get('cpf')
        if not cpf:
            registrar_log('FLUXO_IDENTIFICACAO', "CPF não encontrado no contexto")
            enviar_whatsapp(configs, numero, "Por favor, informe seu CPF novamente.")
            cursor.execute("UPDATE atendimentos SET estado_atual = 'AGUARDANDO_CPF' WHERE id = %s", (atendimento_id,))
            conn.commit()
            return
        
        cadastros = buscar_cadastros_radiusnet(cursor, cpf)
        
        if not cadastros:
            tentativas = ctx.get('tentativas_cpf', 0) + 1
            ctx['tentativas_cpf'] = tentativas
            if tentativas >= 2:
                msg = obter_mensagem_db(cursor, 'msg_identificacao_erro_fuga')
                enviar_whatsapp(configs, numero, msg)
                cursor.execute("""
                    UPDATE atendimentos
                    SET status = 'fila', setor_id = 2, fluxo_atual = 'HUMANO', estado_atual = 'AGUARDANDO', contexto_json = %s
                    WHERE id = %s
                """, (json.dumps(ctx), atendimento_id))
                conn.commit()
            else:
                msg = obter_mensagem_db(cursor, 'msg_cpf_nao_encontrado_repescagem')
                enviar_whatsapp(configs, numero, msg)
                cursor.execute("UPDATE atendimentos SET contexto_json = %s, estado_atual = 'AGUARDANDO_CPF' WHERE id = %s", (json.dumps(ctx), atendimento_id))
                conn.commit()
            return
        
        ctx['cadastros'] = cadastros
        
        if len(cadastros) == 1:
            ctx['id_cliente'] = cadastros[0].get('id_cliente')
            cursor.execute("UPDATE atendimentos SET contexto_json = %s, estado_atual = 'VALIDAR_CONTATOS' WHERE id = %s", (json.dumps(ctx), atendimento_id))
            conn.commit()
            
            # Busca contatos
            dados_cliente = consultar_cliente_por_id(cursor, ctx['id_cliente'])
            email_str, telefone_str = formatar_contatos(dados_cliente)
            
            msg_valid = obter_mensagem_db(cursor, 'msg_validacao_contatos').format(telefone=telefone_str, email=email_str)
            enviar_whatsapp(configs, numero, msg_valid)
        else:
            # Múltiplos cadastros: mostra lista com informações úteis
            lista = []
            for i, c in enumerate(cadastros, 1):
                nome = c.get('nome_razao', 'Cliente')
                status = c.get('status_cliente', 'Desconhecido')
                # Pega o primeiro plano para mostrar a cidade/endereço
                planos = c.get('planos', [])
                endereco = ""
                if planos:
                    end = planos[0].get('endereco_instalacao', '')
                    # Extrai cidade do endereço
                    partes = end.split('-')
                    if len(partes) >= 2:
                        endereco = partes[-2].strip() if len(partes) >= 2 else ''
                linha = f"{i} - {nome} - {status}"
                if endereco:
                    linha += f" - {endereco}"
                lista.append(linha)
            
            msg_menu = "Identifiquei que você possui mais de um cadastro vinculado ao seu documento.\n\nPor favor, responda com o número da opção correspondente:\n\n"
            msg_menu += "\n".join(lista)
            enviar_whatsapp(configs, numero, msg_menu)
            cursor.execute("UPDATE atendimentos SET contexto_json = %s, estado_atual = 'SELECIONAR_CADASTRO' WHERE id = %s", (json.dumps(ctx), atendimento_id))
            conn.commit()
    
    # Estado: Selecionar cadastro
    elif estado == 'SELECIONAR_CADASTRO':
        try:
            escolha = int(mensagem_bruta.strip()) - 1
            cadastros = ctx.get('cadastros', [])
            if 0 <= escolha < len(cadastros):
                ctx['id_cliente'] = cadastros[escolha].get('id_cliente')
                cursor.execute("UPDATE atendimentos SET contexto_json = %s, estado_atual = 'VALIDAR_CONTATOS' WHERE id = %s", (json.dumps(ctx), atendimento_id))
                conn.commit()
                
                dados_cliente = consultar_cliente_por_id(cursor, ctx['id_cliente'])
                email_str, telefone_str = formatar_contatos(dados_cliente)
                
                msg_valid = obter_mensagem_db(cursor, 'msg_validacao_contatos').format(telefone=telefone_str, email=email_str)
                enviar_whatsapp(configs, numero, msg_valid)
            else:
                enviar_whatsapp(configs, numero, "Opção inválida. Digite o número correto da opção desejada.")
        except ValueError:
            enviar_whatsapp(configs, numero, "Digite apenas o número da opção desejada.")
    
    # Estado: Validar contatos
    elif estado == 'VALIDAR_CONTATOS':
        resposta = mensagem_bruta.strip().lower()
        if resposta == '1' or resposta == '3':
            msg_sucesso = obter_mensagem_db(cursor, 'msg_sucesso_identificacao')
            enviar_whatsapp(configs, numero, msg_sucesso)
            cursor.execute("""
                UPDATE atendimentos
                SET fluxo_atual = 'CLASSIFICACAO', estado_atual = 'AGUARDANDO_MENSAGEM'
                WHERE id = %s
            """, (atendimento_id,))
            conn.commit()
        elif resposta == '2':
            enviar_whatsapp(configs, numero, "Transferindo para um atendente para atualização de cadastro.")
            cursor.execute("""
                UPDATE atendimentos
                SET status = 'fila', setor_id = 2, fluxo_atual = 'HUMANO', estado_atual = 'AGUARDANDO'
                WHERE id = %s
            """, (atendimento_id,))
            conn.commit()
        elif resposta == '3':
            enviar_whatsapp(configs, numero, "Transferindo para um atendente para adicionar novo e-mail.")
            cursor.execute("""
                UPDATE atendimentos
                SET status = 'fila', setor_id = 2, fluxo_atual = 'HUMANO', estado_atual = 'AGUARDANDO'
                WHERE id = %s
            """, (atendimento_id,))
            conn.commit()
        else:
            enviar_whatsapp(configs, numero, "Resposta inválida. Digite 1 para dados corretos, 2 para adicionar telefone ou 3 para adicionar e-mail.")
    
    # Estado: Aguardando CPF
    elif estado == 'AGUARDANDO_CPF':
        cpf = limpar_cpf_cnpj(mensagem_bruta)
        if len(cpf) in (11, 14):
            ctx['cpf'] = cpf
            cursor.execute("""
                UPDATE atendimentos
                SET cliente_cpf = %s, contexto_json = %s, estado_atual = 'PROCESSAR_DOCUMENTO'
                WHERE id = %s
            """, (cpf, json.dumps(ctx), atendimento_id))
            conn.commit()
            processar(conn, cursor, job, {**atendimento, 'estado_atual': 'PROCESSAR_DOCUMENTO', 'contexto_json': json.dumps(ctx)}, configs, mensagem_bruta)
        else:
            msg = obter_mensagem_db(cursor, 'msg_cpf_nao_encontrado_repescagem')
            enviar_whatsapp(configs, numero, msg)
    
    else:
        registrar_log('FLUXO_IDENTIFICACAO', f"Estado desconhecido: {estado}")
        cursor.execute("UPDATE atendimentos SET estado_atual = 'AGUARDANDO_CPF' WHERE id = %s", (atendimento_id,))
        conn.commit()