EBIT = Receita Líquida - Custos Operacionais - Despesas Operacionais

EBIT = Lucro Líquido + Despesas Financeiras + Impostos

EBITDA = EBIT + Depreciação + Amortização

EBITDA = Lucro Líquido + Juros + Impostos + Depreciação + Amortização

import requests
import pandas as pd

def calcular_ebit_ebitda(ticker, token):
    """Calcula EBIT e EBITDA usando dados da brapi.dev"""
    
    url = f"https://brapi.dev/api/quote/{ticker}?modules=incomeStatementHistory,defaultKeyStatistics&token={token}"
    
    try:
        response = requests.get(url)
        data = response.json()
        
        # Dados da DRE
        income_statements = data['results'][0].get('incomeStatementHistory', {}).get('incomeStatementHistory', [])
        stats = data['results'][0].get('defaultKeyStatistics', {})
        
        if not income_statements:
            return {}
        
        # Último período (TTM)
        ultimo_periodo = income_statements[0]
        
        # Extrair dados necessários
        receita_liquida = ultimo_periodo.get('totalRevenue', 0)
        lucro_operacional = ultimo_periodo.get('operatingIncome', 0)  # Já é o EBIT
        lucro_liquido = ultimo_periodo.get('netIncome', 0)
        despesas_financeiras = ultimo_periodo.get('interestExpense', 0)
        impostos = ultimo_periodo.get('incomeTaxExpense', 0)
        
        # EBIT (pode vir direto como operatingIncome)
        ebit = lucro_operacional
        
        # Para EBITDA, precisamos somar depreciação ao EBIT
        # Tentamos extrair da demonstração ou estimamos
        depreciacao_amortizacao = ultimo_periodo.get('totalOperatingExpenses', 0) - ultimo_periodo.get('costOfRevenue', 0) - ultimo_periodo.get('sellingGeneralAdministrative', 0)
        
        # Se não conseguimos extrair, estimamos um percentual da receita
        if depreciacao_amortizacao <= 0:
            # Estimativa conservadora baseada no setor
            estimativa_depreciacao = receita_liquida * 0.03  # 3% da receita
            depreciacao_amortizacao = estimativa_depreciacao
        
        ebitda = ebit + abs(depreciacao_amortizacao)
        
        # Calcular margens
        margem_ebit = (ebit / receita_liquida * 100) if receita_liquida > 0 else 0
        margem_ebitda = (ebitda / receita_liquida * 100) if receita_liquida > 0 else 0
        
        # Múltiplos de mercado
        market_cap = stats.get('marketCap', 0)
        enterprise_value = stats.get('enterpriseValue', 0)
        
        ev_ebit = (enterprise_value / ebit) if ebit > 0 else 0
        ev_ebitda = (enterprise_value / ebitda) if ebitda > 0 else 0
        
        return {
            'ticker': ticker,
            'periodo': '2023 TTM',  # Assumindo TTM
            'receita_liquida': receita_liquida / 1e9,  # Em bilhões
            'ebit': ebit / 1e9,
            'ebitda': ebitda / 1e9,
            'lucro_liquido': lucro_liquido / 1e9,
            'margens': {
                'margem_ebit': margem_ebit,
                'margem_ebitda': margem_ebitda,
                'margem_liquida': (lucro_liquido / receita_liquida * 100) if receita_liquida > 0 else 0
            },
            'multiplos': {
                'ev_ebit': ev_ebit,
                'ev_ebitda': ev_ebitda,
                'p_l': (market_cap / lucro_liquido) if lucro_liquido > 0 else 0
            },
            'enterprise_value': enterprise_value / 1e9,
            'market_cap': market_cap / 1e9
        }
        
    except Exception as e:
        print(f"Erro ao calcular EBIT/EBITDA para {ticker}: {e}")
        return {}

# Exemplo de uso
analise_wege = calcular_ebit_ebitda('WEGE3', 'SEU_TOKEN')

if analise_wege:
    print("⚙️ ANÁLISE EBIT/EBITDA - WEGE3")
    print("=" * 50)
    print(f"Receita Líquida: R$ {analise_wege['receita_liquida']:.2f}B")
    print(f"EBIT: R$ {analise_wege['ebit']:.2f}B")
    print(f"EBITDA: R$ {analise_wege['ebitda']:.2f}B")
    print(f"Lucro Líquido: R$ {analise_wege['lucro_liquido']:.2f}B")
    
    print(f"\n📊 MARGENS:")
    print(f"Margem EBIT: {analise_wege['margens']['margem_ebit']:.1f}%")
    print(f"Margem EBITDA: {analise_wege['margens']['margem_ebitda']:.1f}%")
    print(f"Margem Líquida: {analise_wege['margens']['margem_liquida']:.1f}%")
    
    print(f"\n📈 MÚLTIPLOS:")
    print(f"EV/EBIT: {analise_wege['multiplos']['ev_ebit']:.1f}x")
    print(f"EV/EBITDA: {analise_wege['multiplos']['ev_ebitda']:.1f}x")
    print(f"P/L: {analise_wege['multiplos']['p_l']:.1f}x")

def analisar_setor_ebitda(tickers_setor, nome_setor, token):
    """Analisa EBITDA de um setor específico"""
    
    resultados_setor = []
    
    for ticker in tickers_setor:
        dados = calcular_ebit_ebitda(ticker, token)
        if dados:
            resultados_setor.append(dados)
    
    if not resultados_setor:
        return {}
    
    # Calcular estatísticas do setor
    margens_ebitda = [r['margens']['margem_ebitda'] for r in resultados_setor if r['margens']['margem_ebitda'] > 0]
    multiplos_ev_ebitda = [r['multiplos']['ev_ebitda'] for r in resultados_setor if 0 < r['multiplos']['ev_ebitda'] < 50]
    
    estatisticas_setor = {
        'setor': nome_setor,
        'numero_empresas': len(resultados_setor),
        'margem_ebitda': {
            'media': sum(margens_ebitda) / len(margens_ebitda) if margens_ebitda else 0,
            'mediana': sorted(margens_ebitda)[len(margens_ebitda)//2] if margens_ebitda else 0,
            'minimo': min(margens_ebitda) if margens_ebitda else 0,
            'maximo': max(margens_ebitda) if margens_ebitda else 0
        },
        'ev_ebitda': {
            'media': sum(multiplos_ev_ebitda) / len(multiplos_ev_ebitda) if multiplos_ev_ebitda else 0,
            'mediana': sorted(multiplos_ev_ebitda)[len(multiplos_ev_ebitda)//2] if multiplos_ev_ebitda else 0,
            'minimo': min(multiplos_ev_ebitda) if multiplos_ev_ebitda else 0,
            'maximo': max(multiplos_ev_ebitda) if multiplos_ev_ebitda else 0
        },
        'empresas': resultados_setor
    }
    
    return estatisticas_setor

# Análise por setores
setores_analise = {
    'Industrial': ['WEGE3', 'RAIL3', 'EMBR3', 'GOAU4'],
    'Utilities': ['EGIE3', 'SBSP3', 'CPLE6', 'TAEE11'],
    'Commodities': ['VALE3', 'SUZB3', 'KLBN11', 'GGBR4'],
    'Financeiro': ['ITUB4', 'BBDC4', 'BBAS3', 'BBSE3']
}

analises_setoriais = {}

for setor, tickers in setores_analise.items():
    print(f"Analisando setor {setor}...")
    analise = analisar_setor_ebitda(tickers, setor, 'SEU_TOKEN')
    analises_setoriais[setor] = analise

# Exibir comparação setorial
print("\n🏭 COMPARAÇÃO SETORIAL - EBITDA")
print("=" * 70)

for setor, dados in analises_setoriais.items():
    if dados:
        print(f"\n{setor}:")
        print(f"  Margem EBITDA Média: {dados['margem_ebitda']['media']:.1f}%")
        print(f"  EV/EBITDA Médio: {dados['ev_ebitda']['media']:.1f}x")
        print(f"  Empresas analisadas: {dados['numero_empresas']}")

def avaliar_multiplo_ev_ebitda(ev_ebitda, setor):
    """Avalia atratividade do múltiplo EV/EBITDA por setor"""
    
    # Benchmarks típicos por setor (valores indicativos)
    benchmarks_setor = {
        'Industrial': {'baixo': 8, 'medio': 12, 'alto': 18},
        'Utilities': {'baixo': 6, 'medio': 10, 'alto': 14},
        'Commodities': {'baixo': 4, 'medio': 8, 'alto': 12},
        'Financeiro': {'baixo': 5, 'medio': 10, 'alto': 15},
        'Tecnologia': {'baixo': 15, 'medio': 25, 'alto': 40},
        'Consumo': {'baixo': 10, 'medio': 15, 'alto': 22}
    }
    
    benchmark = benchmarks_setor.get(setor, {'baixo': 8, 'medio': 12, 'alto': 18})
    
    if ev_ebitda <= benchmark['baixo']:
        return {
            'classificacao': 'ATRATIVO',
            'descricao': 'Múltiplo baixo, possível oportunidade',
            'score': 90,
            'cor': 'verde'
        }
    elif ev_ebitda <= benchmark['medio']:
        return {
            'classificacao': 'JUSTO',
            'descricao': 'Múltiplo na média do setor',
            'score': 60,
            'cor': 'amarelo'
        }
    elif ev_ebitda <= benchmark['alto']:
        return {
            'classificacao': 'CARO',
            'descricao': 'Múltiplo acima da média',
            'score': 30,
            'cor': 'laranja'
        }
    else:
        return {
            'classificacao': 'MUITO CARO',
            'descricao': 'Múltiplo muito elevado',
            'score': 10,
            'cor': 'vermelho'
        }

def analisar_atratividade_empresas(empresas_dados):
    """Analisa atratividade de múltiplas empresas"""
    
    analises = []
    
    for empresa in empresas_dados:
        if empresa['multiplos']['ev_ebitda'] > 0:
            # Tentar identificar setor (simplificado)
            setor = identificar_setor_empresa(empresa['ticker'])
            
            avaliacao = avaliar_multiplo_ev_ebitda(
                empresa['multiplos']['ev_ebitda'], 
                setor
            )
            
            analises.append({
                'ticker': empresa['ticker'],
                'ev_ebitda': empresa['multiplos']['ev_ebitda'],
                'margem_ebitda': empresa['margens']['margem_ebitda'],
                'setor': setor,
                'avaliacao': avaliacao
            })
    
    # Ordenar por atratividade (menor EV/EBITDA primeiro)
    return sorted(analises, key=lambda x: x['ev_ebitda'])

def identificar_setor_empresa(ticker):
    """Identifica setor da empresa (simplificado)"""
    setores_mapeamento = {
        'WEGE3': 'Industrial', 'RAIL3': 'Industrial', 'EMBR3': 'Industrial',
        'EGIE3': 'Utilities', 'SBSP3': 'Utilities', 'CPLE6': 'Utilities',
        'VALE3': 'Commodities', 'SUZB3': 'Commodities', 'KLBN11': 'Commodities',
        'ITUB4': 'Financeiro', 'BBDC4': 'Financeiro', 'BBAS3': 'Financeiro'
    }
    return setores_mapeamento.get(ticker, 'Outros')

# Exemplo de análise de atratividade
todas_empresas = []
for setor_dados in analises_setoriais.values():
    if setor_dados and 'empresas' in setor_dados:
        todas_empresas.extend(setor_dados['empresas'])

ranking_atratividade = analisar_atratividade_empresas(todas_empresas)

print("\n🎯 RANKING DE ATRATIVIDADE - EV/EBITDA")
print("=" * 60)

for i, empresa in enumerate(ranking_atratividade[:10], 1):
    print(f"{i:2d}. {empresa['ticker']} - {empresa['setor']}")
    print(f"    EV/EBITDA: {empresa['ev_ebitda']:.1f}x")
    print(f"    Margem EBITDA: {empresa['margem_ebitda']:.1f}%")
    print(f"    Avaliação: {empresa['avaliacao']['classificacao']} - {empresa['avaliacao']['descricao']}")
    print()

def analisar_evolucao_ebitda(ticker, token):
    """Analisa evolução histórica do EBITDA"""
    
    url = f"https://brapi.dev/api/quote/{ticker}?modules=incomeStatementHistory&token={token}"
    
    try:
        response = requests.get(url)
        data = response.json()
        
        income_statements = data['results'][0].get('incomeStatementHistory', {}).get('incomeStatementHistory', [])
        
        if len(income_statements) < 2:
            return {}
        
        evolucao = []
        
        for statement in income_statements[:4]:  # Últimos 4 anos
            ano = datetime.fromtimestamp(statement['endDate']).year
            receita = statement.get('totalRevenue', 0)
            ebit = statement.get('operatingIncome', 0)
            
            # Estimar EBITDA (simplificado)
            ebitda = ebit * 1.3  # Estimativa: EBITDA = 130% do EBIT
            
            margem_ebit = (ebit / receita * 100) if receita > 0 else 0
            margem_ebitda = (ebitda / receita * 100) if receita > 0 else 0
            
            evolucao.append({
                'ano': ano,
                'receita': receita / 1e9,
                'ebit': ebit / 1e9,
                'ebitda': ebitda / 1e9,
                'margem_ebit': margem_ebit,
                'margem_ebitda': margem_ebitda
            })
        
        # Ordenar por ano
        evolucao = sorted(evolucao, key=lambda x: x['ano'])
        
        # Calcular crescimentos
        tendencias = {}
        if len(evolucao) >= 2:
            ultimo = evolucao[-1]
            anterior = evolucao[-2]
            
            tendencias = {
                'crescimento_receita': ((ultimo['receita'] - anterior['receita']) / anterior['receita'] * 100) if anterior['receita'] > 0 else 0,
                'crescimento_ebitda': ((ultimo['ebitda'] - anterior['ebitda']) / anterior['ebitda'] * 100) if anterior['ebitda'] > 0 else 0,
                'evolucao_margem': ultimo['margem_ebitda'] - anterior['margem_ebitda'],
                'consistencia_margem': calcular_consistencia_margem([e['margem_ebitda'] for e in evolucao])
            }
        
        return {
            'ticker': ticker,
            'evolucao_anual': evolucao,
            'tendencias': tendencias
        }
        
    except Exception as e:
        print(f"Erro ao analisar evolução de {ticker}: {e}")
        return {}

def calcular_consistencia_margem(margens):
    """Calcula consistência da margem EBITDA"""
    if len(margens) < 2:
        return 0
    
    media = sum(margens) / len(margens)
    desvio = sum((m - media) ** 2 for m in margens) / len(margens)
    desvio_padrao = desvio ** 0.5
    
    # Coeficiente de variação (menor = mais consistente)
    cv = (desvio_padrao / media * 100) if media > 0 else 100
    
    # Score de consistência (0-100, maior = mais consistente)
    score = max(0, 100 - cv * 2)
    
    return score

# Exemplo de análise temporal
evolucao_wege = analisar_evolucao_ebitda('WEGE3', 'SEU_TOKEN')

if evolucao_wege:
    print("📈 EVOLUÇÃO TEMPORAL - WEGE3")
    print("=" * 50)
    
    for ano_data in evolucao_wege['evolucao_anual']:
        print(f"\n📅 {ano_data['ano']}:")
        print(f"  Receita: R$ {ano_data['receita']:.1f}B")
        print(f"  EBITDA: R$ {ano_data['ebitda']:.1f}B")
        print(f"  Margem EBITDA: {ano_data['margem_ebitda']:.1f}%")
    
    if evolucao_wege['tendencias']:
        print(f"\n🔍 TENDÊNCIAS:")
        print(f"  Crescimento Receita: {evolucao_wege['tendencias']['crescimento_receita']:+.1f}%")
        print(f"  Crescimento EBITDA: {evolucao_wege['tendencias']['crescimento_ebitda']:+.1f}%")
        print(f"  Evolução Margem: {evolucao_wege['tendencias']['evolucao_margem']:+.1f} p.p.")
        print(f"  Consistência Margem: {evolucao_wege['tendencias']['consistencia_margem']:.1f}/100")

def identificar_armadilhas_ebitda(dados_empresa):
    """Identifica possíveis armadilhas na análise de EBITDA"""
    
    alertas = []
    
    # 1. EBITDA muito maior que EBIT (depreciação excessiva)
    ebit = dados_empresa.get('ebit', 0)
    ebitda = dados_empresa.get('ebitda', 0)
    
    if ebit > 0 and ebitda > 0:
        diferenca_pct = ((ebitda - ebit) / ebit * 100)
        if diferenca_pct > 50:  # Depreciação > 50% do EBIT
            alertas.append({
                'tipo': 'DEPRECIACAO_ALTA',
                'descricao': f'Depreciação representa {diferenca_pct:.1f}% do EBIT',
                'severidade': 'MEDIA',
                'impacto': 'EBITDA pode superestimar geração de caixa'
            })
    
    # 2. Margem EBITDA muito alta para o setor
    margem_ebitda = dados_empresa['margens']['margem_ebitda']
    ticker = dados_empresa['ticker']
    setor = identificar_setor_empresa(ticker)
    
    margens_tipicas = {
        'Industrial': 15,
        'Utilities': 25,
        'Commodities': 20,
        'Financeiro': 30,
        'Tecnologia': 25,
        'Consumo': 12
    }
    
    margem_tipica = margens_tipicas.get(setor, 15)
    
    if margem_ebitda > margem_tipica * 1.5:  # 50% acima da média
        alertas.append({
            'tipo': 'MARGEM_ATIPICA',
            'descricao': f'Margem EBITDA {margem_ebitda:.1f}% muito acima da média do setor ({margem_tipica}%)',
            'severidade': 'BAIXA',
            'impacto': 'Verificar sustentabilidade da margem'
        })
    
    # 3. EV/EBITDA muito baixo (possível distressed)
    ev_ebitda = dados_empresa['multiplos']['ev_ebitda']
    
    if 0 < ev_ebitda < 3:
        alertas.append({
            'tipo': 'MULTIPLO_BAIXO',
            'descricao': f'EV/EBITDA {ev_ebitda:.1f}x muito baixo',
            'severidade': 'ALTA',
            'impacto': 'Possível empresa em dificuldades'
        })
    
    # 4. EBITDA positivo mas lucro líquido negativo
    lucro_liquido = dados_empresa.get('lucro_liquido', 0)
    
    if ebitda > 0 and lucro_liquido < 0:
        alertas.append({
            'tipo': 'EBITDA_POSITIVO_PREJUIZO',
            'descricao': 'EBITDA positivo mas empresa tem prejuízo',
            'severidade': 'ALTA',
            'impacto': 'Estrutura de capital ou impostos problemáticos'
        })
    
    return alertas

def avaliar_qualidade_ebitda(dados_empresa):
    """Avalia qualidade do EBITDA"""
    
    alertas = identificar_armadilhas_ebitda(dados_empresa)
    
    # Score de qualidade (0-100)
    score_qualidade = 100
    
    for alerta in alertas:
        if alerta['severidade'] == 'ALTA':
            score_qualidade -= 30
        elif alerta['severidade'] == 'MEDIA':
            score_qualidade -= 15
        else:
            score_qualidade -= 5
    
    score_qualidade = max(0, score_qualidade)
    
    # Classificação
    if score_qualidade >= 80:
        classificacao = 'EXCELENTE'
    elif score_qualidade >= 60:
        classificacao = 'BOA'
    elif score_qualidade >= 40:
        classificacao = 'MÉDIA'
    else:
        classificacao = 'BAIXA'
    
    return {
        'score_qualidade': score_qualidade,
        'classificacao': classificacao,
        'alertas': alertas,
        'recomendacao': gerar_recomendacao_qualidade(score_qualidade, alertas)
    }

def gerar_recomendacao_qualidade(score, alertas):
    """Gera recomendação baseada na qualidade do EBITDA"""
    
    if score >= 80:
        return "EBITDA de alta qualidade, confiável para análise"
    elif score >= 60:
        return "EBITDA adequado, mas atenção aos pontos identificados"
    elif score >= 40:
        return "EBITDA com ressalvas, validar com outros indicadores"
    else:
        return "EBITDA questionável, usar com muito cuidado"

# Exemplo de avaliação de qualidade
for empresa in todas_empresas[:3]:  # Analisar 3 empresas
    avaliacao = avaliar_qualidade_ebitda(empresa)
    
    print(f"\n🔍 QUALIDADE EBITDA - {empresa['ticker']}")
    print("=" * 40)
    print(f"Score de Qualidade: {avaliacao['score_qualidade']}/100")
    print(f"Classificação: {avaliacao['classificacao']}")
    print(f"Recomendação: {avaliacao['recomendacao']}")
    
    if avaliacao['alertas']:
        print("\n⚠️ Alertas identificados:")
        for alerta in avaliacao['alertas']:
            print(f"  • {alerta['descricao']}")
            print(f"    Impacto: {alerta['impacto']}")

class MonitorEBITDA:
    def __init__(self, token):
        self.token = token
        self.watchlist = []
    
    def adicionar_watchlist(self, tickers):
        """Adiciona tickers à watchlist"""
        if isinstance(tickers, str):
            tickers = [tickers]
        self.watchlist.extend(tickers)
        self.watchlist = list(set(self.watchlist))  # Remove duplicatas
    
    def gerar_relatorio_watchlist(self):
        """Gera relatório da watchlist"""
        
        relatorio = {
            'data': datetime.now().strftime('%d/%m/%Y %H:%M'),
            'total_empresas': len(self.watchlist),
            'empresas': [],
            'estatisticas': {},
            'alertas': []
        }
        
        dados_empresas = []
        
        for ticker in self.watchlist:
            dados = calcular_ebit_ebitda(ticker, self.token)
            if dados:
                # Adicionar avaliação de qualidade
                qualidade = avaliar_qualidade_ebitda(dados)
                dados['qualidade_ebitda'] = qualidade
                
                dados_empresas.append(dados)
        
        relatorio['empresas'] = dados_empresas
        
        # Calcular estatísticas
        if dados_empresas:
            margens_ebitda = [e['margens']['margem_ebitda'] for e in dados_empresas]
            multiplos_ev = [e['multiplos']['ev_ebitda'] for e in dados_empresas if 0 < e['multiplos']['ev_ebitda'] < 50]
            
            relatorio['estatisticas'] = {
                'margem_ebitda_media': sum(margens_ebitda) / len(margens_ebitda),
                'ev_ebitda_medio': sum(multiplos_ev) / len(multiplos_ev) if multiplos_ev else 0,
                'melhor_margem': max(margens_ebitda),
                'menor_multiplo': min(multiplos_ev) if multiplos_ev else 0
            }
            
            # Identificar alertas gerais
            for empresa in dados_empresas:
                if empresa['qualidade_ebitda']['score_qualidade'] < 60:
                    relatorio['alertas'].append(f"{empresa['ticker']}: Qualidade EBITDA baixa")
                
                if empresa['multiplos']['ev_ebitda'] > 20:
                    relatorio['alertas'].append(f"{empresa['ticker']}: EV/EBITDA muito alto ({empresa['multiplos']['ev_ebitda']:.1f}x)")
        
        return relatorio
    
    def exportar_csv(self, relatorio, filename=None):
        """Exporta relatório para CSV"""
        
        if not filename:
            filename = f"relatorio_ebitda_{datetime.now().strftime('%Y%m%d')}.csv"
        
        dados_csv = []
        
        for empresa in relatorio['empresas']:
            dados_csv.append({
                'Ticker': empresa['ticker'],
                'Receita (R$B)': empresa['receita_liquida'],
                'EBITDA (R$B)': empresa['ebitda'],
                'Margem EBITDA (%)': empresa['margens']['margem_ebitda'],
                'EV/EBITDA': empresa['multiplos']['ev_ebitda'],
                'Qualidade EBITDA': empresa['qualidade_ebitda']['classificacao'],
                'Score Qualidade': empresa['qualidade_ebitda']['score_qualidade']
            })
        
        df = pd.DataFrame(dados_csv)
        df.to_csv(filename, index=False)
        
        return filename

# Exemplo de uso do monitor
monitor = MonitorEBITDA('SEU_TOKEN')

# Adicionar empresas à watchlist
monitor.adicionar_watchlist(['WEGE3', 'VALE3', 'EGIE3', 'ITUB4', 'RAIL3'])

# Gerar relatório
relatorio_monitor = monitor.gerar_relatorio_watchlist()

print("📊 RELATÓRIO WATCHLIST - EBITDA")
print("=" * 50)
print(f"Data: {relatorio_monitor['data']}")
print(f"Empresas monitoradas: {relatorio_monitor['total_empresas']}")

if relatorio_monitor['estatisticas']:
    print(f"\n📈 ESTATÍSTICAS GERAIS:")
    print(f"Margem EBITDA Média: {relatorio_monitor['estatisticas']['margem_ebitda_media']:.1f}%")
    print(f"EV/EBITDA Médio: {relatorio_monitor['estatisticas']['ev_ebitda_medio']:.1f}x")
    print(f"Melhor Margem: {relatorio_monitor['estatisticas']['melhor_margem']:.1f}%")

if relatorio_monitor['alertas']:
    print(f"\n⚠️ ALERTAS:")
    for alerta in relatorio_monitor['alertas']:
        print(f"  • {alerta}")

# Exportar para CSV
arquivo_csv = monitor.exportar_csv(relatorio_monitor)
print(f"\n📄 Relatório exportado para: {arquivo_csv}")

def screening_ebitda_strategy(universo_acoes, estrategia, token):
    """Estratégias de screening baseadas em EBITDA"""
    
    estrategias = {
        'growth': {
            'nome': 'Crescimento EBITDA',
            'criterios': {
                'margem_ebitda_min': 15,
                'ev_ebitda_max': 15,
                'crescimento_min': 10
            }
        },
        'value': {
            'nome': 'Value EBITDA',
            'criterios': {
                'ev_ebitda_max': 8,
                'margem_ebitda_min': 10,
                'qualidade_min': 70
            }
        },
        'quality': {
            'nome': 'Qualidade EBITDA',
            'criterios': {
                'margem_ebitda_min': 20,
                'consistencia_min': 80,
                'qualidade_min': 80
            }
        }
    }
    
    if estrategia not in estrategias:
        return []
    
    config = estrategias[estrategia]
    criterios = config['criterios']
    
    candidatos = []
    
    for ticker in universo_acoes:
        dados = calcular_ebit_ebitda(ticker, token)
        if not dados:
            continue
        
        # Analisar evolução para crescimento
        if estrategia == 'growth':
            evolucao = analisar_evolucao_ebitda(ticker, token)
            crescimento_ebitda = 0
            if evolucao and evolucao['tendencias']:
                crescimento_ebitda = evolucao['tendencias']['crescimento_ebitda']
        
        # Avaliar qualidade
        qualidade = avaliar_qualidade_ebitda(dados)
        
        # Aplicar critérios da estratégia
        aprovado = True
        motivos_reprovacao = []
        
        # Margem EBITDA mínima
        if dados['margens']['margem_ebitda'] < criterios.get('margem_ebitda_min', 0):
            aprovado = False
            motivos_reprovacao.append(f"Margem EBITDA baixa: {dados['margens']['margem_ebitda']:.1f}%")
        
        # EV/EBITDA máximo
        if dados['multiplos']['ev_ebitda'] > criterios.get('ev_ebitda_max', 999):
            aprovado = False
            motivos_reprovacao.append(f"EV/EBITDA alto: {dados['multiplos']['ev_ebitda']:.1f}x")
        
        # Qualidade mínima
        if qualidade['score_qualidade'] < criterios.get('qualidade_min', 0):
            aprovado = False
            motivos_reprovacao.append(f"Qualidade baixa: {qualidade['score_qualidade']}/100")
        
        # Crescimento mínimo (se aplicável)
        if estrategia == 'growth' and crescimento_ebitda < criterios.get('crescimento_min', 0):
            aprovado = False
            motivos_reprovacao.append(f"Crescimento baixo: {crescimento_ebitda:.1f}%")
        
        if aprovado:
            candidatos.append({
                'ticker': ticker,
                'dados': dados,
                'qualidade': qualidade,
                'crescimento': crescimento_ebitda if estrategia == 'growth' else None,
                'score_estrategia': calcular_score_estrategia(dados, qualidade, estrategia)
            })
        else:
            print(f"{ticker} reprovado: {', '.join(motivos_reprovacao)}")
    
    # Ordenar por score da estratégia
    return sorted(candidatos, key=lambda x: x['score_estrategia'], reverse=True)

def calcular_score_estrategia(dados, qualidade, estrategia):
    """Calcula score específico para cada estratégia"""
    
    if estrategia == 'value':
        # Para value: menor EV/EBITDA é melhor
        ev_ebitda = dados['multiplos']['ev_ebitda']
        score_multiplo = max(0, 100 - ev_ebitda * 5)  # Score decresce com múltiplo
        score_margem = min(100, dados['margens']['margem_ebitda'] * 3)
        return (score_multiplo * 0.6 + score_margem * 0.4)
    
    elif estrategia == 'quality':
        # Para quality: foco na qualidade e margem
        score_qualidade = qualidade['score_qualidade']
        score_margem = min(100, dados['margens']['margem_ebitda'] * 3)
        return (score_qualidade * 0.7 + score_margem * 0.3)
    
    else:  # growth
        # Para growth: foco em margem e crescimento
        score_margem = min(100, dados['margens']['margem_ebitda'] * 3)
        # Score de crescimento seria calculado se tivéssemos os dados
        return score_margem

# Executar estratégias
universo_teste = ['WEGE3', 'VALE3', 'EGIE3', 'RAIL3', 'EMBR3', 'SUZB3']

for estrategia in ['value', 'quality']:
    print(f"\n🎯 ESTRATÉGIA: {estrategia.upper()}")
    print("=" * 50)
    
    resultados = screening_ebitda_strategy(universo_teste, estrategia, 'SEU_TOKEN')
    
    for i, resultado in enumerate(resultados[:3], 1):
        dados = resultado['dados']
        print(f"{i}. {dados['ticker']}")
        print(f"   EBITDA: R$ {dados['ebitda']:.1f}B")
        print(f"   Margem: {dados['margens']['margem_ebitda']:.1f}%")
        print(f"   EV/EBITDA: {dados['multiplos']['ev_ebitda']:.1f}x")
        print(f"   Qualidade: {resultado['qualidade']['classificacao']}")
        print(f"   Score: {resultado['score_estrategia']:.1f}")
        print()