import requests
import pandas as pd
from datetime import datetime, timedelta

class AnalisadorFundamentalista:
    def __init__(self, token):
        self.token = token
        self.base_url = "https://brapi.dev/api"
    
    def analise_completa(self, ticker):
        """Realiza análise fundamentalista completa de uma ação"""
        
        # Obter dados da empresa
        dados_empresa = self.obter_dados_empresa(ticker)
        
        # Análise de múltiplos
        multiplos = self.calcular_multiplos(ticker)
        
        # Análise de rentabilidade
        rentabilidade = self.analisar_rentabilidade(ticker)
        
        # Análise de endividamento
        endividamento = self.analisar_endividamento(ticker)
        
        # Análise de crescimento
        crescimento = self.analisar_crescimento(ticker)
        
        # Score final
        score_final = self.calcular_score_total(multiplos, rentabilidade, endividamento, crescimento)
        
        return {
            'ticker': ticker,
            'dados_empresa': dados_empresa,
            'multiplos': multiplos,
            'rentabilidade': rentabilidade,
            'endividamento': endividamento,
            'crescimento': crescimento,
            'score_final': score_final,
            'recomendacao': self.gerar_recomendacao(score_final)
        }
    
    def obter_dados_empresa(self, ticker):
        """Obtém informações básicas da empresa"""
        url = f"{self.base_url}/quote/{ticker}?modules=summaryProfile,defaultKeyStatistics&token={self.token}"
        
        try:
            response = requests.get(url)
            data = response.json()
            
            acao = data['results'][0]
            profile = acao.get('summaryProfile', {})
            stats = acao.get('defaultKeyStatistics', {})
            
            return {
                'nome': acao['longName'],
                'setor': profile.get('sector', 'N/A'),
                'industria': profile.get('industry', 'N/A'),
                'funcionarios': profile.get('fullTimeEmployees', 0),
                'market_cap': stats.get('marketCap', 0) / 1e9,  # Em bilhões
                'preco_atual': acao['regularMarketPrice'],
                'variacao_52w': {
                    'minimo': acao.get('fiftyTwoWeekLow', 0),
                    'maximo': acao.get('fiftyTwoWeekHigh', 0)
                }
            }
        except Exception as e:
            print(f"Erro ao obter dados da empresa {ticker}: {e}")
            return {}
    
    def calcular_multiplos(self, ticker):
        """Calcula múltiplos de valuation"""
        url = f"{self.base_url}/quote/{ticker}?modules=defaultKeyStatistics,financialData&token={self.token}"
        
        try:
            response = requests.get(url)
            data = response.json()
            
            acao = data['results'][0]
            stats = acao.get('defaultKeyStatistics', {})
            financials = acao.get('financialData', {})
            
            multiplos = {
                'pl': stats.get('forwardPE', 0),
                'pvp': stats.get('priceToBook', 0),
                'p_vendas': stats.get('priceToSalesTrailing12Months', 0),
                'ev_ebitda': stats.get('enterpriseToEbitda', 0),
                'ev_receita': stats.get('enterpriseToRevenue', 0),
                'peg_ratio': stats.get('pegRatio', 0),
                'dividend_yield': stats.get('dividendYield', 0) * 100
            }
            
            # Scores dos múltiplos (0-100)
            scores = {
                'score_pl': self.score_pl(multiplos['pl']),
                'score_pvp': self.score_pvp(multiplos['pvp']),
                'score_ev_ebitda': self.score_ev_ebitda(multiplos['ev_ebitda']),
                'score_dy': self.score_dy(multiplos['dividend_yield'])
            }
            
            multiplos.update(scores)
            multiplos['score_medio_multiplos'] = sum(scores.values()) / len(scores)
            
            return multiplos
            
        except Exception as e:
            print(f"Erro ao calcular múltiplos para {ticker}: {e}")
            return {}
    
    def analisar_rentabilidade(self, ticker):
        """Analisa indicadores de rentabilidade"""
        url = f"{self.base_url}/quote/{ticker}?modules=financialData&token={self.token}"
        
        try:
            response = requests.get(url)
            data = response.json()
            
            financials = data['results'][0].get('financialData', {})
            
            rentabilidade = {
                'roe': financials.get('returnOnEquity', 0) * 100,
                'roa': financials.get('returnOnAssets', 0) * 100,
                'roic': self.calcular_roic(ticker),  # Calculado separadamente
                'margem_bruta': financials.get('grossMargins', 0) * 100,
                'margem_operacional': financials.get('operatingMargins', 0) * 100,
                'margem_liquida': financials.get('profitMargins', 0) * 100
            }
            
            # Scores de rentabilidade
            scores = {
                'score_roe': self.score_roe(rentabilidade['roe']),
                'score_roa': self.score_roa(rentabilidade['roa']),
                'score_margem_liquida': self.score_margem_liquida(rentabilidade['margem_liquida'])
            }
            
            rentabilidade.update(scores)
            rentabilidade['score_medio_rentabilidade'] = sum(scores.values()) / len(scores)
            
            return rentabilidade
            
        except Exception as e:
            print(f"Erro ao analisar rentabilidade para {ticker}: {e}")
            return {}
    
    def analisar_endividamento(self, ticker):
        """Analisa estrutura de capital e endividamento"""
        url = f"{self.base_url}/quote/{ticker}?modules=defaultKeyStatistics,financialData&token={self.token}"
        
        try:
            response = requests.get(url)
            data = response.json()
            
            stats = data['results'][0].get('defaultKeyStatistics', {})
            financials = data['results'][0].get('financialData', {})
            
            endividamento = {
                'divida_patrimonio': financials.get('debtToEquity', 0),
                'liquidez_corrente': financials.get('currentRatio', 0),
                'liquidez_seca': financials.get('quickRatio', 0),
                'cobertura_juros': stats.get('interestCoverage', 0),
                'divida_ebitda': self.calcular_divida_ebitda(ticker)
            }
            
            # Scores de endividamento
            scores = {
                'score_liquidez': self.score_liquidez_corrente(endividamento['liquidez_corrente']),
                'score_endividamento': self.score_endividamento(endividamento['divida_patrimonio'])
            }
            
            endividamento.update(scores)
            endividamento['score_medio_endividamento'] = sum(scores.values()) / len(scores)
            
            return endividamento
            
        except Exception as e:
            print(f"Erro ao analisar endividamento para {ticker}: {e}")
            return {}
    
    def analisar_crescimento(self, ticker):
        """Analisa indicadores de crescimento"""
        # Esta função seria expandida com dados históricos
        # Por ora, usar dados disponíveis na API
        
        url = f"{self.base_url}/quote/{ticker}?modules=defaultKeyStatistics&token={self.token}"
        
        try:
            response = requests.get(url)
            data = response.json()
            
            stats = data['results'][0].get('defaultKeyStatistics', {})
            
            crescimento = {
                'crescimento_receita_ttm': stats.get('revenueGrowth', 0) * 100,
                'crescimento_lucro_ttm': stats.get('earningsGrowth', 0) * 100,
                'payout_ratio': stats.get('payoutRatio', 0) * 100,
                'retencao_lucros': 100 - (stats.get('payoutRatio', 0) * 100),
                'reinvestimento': self.calcular_taxa_reinvestimento(ticker)
            }
            
            # Score de crescimento
            score_crescimento = self.score_crescimento(
                crescimento['crescimento_receita_ttm'],
                crescimento['crescimento_lucro_ttm']
            )
            
            crescimento['score_crescimento'] = score_crescimento
            
            return crescimento
            
        except Exception as e:
            print(f"Erro ao analisar crescimento para {ticker}: {e}")
            return {}
    
    # Métodos auxiliares para scoring
    def score_pl(self, pl):
        """Score P/L (0-100, maior score = melhor)"""
        if pl <= 0: return 0
        elif pl <= 8: return 100
        elif pl <= 12: return 80
        elif pl <= 18: return 60
        elif pl <= 25: return 40
        else: return 20
    
    def score_pvp(self, pvp):
        """Score P/VP (0-100, maior score = melhor)"""
        if pvp <= 0: return 0
        elif pvp <= 1: return 100
        elif pvp <= 1.5: return 80
        elif pvp <= 2: return 60
        elif pvp <= 3: return 40
        else: return 20
    
    def score_ev_ebitda(self, ev_ebitda):
        """Score EV/EBITDA (0-100, maior score = melhor)"""
        if ev_ebitda <= 0: return 0
        elif ev_ebitda <= 6: return 100
        elif ev_ebitda <= 10: return 80
        elif ev_ebitda <= 15: return 60
        elif ev_ebitda <= 20: return 40
        else: return 20
    
    def score_dy(self, dy):
        """Score Dividend Yield (0-100, maior score = melhor)"""
        if dy >= 8: return 100
        elif dy >= 6: return 80
        elif dy >= 4: return 60
        elif dy >= 2: return 40
        else: return 20
    
    def score_roe(self, roe):
        """Score ROE (0-100, maior score = melhor)"""
        if roe >= 25: return 100
        elif roe >= 20: return 80
        elif roe >= 15: return 60
        elif roe >= 10: return 40
        else: return 20
    
    def score_roa(self, roa):
        """Score ROA (0-100, maior score = melhor)"""
        if roa >= 15: return 100
        elif roa >= 10: return 80
        elif roa >= 7: return 60
        elif roa >= 5: return 40
        else: return 20
    
    def score_margem_liquida(self, margem):
        """Score Margem Líquida (0-100, maior score = melhor)"""
        if margem >= 20: return 100
        elif margem >= 15: return 80
        elif margem >= 10: return 60
        elif margem >= 5: return 40
        else: return 20
    
    def score_liquidez_corrente(self, liquidez):
        """Score Liquidez Corrente (0-100, maior score = melhor)"""
        if liquidez >= 2: return 100
        elif liquidez >= 1.5: return 80
        elif liquidez >= 1.2: return 60
        elif liquidez >= 1: return 40
        else: return 20
    
    def score_endividamento(self, debt_equity):
        """Score Endividamento (0-100, maior score = melhor)"""
        if debt_equity <= 0.3: return 100
        elif debt_equity <= 0.5: return 80
        elif debt_equity <= 0.8: return 60
        elif debt_equity <= 1.2: return 40
        else: return 20
    
    def score_crescimento(self, crescimento_receita, crescimento_lucro):
        """Score Crescimento (0-100, maior score = melhor)"""
        crescimento_medio = (crescimento_receita + crescimento_lucro) / 2
        
        if crescimento_medio >= 20: return 100
        elif crescimento_medio >= 15: return 80
        elif crescimento_medio >= 10: return 60
        elif crescimento_medio >= 5: return 40
        else: return 20
    
    def calcular_roic(self, ticker):
        """Calcula ROIC (simplificado)"""
        # Implementação simplificada - na prática seria mais complexa
        return 0  # Placeholder
    
    def calcular_divida_ebitda(self, ticker):
        """Calcula Dívida/EBITDA"""
        # Implementação simplificada
        return 0  # Placeholder
    
    def calcular_taxa_reinvestimento(self, ticker):
        """Calcula taxa de reinvestimento"""
        # Implementação simplificada
        return 0  # Placeholder
    
    def calcular_score_total(self, multiplos, rentabilidade, endividamento, crescimento):
        """Calcula score total ponderado"""
        
        scores = [
            multiplos.get('score_medio_multiplos', 0),
            rentabilidade.get('score_medio_rentabilidade', 0),
            endividamento.get('score_medio_endividamento', 0),
            crescimento.get('score_crescimento', 0)
        ]
        
        # Pesos: Múltiplos 30%, Rentabilidade 35%, Endividamento 20%, Crescimento 15%
        pesos = [0.30, 0.35, 0.20, 0.15]
        
        score_total = sum(score * peso for score, peso in zip(scores, pesos))
        
        return {
            'score_total': score_total,
            'scores_individuais': {
                'multiplos': scores[0],
                'rentabilidade': scores[1],
                'endividamento': scores[2],
                'crescimento': scores[3]
            }
        }
    
    def gerar_recomendacao(self, score_final):
        """Gera recomendação baseada no score"""
        score = score_final['score_total']
        
        if score >= 80:
            return {
                'recomendacao': 'COMPRA FORTE',
                'descricao': 'Empresa com excelentes fundamentos',
                'cor': 'verde'
            }
        elif score >= 60:
            return {
                'recomendacao': 'COMPRA',
                'descricao': 'Empresa com bons fundamentos',
                'cor': 'verde-claro'
            }
        elif score >= 40:
            return {
                'recomendacao': 'NEUTRO',
                'descricao': 'Empresa com fundamentos medianos',
                'cor': 'amarelo'
            }
        elif score >= 20:
            return {
                'recomendacao': 'VENDA',
                'descricao': 'Empresa com fundamentos fracos',
                'cor': 'laranja'
            }
        else:
            return {
                'recomendacao': 'VENDA FORTE',
                'descricao': 'Empresa com fundamentos ruins',
                'cor': 'vermelho'
            }

# Exemplo de uso do analisador
analisador = AnalisadorFundamentalista('SEU_TOKEN')

# Analisar uma empresa
analise_petr4 = analisador.analise_completa('PETR4')

print("📊 ANÁLISE FUNDAMENTALISTA - PETR4")
print("=" * 50)
print(f"Empresa: {analise_petr4['dados_empresa']['nome']}")
print(f"Setor: {analise_petr4['dados_empresa']['setor']}")
print(f"Market Cap: R$ {analise_petr4['dados_empresa']['market_cap']:.1f}B")

print(f"\n📈 MÚLTIPLOS:")
print(f"P/L: {analise_petr4['multiplos']['pl']:.1f}")
print(f"P/VP: {analise_petr4['multiplos']['pvp']:.2f}")
print(f"EV/EBITDA: {analise_petr4['multiplos']['ev_ebitda']:.1f}")
print(f"DY: {analise_petr4['multiplos']['dividend_yield']:.2f}%")

print(f"\n💰 RENTABILIDADE:")
print(f"ROE: {analise_petr4['rentabilidade']['roe']:.1f}%")
print(f"ROA: {analise_petr4['rentabilidade']['roa']:.1f}%")
print(f"Margem Líquida: {analise_petr4['rentabilidade']['margem_liquida']:.1f}%")

print(f"\n🎯 SCORE FINAL: {analise_petr4['score_final']['score_total']:.1f}/100")
print(f"Recomendação: {analise_petr4['recomendacao']['recomendacao']}")
print(f"Descrição: {analise_petr4['recomendacao']['descricao']}")

def analisar_dre(ticker, token):
    """Analisa Demonstração de Resultados"""
    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 not income_statements:
            return {}
        
        # Analisar últimos 3 anos
        analise_dre = []
        
        for statement in income_statements[:3]:
            ano = datetime.fromtimestamp(statement['endDate']).year
            
            receita_liquida = statement.get('totalRevenue', 0)
            custo_vendas = statement.get('costOfRevenue', 0)
            lucro_bruto = statement.get('grossProfit', 0)
            lucro_operacional = statement.get('operatingIncome', 0)
            lucro_liquido = statement.get('netIncome', 0)
            
            # Calcular margens
            margem_bruta = (lucro_bruto / receita_liquida * 100) if receita_liquida > 0 else 0
            margem_operacional = (lucro_operacional / receita_liquida * 100) if receita_liquida > 0 else 0
            margem_liquida = (lucro_liquido / receita_liquida * 100) if receita_liquida > 0 else 0
            
            analise_dre.append({
                'ano': ano,
                'receita_liquida': receita_liquida / 1e9,  # Em bilhões
                'lucro_bruto': lucro_bruto / 1e9,
                'lucro_operacional': lucro_operacional / 1e9,
                'lucro_liquido': lucro_liquido / 1e9,
                'margem_bruta': margem_bruta,
                'margem_operacional': margem_operacional,
                'margem_liquida': margem_liquida
            })
        
        # Calcular tendências
        if len(analise_dre) >= 2:
            receita_crescimento = ((analise_dre[0]['receita_liquida'] - analise_dre[1]['receita_liquida']) / 
                                 analise_dre[1]['receita_liquida'] * 100)
            lucro_crescimento = ((analise_dre[0]['lucro_liquido'] - analise_dre[1]['lucro_liquido']) / 
                               analise_dre[1]['lucro_liquido'] * 100)
        else:
            receita_crescimento = 0
            lucro_crescimento = 0
        
        return {
            'dados_anuais': analise_dre,
            'tendencias': {
                'crescimento_receita': receita_crescimento,
                'crescimento_lucro': lucro_crescimento,
                'evolucao_margem_liquida': analise_dre[0]['margem_liquida'] - analise_dre[1]['margem_liquida'] if len(analise_dre) >= 2 else 0
            }
        }
        
    except Exception as e:
        print(f"Erro ao analisar DRE de {ticker}: {e}")
        return {}

# Exemplo de análise DRE
dre_analise = analisar_dre('WEGE3', 'SEU_TOKEN')

if dre_analise:
    print("📋 ANÁLISE DRE - WEGE3")
    print("=" * 40)
    
    for ano_data in dre_analise['dados_anuais']:
        print(f"\n📅 Ano {ano_data['ano']}:")
        print(f"  Receita: R$ {ano_data['receita_liquida']:.1f}B")
        print(f"  Lucro Líquido: R$ {ano_data['lucro_liquido']:.1f}B")
        print(f"  Margem Líquida: {ano_data['margem_liquida']:.1f}%")
    
    print(f"\n📈 TENDÊNCIAS:")
    print(f"  Crescimento Receita: {dre_analise['tendencias']['crescimento_receita']:+.1f}%")
    print(f"  Crescimento Lucro: {dre_analise['tendencias']['crescimento_lucro']:+.1f}%")
    print(f"  Evolução Margem: {dre_analise['tendencias']['evolucao_margem_liquida']:+.1f} p.p.")

def analisar_balanco(ticker, token):
    """Analisa Balanço Patrimonial"""
    url = f"https://brapi.dev/api/quote/{ticker}?modules=balanceSheetHistory&token={token}"
    
    try:
        response = requests.get(url)
        data = response.json()
        
        balance_sheets = data['results'][0].get('balanceSheetHistory', {}).get('balanceSheetStatements', [])
        
        if not balance_sheets:
            return {}
        
        # Analisar último balanço
        balanco_atual = balance_sheets[0]
        
        # Ativos
        ativo_circulante = balanco_atual.get('totalCurrentAssets', 0)
        ativo_total = balanco_atual.get('totalAssets', 0)
        
        # Passivos
        passivo_circulante = balanco_atual.get('totalCurrentLiabilities', 0)
        divida_total = balanco_atual.get('totalLiab', 0)
        patrimonio_liquido = balanco_atual.get('totalStockholderEquity', 0)
        
        # Calcular indicadores
        liquidez_corrente = ativo_circulante / passivo_circulante if passivo_circulante > 0 else 0
        debt_to_equity = divida_total / patrimonio_liquido if patrimonio_liquido > 0 else 0
        ativo_circulante_pct = (ativo_circulante / ativo_total * 100) if ativo_total > 0 else 0
        
        return {
            'ativo_total': ativo_total / 1e9,  # Em bilhões
            'ativo_circulante': ativo_circulante / 1e9,
            'passivo_circulante': passivo_circulante / 1e9,
            'patrimonio_liquido': patrimonio_liquido / 1e9,
            'divida_total': divida_total / 1e9,
            'indicadores': {
                'liquidez_corrente': liquidez_corrente,
                'debt_to_equity': debt_to_equity,
                'ativo_circulante_pct': ativo_circulante_pct,
                'composicao_ativo': 'Circulante' if ativo_circulante_pct > 50 else 'Permanente'
            }
        }
        
    except Exception as e:
        print(f"Erro ao analisar balanço de {ticker}: {e}")
        return {}

# Exemplo de análise do balanço
balanco_analise = analisar_balanco('ITUB4', 'SEU_TOKEN')

if balanco_analise:
    print("⚖️ ANÁLISE BALANÇO - ITUB4")
    print("=" * 40)
    print(f"Ativo Total: R$ {balanco_analise['ativo_total']:.1f}B")
    print(f"Patrimônio Líquido: R$ {balanco_analise['patrimonio_liquido']:.1f}B")
    print(f"Dívida Total: R$ {balanco_analise['divida_total']:.1f}B")
    print(f"Liquidez Corrente: {balanco_analise['indicadores']['liquidez_corrente']:.2f}")
    print(f"Debt/Equity: {balanco_analise['indicadores']['debt_to_equity']:.2f}")

def screening_fundamentalista_avancado(universo_acoes, criterios, token):
    """Sistema avançado de screening fundamentalista"""
    
    resultados = []
    
    for ticker in universo_acoes:
        try:
            print(f"Analisando {ticker}...")
            
            # Análise completa
            analisador = AnalisadorFundamentalista(token)
            analise = analisador.analise_completa(ticker)
            
            if not analise:
                continue
            
            # Aplicar filtros
            multiplos = analise['multiplos']
            rentabilidade = analise['rentabilidade']
            endividamento = analise['endividamento']
            crescimento = analise['crescimento']
            
            # Filtros de múltiplos
            if (multiplos.get('pl', 0) > criterios['pl_max'] or
                multiplos.get('pvp', 0) > criterios['pvp_max'] or
                multiplos.get('ev_ebitda', 0) > criterios['ev_ebitda_max']):
                continue
            
            # Filtros de rentabilidade
            if (rentabilidade.get('roe', 0) < criterios['roe_min'] or
                rentabilidade.get('margem_liquida', 0) < criterios['margem_min']):
                continue
            
            # Filtros de endividamento
            if (endividamento.get('liquidez_corrente', 0) < criterios['liquidez_min'] or
                endividamento.get('divida_patrimonio', 0) > criterios['debt_equity_max']):
                continue
            
            # Filtros de crescimento
            if crescimento.get('crescimento_receita_ttm', 0) < criterios['crescimento_min']:
                continue
            
            # Se passou em todos os filtros, incluir na lista
            resultado = {
                'ticker': ticker,
                'nome': analise['dados_empresa']['nome'],
                'setor': analise['dados_empresa']['setor'],
                'score_total': analise['score_final']['score_total'],
                'recomendacao': analise['recomendacao']['recomendacao'],
                'metricas_chave': {
                    'pl': multiplos.get('pl', 0),
                    'pvp': multiplos.get('pvp', 0),
                    'roe': rentabilidade.get('roe', 0),
                    'dy': multiplos.get('dividend_yield', 0),
                    'margem_liquida': rentabilidade.get('margem_liquida', 0),
                    'crescimento_receita': crescimento.get('crescimento_receita_ttm', 0)
                }
            }
            
            resultados.append(resultado)
            
        except Exception as e:
            print(f"Erro ao analisar {ticker}: {e}")
            continue
    
    # Ordenar por score total
    return sorted(resultados, key=lambda x: x['score_total'], reverse=True)

# Critérios de screening
criterios_avancados = {
    # Múltiplos
    'pl_max': 20,
    'pvp_max': 3,
    'ev_ebitda_max': 15,
    
    # Rentabilidade
    'roe_min': 15,
    'margem_min': 5,
    
    # Endividamento
    'liquidez_min': 1.2,
    'debt_equity_max': 1.0,
    
    # Crescimento
    'crescimento_min': 0  # Pelo menos estável
}

# Universo de ações (top por liquidez)
universo_screening = [
    'PETR4', 'VALE3', 'ITUB4', 'BBDC4', 'ABEV3', 'BBAS3', 'WEGE3', 'RENT3',
    'EGIE3', 'MGLU3', 'LREN3', 'RAIL3', 'VIVT3', 'KLBN11', 'SBSP3', 'SUZB3',
    'GGBR4', 'USIM5', 'BRFS3', 'JBSS3', 'EMBR3', 'GOAU4', 'CPLE6', 'TAEE11'
]

# Executar screening (demonstração com subset menor)
acoes_subset = universo_screening[:5]  # Apenas 5 para demonstração
oportunidades = screening_fundamentalista_avancado(acoes_subset, criterios_avancados, 'SEU_TOKEN')

print("🎯 OPORTUNIDADES IDENTIFICADAS")
print("=" * 80)

for i, oportunidade in enumerate(oportunidades, 1):
    print(f"{i}. {oportunidade['ticker']} - {oportunidade['nome']}")
    print(f"   Setor: {oportunidade['setor']}")
    print(f"   Score: {oportunidade['score_total']:.1f}/100 - {oportunidade['recomendacao']}")
    print(f"   P/L: {oportunidade['metricas_chave']['pl']:.1f} | ROE: {oportunidade['metricas_chave']['roe']:.1f}% | DY: {oportunidade['metricas_chave']['dy']:.1f}%")
    print()

def avaliacacao_qualitativa(ticker):
    """Framework de avaliação qualitativa de empresas"""
    
    # Esta análise seria baseada em pesquisa e dados qualitativos
    # Aqui apresentamos um framework conceitual
    
    criterios_qualitativos = {
        'gestao': {
            'peso': 25,
            'fatores': [
                'Histórico da gestão',
                'Transparência nas comunicações',
                'Estratégia clara',
                'Governança corporativa'
            ],
            'score': 0  # Seria preenchido com pesquisa
        },
        'vantagem_competitiva': {
            'peso': 30,
            'fatores': [
                'Diferenciação do produto',
                'Barreiras de entrada',
                'Posição de mercado',
                'Rede de distribuição'
            ],
            'score': 0
        },
        'mercado': {
            'peso': 20,
            'fatores': [
                'Tamanho do mercado',
                'Taxa de crescimento',
                'Competitividade',
                'Regulamentação'
            ],
            'score': 0
        },
        'financeiro': {
            'peso': 15,
            'fatores': [
                'Qualidade dos lucros',
                'Geração de caixa',
                'Estrutura de capital',
                'Política de dividendos'
            ],
            'score': 0
        },
        'sustentabilidade': {
            'peso': 10,
            'fatores': [
                'Práticas ESG',
                'Sustentabilidade ambiental',
                'Responsabilidade social',
                'Compliance'
            ],
            'score': 0
        }
    }
    
    return criterios_qualitativos

def exemplos_analise_qualitativa():
    """Exemplos práticos de análise qualitativa"""
    
    exemplos = {
        'WEGE3': {
            'gestao': {
                'score': 90,
                'comentarios': 'Gestão familiar profissionalizada, foco em inovação'
            },
            'vantagem_competitiva': {
                'score': 85,
                'comentarios': 'Líder em motores elétricos, marca forte, P&D'
            },
            'mercado': {
                'score': 80,
                'comentarios': 'Mercado de automação industrial em crescimento'
            }
        },
        'VALE3': {
            'gestao': {
                'score': 70,
                'comentarios': 'Governança melhorada pós-Brumadinho'
            },
            'vantagem_competitiva': {
                'score': 95,
                'comentarios': 'Baixo custo, reservas de qualidade'
            },
            'mercado': {
                'score': 60,
                'comentarios': 'Mercado cíclico, dependente da China'
            }
        }
    }
    
    return exemplos

# Exemplo de uso
exemplos_qual = exemplos_analise_qualitativa()

print("🔍 ANÁLISE QUALITATIVA - EXEMPLOS")
print("=" * 50)

for ticker, analise in exemplos_qual.items():
    print(f"\n{ticker}:")
    for criterio, dados in analise.items():
        print(f"  {criterio.title()}: {dados['score']}/100")
        print(f"    {dados['comentarios']}")

def gerar_relatorio_completo(ticker, token):
    """Gera relatório completo de análise fundamentalista"""
    
    # Realizar todas as análises
    analisador = AnalisadorFundamentalista(token)
    analise_principal = analisador.analise_completa(ticker)
    
    dre_dados = analisar_dre(ticker, token)
    balanco_dados = analisar_balanco(ticker, token)
    
    # Estruturar relatório
    relatorio = {
        'ticker': ticker,
        'data_analise': datetime.now().strftime('%d/%m/%Y'),
        'resumo_executivo': gerar_resumo_executivo(analise_principal),
        'dados_empresa': analise_principal['dados_empresa'],
        'analise_quantitativa': {
            'multiplos': analise_principal['multiplos'],
            'rentabilidade': analise_principal['rentabilidade'],
            'endividamento': analise_principal['endividamento'],
            'crescimento': analise_principal['crescimento']
        },
        'demonstracoes': {
            'dre': dre_dados,
            'balanco': balanco_dados
        },
        'score_final': analise_principal['score_final'],
        'recomendacao': analise_principal['recomendacao']
    }
    
    return relatorio

def gerar_resumo_executivo(analise):
    """Gera resumo executivo da análise"""
    
    score = analise['score_final']['score_total']
    
    pontos_fortes = []
    pontos_fracos = []
    
    # Múltiplos
    if analise['multiplos'].get('score_medio_multiplos', 0) > 70:
        pontos_fortes.append("Múltiplos de valuation atrativos")
    elif analise['multiplos'].get('score_medio_multiplos', 0) < 40:
        pontos_fracos.append("Múltiplos de valuation elevados")
    
    # Rentabilidade
    if analise['rentabilidade'].get('score_medio_rentabilidade', 0) > 70:
        pontos_fortes.append("Alta rentabilidade e eficiência operacional")
    elif analise['rentabilidade'].get('score_medio_rentabilidade', 0) < 40:
        pontos_fracos.append("Rentabilidade abaixo da média")
    
    # Endividamento
    if analise['endividamento'].get('score_medio_endividamento', 0) > 70:
        pontos_fortes.append("Estrutura de capital sólida")
    elif analise['endividamento'].get('score_medio_endividamento', 0) < 40:
        pontos_fracos.append("Endividamento elevado")
    
    return {
        'score_geral': score,
        'classificacao': 'Excelente' if score >= 80 else 'Boa' if score >= 60 else 'Mediana' if score >= 40 else 'Fraca',
        'pontos_fortes': pontos_fortes,
        'pontos_fracos': pontos_fracos
    }

def formatar_relatorio_html(relatorio):
    """Formata relatório em HTML"""
    
    html = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <title>Análise Fundamentalista - {relatorio['ticker']}</title>
        <style>
            body {{ font-family: Arial, sans-serif; margin: 20px; }}
            .header {{ background: #2c3e50; color: white; padding: 20px; }}
            .score {{ font-size: 2em; font-weight: bold; }}
            .secao {{ margin: 20px 0; padding: 15px; border-left: 4px solid #3498db; }}
            .positivo {{ color: #27ae60; }}
            .negativo {{ color: #e74c3c; }}
            table {{ width: 100%; border-collapse: collapse; }}
            th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
            th {{ background-color: #f2f2f2; }}
        </style>
    </head>
    <body>
        <div class="header">
            <h1>Análise Fundamentalista</h1>
            <h2>{relatorio['ticker']} - {relatorio['dados_empresa']['nome']}</h2>
            <p>Análise realizada em {relatorio['data_analise']}</p>
        </div>
        
        <div class="secao">
            <h2>Resumo Executivo</h2>
            <div class="score">Score Final: {relatorio['score_final']['score_total']:.1f}/100</div>
            <p><strong>Classificação:</strong> {relatorio['resumo_executivo']['classificacao']}</p>
            <p><strong>Recomendação:</strong> {relatorio['recomendacao']['recomendacao']}</p>
            
            <h3>Pontos Fortes</h3>
            <ul>
    """
    
    for ponto in relatorio['resumo_executivo']['pontos_fortes']:
        html += f"<li class='positivo'>{ponto}</li>"
    
    html += """
            </ul>
            
            <h3>Pontos de Atenção</h3>
            <ul>
    """
    
    for ponto in relatorio['resumo_executivo']['pontos_fracos']:
        html += f"<li class='negativo'>{ponto}</li>"
    
    html += f"""
            </ul>
        </div>
        
        <div class="secao">
            <h2>Informações da Empresa</h2>
            <table>
                <tr><td><strong>Setor</strong></td><td>{relatorio['dados_empresa']['setor']}</td></tr>
                <tr><td><strong>Indústria</strong></td><td>{relatorio['dados_empresa']['industria']}</td></tr>
                <tr><td><strong>Market Cap</strong></td><td>R$ {relatorio['dados_empresa']['market_cap']:.1f}B</td></tr>
                <tr><td><strong>Funcionários</strong></td><td>{relatorio['dados_empresa']['funcionarios']:,}</td></tr>
            </table>
        </div>
        
        <div class="secao">
            <h2>Múltiplos de Valuation</h2>
            <table>
                <tr><td><strong>P/L</strong></td><td>{relatorio['analise_quantitativa']['multiplos']['pl']:.1f}</td></tr>
                <tr><td><strong>P/VP</strong></td><td>{relatorio['analise_quantitativa']['multiplos']['pvp']:.2f}</td></tr>
                <tr><td><strong>EV/EBITDA</strong></td><td>{relatorio['analise_quantitativa']['multiplos']['ev_ebitda']:.1f}</td></tr>
                <tr><td><strong>Dividend Yield</strong></td><td>{relatorio['analise_quantitativa']['multiplos']['dividend_yield']:.2f}%</td></tr>
            </table>
        </div>
        
        <div class="secao">
            <h2>Indicadores de Rentabilidade</h2>
            <table>
                <tr><td><strong>ROE</strong></td><td>{relatorio['analise_quantitativa']['rentabilidade']['roe']:.1f}%</td></tr>
                <tr><td><strong>ROA</strong></td><td>{relatorio['analise_quantitativa']['rentabilidade']['roa']:.1f}%</td></tr>
                <tr><td><strong>Margem Líquida</strong></td><td>{relatorio['analise_quantitativa']['rentabilidade']['margem_liquida']:.1f}%</td></tr>
                <tr><td><strong>Margem Operacional</strong></td><td>{relatorio['analise_quantitativa']['rentabilidade']['margem_operacional']:.1f}%</td></tr>
            </table>
        </div>
    </body>
    </html>
    """
    
    return html

# Exemplo de geração de relatório
relatorio_exemplo = gerar_relatorio_completo('WEGE3', 'SEU_TOKEN')
html_relatorio = formatar_relatorio_html(relatorio_exemplo)

# Salvar relatório
with open(f"relatorio_{relatorio_exemplo['ticker']}_{datetime.now().strftime('%Y%m%d')}.html", 'w', encoding='utf-8') as f:
    f.write(html_relatorio)

print(f"✅ Relatório de {relatorio_exemplo['ticker']} gerado com sucesso!")