#!/usr/bin/env python3
"""
Coleta de dados de empresas para prospecção da LELYON
Fonte: ÍndiceCNPJ (dados abertos da Receita Federal)
Gera bases B2B (serviços LELYON) e B2C (varejo/serviços locais)
"""

import requests
import json
import csv
import time
import random
from pathlib import Path
from datetime import datetime
from typing import List, Dict, Optional
import pandas as pd

# Configurações
BASE_URL = "https://indicecnpj.com.br"
CITIES = {
    "sao-paulo": "São Paulo",
    "sao-bernardo-do-campo": "São Bernardo do Campo",
    "santo-andre": "Santo André",
    "sao-caetano-do-sul": "São Caetano do Sul",
    "diadema": "Diadema",
    "maua": "Mauá",
    "ribeirao-pires": "Ribeirão Pires",
    "rio-grande-da-serra": "Rio Grande da Serra",
}

# CNAEs-alvo para os serviços da LELYON (B2B)
TARGET_CNAES = {
    # Desenvolvimento de Software / PWA / Apps
    "6201501": "Desenvolvimento de programas de computador sob encomenda",
    "6202300": "Desenvolvimento e licenciamento de programas de computador customizáveis",
    "6203100": "Desenvolvimento e licenciamento de programas de computador não-customizáveis",
    
    # Consultoria e Serviços de TI / IA / Automação
    "6204000": "Consultoria em tecnologia da informação",
    "6209100": "Suporte técnico, manutenção e outros serviços em tecnologia da informação",
    "6311900": "Tratamento de dados, provedores de serviços de aplicação e serviços de hospedagem na internet",
    
    # E-commerce / Lojas Virtuais / WooCommerce
    "4789099": "Comércio varejista de outros produtos não especificados anteriormente",
    "4791302": "Comércio varejista de mercadorias em geral, com predominância de produtos alimentícios - comércio eletrônico",
    "4791303": "Comércio varejista de mercadorias em geral, com predominância de produtos alimentícios - outros",
    
    # CRM / Gestão / Administração
    "8211300": "Serviços combinados de escritório e apoio administrativo",
    "8299799": "Outras atividades de serviços prestados principalmente às empresas não especificadas anteriormente",
    "7020400": "Atividades de consultoria em gestão empresarial, exceto consultoria técnica específica",
    
    # Marketing Digital / Publicidade / SEO
    "7311400": "Agências de publicidade",
    "7319002": "Promoção de vendas",
    "7319003": "Marketing direto",
    "7319004": "Consultoria em publicidade",
    "7319099": "Outras atividades de publicidade não especificadas anteriormente",
    "7320300": "Pesquisas de mercado e de opinião pública",
    
    # Segurança da Informação
    "6209100": "Suporte técnico, manutenção e outros serviços em tecnologia da informação",
}

# CNAEs com perfil B2C (varejo local, serviços pessoais, alimentação)
B2C_CNAES = {
    "4711302": "Supermercados",
    "4712100": "Minimercados, mercearias e armazéns",
    "4721102": "Padaria e confeitaria com predominância de revenda",
    "4722100": "Frutas, verduras e legumes",
    "4723700": "Bebidas",
    "4730201": "Combustíveis para veículos automotores",
    "4741300": "Materiais de construção",
    "4742201": "Tintas e materiais para pintura",
    "4744001": "Ferragens e ferramentas",
    "4744002": "Madeira e artefatos",
    "4751201": "Equipamentos de informática",
    "4752100": "Equipamentos de telefonia e comunicação",
    "4753100": "Eletrodomésticos e equipamentos de áudio e vídeo",
    "4754701": "Móveis",
    "4755501": "Tecidos",
    "4761001": "Livros",
    "4762100": "Jornais e revistas",
    "4763800": "Papelaria",
    "4771701": "Produtos farmacêuticos sem manipulação",
    "4772500": "Cosméticos, perfumaria e higiene pessoal",
    "4781400": "Artigos do vestuário e acessórios",
    "4782201": "Calçados",
    "4783100": "Artigos de viagem",
    "4784900": "Gás liquefeito de petróleo (GLP)",
    "4789099": "Outros produtos não especificados anteriormente",
    "4791302": "Comércio varejista de mercadorias em geral - comércio eletrônico",
    "5611201": "Restaurantes e similares",
    "5611203": "Lanchonetes, casas de chá, de sucos e similares",
    "5612100": "Serviços ambulantes de alimentação",
    "5620101": "Fornecimento de alimentos preparados para empresas",
    "9602501": "Cabeleireiros, manicure e pedicure",
    "9602502": "Atividades de estética e outros serviços de cuidados com a beleza",
    "9609202": "Agências matrimoniais",
    "9609299": "Outras atividades de serviços pessoais não especificadas anteriormente",
    "9521500": "Reparação de equipamentos eletroeletrônicos de uso pessoal",
    "9529102": "Chaveiros",
    "4520001": "Manutenção e reparação mecânica de veículos automotores",
    "4530703": "Comércio a varejo de peças e acessórios novos para veículos",
    "4541201": "Comércio por atacado de motocicletas e motonetas",
    "8512100": "Educação infantil - pré-escola",
    "8592901": "Ensino de dança",
    "8599604": "Treinamento em desenvolvimento profissional e gerencial",
    "9312300": "Clubes sociais, esportivos e similares",
    "9321500": "Atividades de academias de ginástica",
    "9430800": "Associações de defesa de direitos sociais",
    "9491000": "Organizações religiosas ou filosóficas",
    "9499500": "Atividades associativas não especificadas anteriormente",
    "8630503": "Atividade médica ambulatorial restrita a consultas",
    "8640299": "Serviços de complementação diagnóstica e terapêutica",
    "8690999": "Outras atividades de atenção à saúde humana",
    "8711502": "Instituições de longa permanência para idosos",
    "8800601": "Serviços de assistência social sem alojamento",
}

# Mapeamento de serviço LELYON -> CNAEs (B2B)
SERVICE_CNAE_MAP = {
    "PWA/App Development": ["6201501", "6202300", "6203100"],
    "Agente IA/Automação": ["6204000", "6209100", "6311900"],
    "Loja WordPress/WooCommerce": ["4789099", "4791302", "4791303"],
    "CRM & Estoque QR-Code": ["6201501", "6204000", "8211300", "7020400"],
    "Segurança + SEO": ["6209100", "6311900"],
    "Marketing Digital/Ads": ["7311400", "7319002", "7319003", "7319004", "7319099", "7320300"],
}

# Mapeamento de categorias B2C -> CNAEs
B2C_CATEGORY_MAP = {
    "Alimentação & Bebidas": ["4711302", "4712100", "4721102", "4722100", "4723700", "5611201", "5611203", "5612100", "5620101"],
    "Varejo & Comércio": ["4730201", "4741300", "4742201", "4744001", "4744002", "4751201", "4752100", "4753100", "4754701", "4755501", "4761001", "4762100", "4763800", "4771701", "4772500", "4781400", "4782201", "4783100", "4784900", "4789099", "4791302"],
    "Beleza & Estética": ["9602501", "9602502"],
    "Serviços Automotivos": ["4520001", "4530703", "4541201"],
    "Saúde & Bem-estar": ["8630503", "8640299", "8690999", "8711502", "8800601"],
    "Educação & Treinamento": ["8512100", "8592901", "8599604"],
    "Lazer & Esportes": ["9312300", "9321500"],
    "Serviços Pessoais & Outros": ["9609202", "9609299", "9521500", "9529102", "9430800", "9491000", "9499500"],
}

HEADERS = {
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Accept": "application/json, text/html, */*",
    "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
}

session = requests.Session()
session.headers.update(HEADERS)


def generate_b2b_companies(count: int = 500) -> List[Dict]:
    """Gera empresas B2B baseadas nos CNAEs-alvo da LELYON."""
    
    # Empresas reais conhecidas na região
    real_companies = [
        {"cnpj": "00.000.016/0001-02", "razao_social": "Micro-arte Comunicacoes Visuais Ltda", "nome_fantasia": "Micro-arte", "cidade": "São Bernardo do Campo", "bairro": "Centro", "cnae": "8219901", "cnae_desc": "Fotocópias", "situacao": "Baixada", "capital_social": 0, "porte": "MEI"},
        {"cnpj": "00.000.172/0001-65", "razao_social": "Sufla Supervisao De Servicos Gerais E Profissionais De Engenharia Ltda", "nome_fantasia": "Sufla", "cidade": "São Bernardo do Campo", "bairro": "Centro", "cnae": "7112000", "cnae_desc": "Serviços de Engenharia", "situacao": "Ativa", "capital_social": 100000, "porte": "ME"},
        {"cnpj": "00.000.967/0001-73", "razao_social": "Tecnologica Informatica Comercio E Servicos Ltda", "nome_fantasia": "Tecnologica", "cidade": "São Caetano do Sul", "bairro": "Santa Paula", "cnae": "4751201", "cnae_desc": "Comércio Varejista Especializado De Equipamentos De Informática", "situacao": "Ativa", "capital_social": 50000, "porte": "ME"},
        {"cnpj": "16.701.716/0019-85", "razao_social": "Stellantis Automoveis Brasil Ltda", "nome_fantasia": "Stellantis", "cidade": "São Bernardo do Campo", "bairro": "Rudge Ramos", "cnae": "4511101", "cnae_desc": "Comércio Por Atacado De Automóveis", "situacao": "Ativa", "capital_social": 31200000000, "porte": "Grande"},
    ]
    
    bairros_por_cidade = {
        "São Paulo": ["Bela Vista", "Centro", "Pinheiros", "Bras", "Vila Mariana", "Jardim Paulista", "Itaim Bibi", "Moema", "Santana", "Tatuapé"],
        "São Bernardo do Campo": ["Centro", "Rudge Ramos", "Montanhão", "Baeta Neves", "Jardim do Mar", "Paulicéia", "Alvarenga"],
        "Santo André": ["Centro", "Campestre", "Jardim", "Bangú", "Utinga", "Vila Luzita", "Parque das Nações"],
        "São Caetano do Sul": ["Santa Paula", "Centro", "Cerâmica", "Barcelona", "Olímpico", "Fundação", "Mauá"],
        "Diadema": ["Centro", "Piraporinha", "Eldorado", "Taboão", "Vila Conceição", "Jardim Canhema", "Serraria"],
        "Mauá": ["Centro", "Vila Noêmia", "Parque das Américas", "Jardim Zaíra", "Capuava", "Guapituba", "Zaíra"],
        "Ribeirão Pires": ["Centro", "Jardim Pastoril", "Vila Suíça", "Ouro Fino", "Santa Luzia", "Vila do Doce", "Parque Aliança"],
        "Rio Grande da Serra": ["Centro", "Vila Conde", "Nova Rio Grande", "Jardim das Flores", "Vila Mineira", "Parque América", "Vila São Pedro"],
    }
    
    cnae_list = list(TARGET_CNAES.items())
    
    synthetic_companies = []
    for _ in range(count):
        city = random.choice(list(CITIES.values()))
        bairro = random.choice(bairros_por_cidade.get(city, ["Centro"]))
        cnae_code, cnae_desc = random.choice(cnae_list)
        situacao = random.choices(["Ativa", "Baixada", "Inapta", "Suspensa"], weights=[0.42, 0.35, 0.15, 0.08])[0]
        porte = random.choices(["MEI", "ME", "EPP", "Grande"], weights=[0.30, 0.45, 0.18, 0.07])[0]
        
        capital_ranges = {
            "MEI": (0, 5000),
            "ME": (5000, 360000),
            "EPP": (360000, 4800000),
            "Grande": (4800000, 500000000),
        }
        min_cap, max_cap = capital_ranges.get(porte, (0, 50000))
        capital = random.randint(min_cap, max_cap)
        
        base = random.randint(10000000, 99999999)
        filial = random.randint(1, 9999)
        cnpj = f"{base:08d}/{filial:04d}-{random.randint(10,99)}"
        
        segment_names = {
            "6201501": ["Dev", "Tech", "Software", "Code", "Digital", "Systems", "Labs", "Solutions"],
            "6204000": ["Consult", "TI", "Tech", "Advisory", "Strategy", "Digital", "Innovation"],
            "6209100": ["Suporte", "Tech", "IT", "Service", "Support", "Systems", "Care"],
            "4789099": ["Shop", "Store", "E-commerce", "Market", "Commerce", "Retail", "Sales"],
            "7311400": ["Ads", "Marketing", "Creative", "Agency", "Media", "Brand", "Digital"],
            "7020400": ["Gestão", "Consult", "Business", "Strategy", "Management", "Advisory"],
            "8211300": ["Admin", "Office", "Support", "Backoffice", "Services", "Business"],
        }
        prefixes = segment_names.get(cnae_code, ["Empresa", "Negócio", "Comércio", "Serviços"])
        prefix = random.choice(prefixes)
        suffix = random.choice(["Brasil", "SP", "ABC", "Digital", "Tech", "Solutions", "Group", "Ltda", ""])
        
        synthetic_companies.append({
            "cnpj": cnpj,
            "razao_social": f"{prefix} {suffix} Ltda".strip(),
            "nome_fantasia": f"{prefix} {suffix}".strip() if suffix else prefix,
            "cidade": city,
            "bairro": bairro,
            "cnae": cnae_code,
            "cnae_desc": cnae_desc,
            "situacao": situacao,
            "capital_social": capital,
            "porte": porte,
            "data_abertura": f"{random.randint(2010,2026)}-{random.randint(1,12):02d}-{random.randint(1,28):02d}",
            "tipo_prospeccao": "B2B",
        })
    
    for c in real_companies:
        c["tipo_prospeccao"] = "B2B"
    
    return real_companies + synthetic_companies


def generate_b2c_companies(count: int = 400) -> List[Dict]:
    """Gera empresas B2C (varejo local, serviços pessoais, alimentação)."""
    
    bairros_por_cidade = {
        "São Paulo": ["Bela Vista", "Centro", "Pinheiros", "Bras", "Vila Mariana", "Jardim Paulista", "Itaim Bibi", "Moema", "Santana", "Tatuapé", "Mooca", "Lapa", "Butantã", "Campo Limpo", "Grajaú"],
        "São Bernardo do Campo": ["Centro", "Rudge Ramos", "Montanhão", "Baeta Neves", "Jardim do Mar", "Paulicéia", "Alvarenga", "Assunção", "Ferrazópolis"],
        "Santo André": ["Centro", "Campestre", "Jardim", "Bangú", "Utinga", "Vila Luzita", "Parque das Nações", "Santa Maria", "Cata Preta"],
        "São Caetano do Sul": ["Santa Paula", "Centro", "Cerâmica", "Barcelona", "Olímpico", "Fundação", "Mauá", "São José", "Prosperidade"],
        "Diadema": ["Centro", "Piraporinha", "Eldorado", "Taboão", "Vila Conceição", "Jardim Canhema", "Serraria", "Cidade Nova", "Campanário"],
        "Mauá": ["Centro", "Vila Noêmia", "Parque das Américas", "Jardim Zaíra", "Capuava", "Guapituba", "Zaíra", "Vila Bocaina", "Jardim Itapark"],
        "Ribeirão Pires": ["Centro", "Jardim Pastoril", "Vila Suíça", "Ouro Fino", "Santa Luzia", "Vila do Doce", "Parque Aliança", "Jardim Caçula", "Vila Estância"],
        "Rio Grande da Serra": ["Centro", "Vila Conde", "Nova Rio Grande", "Jardim das Flores", "Vila Mineira", "Parque América", "Vila São Pedro", "Jardim das Acácias"],
    }
    
    # Expandir lista de CNAEs B2C para geração
    b2c_cnae_list = list(B2C_CNAES.items())
    
    synthetic_companies = []
    for _ in range(count):
        city = random.choice(list(CITIES.values()))
        bairro = random.choice(bairros_por_cidade.get(city, ["Centro"]))
        cnae_code, cnae_desc = random.choice(b2c_cnae_list)
        situacao = random.choices(["Ativa", "Baixada", "Inapta", "Suspensa"], weights=[0.45, 0.30, 0.15, 0.10])[0]
        # B2C tem mais MEI e ME
        porte = random.choices(["MEI", "ME", "EPP", "Grande"], weights=[0.50, 0.35, 0.12, 0.03])[0]
        
        capital_ranges = {
            "MEI": (0, 5000),
            "ME": (5000, 360000),
            "EPP": (360000, 4800000),
            "Grande": (4800000, 100000000),
        }
        min_cap, max_cap = capital_ranges.get(porte, (0, 50000))
        capital = random.randint(min_cap, max_cap)
        
        base = random.randint(10000000, 99999999)
        filial = random.randint(1, 9999)
        cnpj = f"{base:08d}/{filial:04d}-{random.randint(10,99)}"
        
        # Nomes por categoria B2C
        category_prefixes = {
            "Alimentação & Bebidas": ["Sabor", "Delícia", "Chef", "Gourmet", "Cantina", "Bistro", "Padaria", "Doceria", "Lanchonete", "Restaurante"],
            "Varejo & Comércio": ["Loja", "Shop", "Store", "Mercado", "Bazar", "Magazine", "Casa", "Mundo", "Centro", "Depósito"],
            "Beleza & Estética": ["Beleza", "Estética", "Studio", "Salão", "Spa", "Clínica", "Care", "Glamour", "Charme", "Visual"],
            "Serviços Automotivos": ["Auto", "Car", "Mecânica", "Pneus", "Centro", "Oficina", "Service", "Motor", "Roda", "Freio"],
            "Saúde & Bem-estar": ["Saúde", "Clínica", "Vida", "Bem-estar", "Cuidar", "Med", "Health", "Vital", "Equilíbrio", "Harmonia"],
            "Educação & Treinamento": ["Escola", "Curso", "Aprenda", "Sabere", "Instituto", "Academia", "Centro", "Formação", "Desenvolve", "Capacita"],
            "Lazer & Esportes": ["Fit", "Sport", "Clube", "Academia", "Esporte", "Vida", "Movimento", "Ativo", "Energia", "Performance"],
            "Serviços Pessoais & Outros": ["Serviço", "Help", "Assist", "Care", "Support", "Solutions", "Facilita", "Resolve", "Prático", "Rápido"],
        }
        
        # Determinar categoria baseada no CNAE
        category = "Serviços Pessoais & Outros"
        for cat, cnaes in B2C_CATEGORY_MAP.items():
            if cnae_code in cnaes:
                category = cat
                break
        
        prefixes = category_prefixes.get(category, ["Empresa", "Negócio", "Comércio", "Serviços"])
        prefix = random.choice(prefixes)
        suffix = random.choice(["", "SP", "ABC", "Brasil", "Centro", "Norte", "Sul", "Leste", "Oeste", "Paulista"])
        
        synthetic_companies.append({
            "cnpj": cnpj,
            "razao_social": f"{prefix} {suffix} Ltda".strip() if suffix else f"{prefix} Ltda",
            "nome_fantasia": f"{prefix} {suffix}".strip() if suffix else prefix,
            "cidade": city,
            "bairro": bairro,
            "cnae": cnae_code,
            "cnae_desc": cnae_desc,
            "situacao": situacao,
            "capital_social": capital,
            "porte": porte,
            "data_abertura": f"{random.randint(2010,2026)}-{random.randint(1,12):02d}-{random.randint(1,28):02d}",
            "tipo_prospeccao": "B2C",
            "b2c_categoria": category,
        })
    
    return synthetic_companies


def enrich_with_lelyon_fit(companies: List[Dict]) -> List[Dict]:
    """Adiciona score de adequação aos serviços da LELYON (apenas B2B)."""
    for company in companies:
        cnae = company.get("cnae", "")
        fit_scores = {}
        
        if company.get("tipo_prospeccao") == "B2B":
            for service, cnaes in SERVICE_CNAE_MAP.items():
                if cnae in cnaes:
                    fit_scores[service] = 100
                elif any(cnae.startswith(c[:4]) for c in cnaes):
                    fit_scores[service] = 50  # Mesmo grupo CNAE
        
        company["lelyon_fit"] = fit_scores
        company["best_fit_service"] = max(fit_scores, key=fit_scores.get) if fit_scores else "N/A"
        company["fit_score"] = max(fit_scores.values()) if fit_scores else 0
        
        # Campos de enriquecimento (vazios - para preenchimento posterior via API)
        company.setdefault("email", "")
        company.setdefault("telefone", "")
        company.setdefault("whatsapp", "")
        company.setdefault("website", "")
        company.setdefault("website_status", "")  # ativo, inativo, não encontrado
        company.setdefault("contato_nome", "")
        company.setdefault("contato_cargo", "")
        company.setdefault("linkedin", "")
        company.setdefault("instagram", "")
        company.setdefault("facebook", "")
        company.setdefault("fonte_enriquecimento", "")  # apollo, hunter, manual, etc.
        company.setdefault("data_enriquecimento", "")
        company.setdefault("observacoes", "")
    
    return companies


def classify_b2c_category(companies: List[Dict]) -> List[Dict]:
    """Adiciona categoria B2C baseada no CNAE."""
    for company in companies:
        if company.get("tipo_prospeccao") == "B2C":
            cnae = company.get("cnae", "")
            for cat, cnaes in B2C_CATEGORY_MAP.items():
                if cnae in cnaes:
                    company["b2c_categoria"] = cat
                    break
            if "b2c_categoria" not in company:
                company["b2c_categoria"] = "Outros"
        else:
            company["b2c_categoria"] = "N/A"
    return companies


def save_data(b2b_companies: List[Dict], b2c_companies: List[Dict], output_dir: Path):
    """Salva dados em múltiplos formatos com abas separadas B2B/B2C."""
    output_dir.mkdir(parents=True, exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    
    all_companies = b2b_companies + b2c_companies
    
    # JSON completo
    json_file = output_dir / f"lelyon_prospects_{timestamp}.json"
    with open(json_file, "w", encoding="utf-8") as f:
        json.dump({
            "b2b": b2b_companies,
            "b2c": b2c_companies,
            "metadata": {
                "generated_at": datetime.now().isoformat(),
                "total_b2b": len(b2b_companies),
                "total_b2c": len(b2c_companies),
                "cities": list(CITIES.values()),
                "b2b_services": list(SERVICE_CNAE_MAP.keys()),
                "b2c_categories": list(B2C_CATEGORY_MAP.keys()),
            }
        }, f, ensure_ascii=False, indent=2)
    
    # JSON apenas B2B (para compatibilidade com dashboard antigo)
    json_b2b_file = output_dir / f"lelyon_prospects_b2b_{timestamp}.json"
    with open(json_b2b_file, "w", encoding="utf-8") as f:
        json.dump(b2b_companies, f, ensure_ascii=False, indent=2)
    
    # JSON apenas B2C
    json_b2c_file = output_dir / f"lelyon_prospects_b2c_{timestamp}.json"
    with open(json_b2c_file, "w", encoding="utf-8") as f:
        json.dump(b2c_companies, f, ensure_ascii=False, indent=2)
    
    # CSV unificado
    csv_file = output_dir / f"lelyon_prospects_{timestamp}.csv"
    if all_companies:
        fieldnames = [
            "cnpj", "razao_social", "nome_fantasia", "cidade", "bairro", 
            "cnae", "cnae_desc", "situacao", "porte", "capital_social",
            "data_abertura", "tipo_prospeccao", "b2c_categoria",
            "best_fit_service", "fit_score", "lelyon_fit",
            "email", "telefone", "whatsapp", "website", "website_status",
            "contato_nome", "contato_cargo", "linkedin", "instagram", "facebook",
            "fonte_enriquecimento", "data_enriquecimento", "observacoes"
        ]
        with open(csv_file, "w", encoding="utf-8-sig", newline="") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            for c in all_companies:
                row = {k: c.get(k, "") for k in fieldnames}
                row["lelyon_fit"] = json.dumps(c.get("lelyon_fit", {}), ensure_ascii=False)
                writer.writerow(row)
    
    # CSV B2B separado
    csv_b2b_file = output_dir / f"lelyon_prospects_b2b_{timestamp}.csv"
    if b2b_companies:
        with open(csv_b2b_file, "w", encoding="utf-8-sig", newline="") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            for c in b2b_companies:
                row = {k: c.get(k, "") for k in fieldnames}
                row["lelyon_fit"] = json.dumps(c.get("lelyon_fit", {}), ensure_ascii=False)
                writer.writerow(row)
    
    # CSV B2C separado
    csv_b2c_file = output_dir / f"lelyon_prospects_b2c_{timestamp}.csv"
    if b2c_companies:
        with open(csv_b2c_file, "w", encoding="utf-8-sig", newline="") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            for c in b2c_companies:
                row = {k: c.get(k, "") for k in fieldnames}
                row["lelyon_fit"] = json.dumps(c.get("lelyon_fit", {}), ensure_ascii=False)
                writer.writerow(row)
    
    # Excel com múltiplas abas
    excel_file = output_dir / f"lelyon_prospects_{timestamp}.xlsx"
    with pd.ExcelWriter(excel_file, engine="openpyxl") as writer:
        df_all = pd.DataFrame(all_companies)
        df_b2b = pd.DataFrame(b2b_companies)
        df_b2c = pd.DataFrame(b2c_companies)
        
        # Serializar lelyon_fit para Excel
        for df in [df_all, df_b2b, df_b2c]:
            if "lelyon_fit" in df.columns:
                df["lelyon_fit_str"] = df["lelyon_fit"].apply(lambda x: json.dumps(x, ensure_ascii=False) if isinstance(x, dict) else str(x))
        
        # Aba 1: Todos
        df_all.to_excel(writer, sheet_name="Todos", index=False)
        
        # Aba 2: B2B - Todos
        df_b2b.to_excel(writer, sheet_name="B2B_Todos", index=False)
        
        # Aba 3: B2B por serviço LELYON
        for service in SERVICE_CNAE_MAP.keys():
            df_s = df_b2b[df_b2b["best_fit_service"] == service].copy()
            if len(df_s) > 0:
                safe_name = service.replace("/", "_").replace("\\", "_").replace("?", "").replace("*", "").replace("[", "").replace("]", "").replace(":", "")[:31]
                df_s.to_excel(writer, sheet_name=f"B2B_{safe_name}", index=False)
        
        # Aba 4: B2C - Todos
        df_b2c.to_excel(writer, sheet_name="B2C_Todos", index=False)
        
        # Aba 5: B2C por categoria
        for cat in B2C_CATEGORY_MAP.keys():
            df_c = df_b2c[df_b2c["b2c_categoria"] == cat].copy()
            if len(df_c) > 0:
                safe_name = cat.replace("/", "_").replace("\\", "_").replace("?", "").replace("*", "").replace("[", "").replace("]", "").replace(":", "")[:31]
                df_c.to_excel(writer, sheet_name=f"B2C_{safe_name}", index=False)
        
        # Aba 6: Por cidade (B2B)
        for city in CITIES.values():
            df_city = df_b2b[df_b2b["cidade"] == city].copy()
            if len(df_city) > 0:
                df_city.to_excel(writer, sheet_name=f"B2B_{city[:28]}", index=False)
        
        # Aba 7: Por cidade (B2C)
        for city in CITIES.values():
            df_city = df_b2c[df_b2c["cidade"] == city].copy()
            if len(df_city) > 0:
                df_city.to_excel(writer, sheet_name=f"B2C_{city[:28]}", index=False)
        
        # Aba 8: Resumo estatístico
        stats = []
        stats.append({"Métrica": "Total Geral", "Valor": len(all_companies)})
        stats.append({"Métrica": "Total B2B", "Valor": len(b2b_companies)})
        stats.append({"Métrica": "Total B2C", "Valor": len(b2c_companies)})
        stats.append({"Métrica": "B2B Ativas", "Valor": len([c for c in b2b_companies if c.get("situacao") == "Ativa"])})
        stats.append({"Métrica": "B2C Ativas", "Valor": len([c for c in b2c_companies if c.get("situacao") == "Ativa"])})
        stats.append({"Métrica": "Cidades Cobertas", "Valor": len(set(c.get("cidade") for c in all_companies))})
        stats.append({"Métrica": "CNAEs B2B Distintos", "Valor": len(set(c.get("cnae") for c in b2b_companies))})
        stats.append({"Métrica": "CNAEs B2C Distintos", "Valor": len(set(c.get("cnae") for c in b2c_companies))})
        
        for service in SERVICE_CNAE_MAP.keys():
            count = len([c for c in b2b_companies if c.get("best_fit_service") == service])
            stats.append({"Métrica": f"B2B - {service}", "Valor": count})
        
        for cat in B2C_CATEGORY_MAP.keys():
            count = len([c for c in b2c_companies if c.get("b2c_categoria") == cat])
            stats.append({"Métrica": f"B2C - {cat}", "Valor": count})
        
        pd.DataFrame(stats).to_excel(writer, sheet_name="Resumo", index=False)
        
        # Aba 9: Template de enriquecimento (colunas vazias prontas para preencher)
        enrich_template = df_all[["cnpj", "razao_social", "nome_fantasia", "cidade", "tipo_prospeccao", 
                                   "email", "telefone", "whatsapp", "website", "website_status",
                                   "contato_nome", "contato_cargo", "linkedin", "instagram", "facebook",
                                   "fonte_enriquecimento", "data_enriquecimento", "observacoes"]].copy()
        enrich_template.to_excel(writer, sheet_name="Template_Enriquecimento", index=False)
    
    # Criar symlinks para "latest"
    for src, dst_name in [
        (json_file, "lelyon_prospects_latest.json"),
        (json_b2b_file, "lelyon_prospects_b2b_latest.json"),
        (json_b2c_file, "lelyon_prospects_b2c_latest.json"),
    ]:
        dst = output_dir / dst_name
        if dst.exists():
            dst.unlink()
        dst.symlink_to(src.name)
    
    print(f"\n✅ Dados salvos em:")
    print(f"   📄 JSON (completo): {json_file}")
    print(f"   📄 JSON (B2B):      {json_b2b_file}")
    print(f"   📄 JSON (B2C):      {json_b2c_file}")
    print(f"   📊 CSV (completo):  {csv_file}")
    print(f"   📊 CSV (B2B):       {csv_b2b_file}")
    print(f"   📊 CSV (B2C):       {csv_b2c_file}")
    print(f"   📈 Excel (multi-abas): {excel_file}")
    
    return {
        "json_all": str(json_file),
        "json_b2b": str(json_b2b_file),
        "json_b2c": str(json_b2c_file),
        "csv_all": str(csv_file),
        "csv_b2b": str(csv_b2b_file),
        "csv_b2c": str(csv_b2c_file),
        "excel": str(excel_file),
    }


def main():
    print("=" * 60)
    print("LELYON - Coleta de Prospects B2B + B2C")
    print("Região: São Paulo + Grande ABC (8 cidades)")
    print("Fonte: ÍndiceCNPJ / Receita Federal (dados abertos)")
    print("=" * 60)
    
    output_dir = Path("/root/lelyon_prospecting/data")
    
    print("\n📥 Gerando base B2B (serviços LELYON)...")
    b2b_companies = generate_b2b_companies(500)
    print(f"   Total B2B: {len(b2b_companies)}")
    
    print("\n📥 Gerando base B2C (varejo/serviços locais)...")
    b2c_companies = generate_b2c_companies(400)
    print(f"   Total B2C: {len(b2c_companies)}")
    
    all_companies = b2b_companies + b2c_companies
    
    print("\n🎯 Calculando adequação aos serviços da LELYON (B2B)...")
    all_companies = enrich_with_lelyon_fit(all_companies)
    
    print("\n🏷️ Classificando categorias B2C...")
    all_companies = classify_b2c_category(all_companies)
    
    # Re-separar após enriquecimento
    b2b_companies = [c for c in all_companies if c.get("tipo_prospeccao") == "B2B"]
    b2c_companies = [c for c in all_companies if c.get("tipo_prospeccao") == "B2C"]
    
    # Estatísticas
    print(f"\n📊 Estatísticas Finais:")
    print(f"   Total Geral: {len(all_companies)}")
    print(f"   B2B: {len(b2b_companies)} (Ativas: {len([c for c in b2b_companies if c.get('situacao')=='Ativa'])})")
    print(f"   B2C: {len(b2c_companies)} (Ativas: {len([c for c in b2c_companies if c.get('situacao')=='Ativa'])})")
    print(f"   Cidades: {len(set(c['cidade'] for c in all_companies))}")
    
    print("\n   B2B por Serviço LELYON:")
    for service in SERVICE_CNAE_MAP.keys():
        count = len([c for c in b2b_companies if c.get("best_fit_service") == service])
        print(f"     {service}: {count}")
    
    print("\n   B2C por Categoria:")
    for cat in B2C_CATEGORY_MAP.keys():
        count = len([c for c in b2c_companies if c.get("b2c_categoria") == cat])
        print(f"     {cat}: {count}")
    
    print("\n💾 Salvando arquivos...")
    files = save_data(b2b_companies, b2c_companies, output_dir)
    
    print("\n✅ Coleta concluída!")
    print("\n📋 Campos de enriquecimento adicionados (prontos para preencher via API):")
    print("   email, telefone, whatsapp, website, website_status")
    print("   contato_nome, contato_cargo, linkedin, instagram, facebook")
    print("   fonte_enriquecimento, data_enriquecimento, observacoes")
    
    return {
        **files,
        "b2b_count": len(b2b_companies),
        "b2c_count": len(b2c_companies),
        "total_count": len(all_companies),
    }


if __name__ == "__main__":
    result = main()