const analiseBanco = {
  eficiencia: 'Índice de Eficiência (< 50% é bom)',
  qualidadeCredito: 'Taxa de Inadimplência (< 5% é boa)',
  rentabilidade: 'ROE (15-25% é típico)',
  capitalização: 'Índice de Basileia (> 11% é obrigatório)',
  crescimento: 'Crescimento da Carteira de Crédito'
};

def analisar_setor_bancario(tickers_bancos, token):
    """Análise específica para setor bancário"""
    resultados = []
    
    for ticker in tickers_bancos:
        url = f"https://brapi.dev/api/quote/{ticker}?modules=defaultKeyStatistics,financialData&token={token}"
        response = requests.get(url)
        data = response.json()
        
        acao = data['results'][0]
        stats = acao.get('defaultKeyStatistics', {})
        financials = acao.get('financialData', {})
        
        analise = {
            'ticker': ticker,
            'nome': acao['shortName'],
            'preco': acao['regularMarketPrice'],
            'p_vp': stats.get('priceToBook', 0),
            'roe': financials.get('returnOnEquity', 0) * 100,
            'dividend_yield': stats.get('dividendYield', 0) * 100,
            'market_cap': stats.get('marketCap', 0) / 1e9,
            'eficiencia_score': calcular_score_eficiencia(ticker, token)
        }
        
        resultados.append(analise)
    
    # Ordenar por ROE (maior para menor)
    return sorted(resultados, key=lambda x: x['roe'], reverse=True)

# Exemplo de uso
bancos = ['ITUB4', 'BBDC4', 'BBAS3', 'SANB11', 'BPAC11']
ranking_bancos = analisar_setor_bancario(bancos, 'SEU_TOKEN')

print("🏦 RANKING SETOR BANCÁRIO")
print("-" * 50)
for i, banco in enumerate(ranking_bancos, 1):
    print(f"{i}. {banco['ticker']} - {banco['nome']}")
    print(f"   ROE: {banco['roe']:.1f}% | P/VP: {banco['p_vp']:.2f} | DY: {banco['dividend_yield']:.1f}%")

def analisar_utilities(tickers_utilities, token):
    """Análise específica para utilities"""
    resultados = []
    
    for ticker in tickers_utilities:
        url = f"https://brapi.dev/api/quote/{ticker}?modules=defaultKeyStatistics,financialData&token={token}"
        response = requests.get(url)
        data = response.json()
        
        acao = data['results'][0]
        stats = acao.get('defaultKeyStatistics', {})
        financials = acao.get('financialData', {})
        
        # Calcular EV/EBITDA específico para utilities
        ev = stats.get('enterpriseValue', 0)
        ebitda = stats.get('enterpriseToEbitda', 0)
        
        analise = {
            'ticker': ticker,
            'nome': acao['shortName'],
            'ev_ebitda': ebitda,
            'dividend_yield': stats.get('dividendYield', 0) * 100,
            'roe': financials.get('returnOnEquity', 0) * 100,
            'margem_liquida': financials.get('profitMargins', 0) * 100,
            'crescimento_receita': calcular_crescimento_receita(ticker, token),
            'estabilidade_dividendos': avaliar_estabilidade_dividendos(ticker, token)
        }
        
        resultados.append(analise)
    
    return sorted(resultados, key=lambda x: x['dividend_yield'], reverse=True)

utilities = ['EGIE3', 'SBSP3', 'CPLE6', 'TAEE11', 'CMIG4']
ranking_utilities = analisar_utilities(utilities, 'SEU_TOKEN')

def analisar_varejo(tickers_varejo, token):
    """Análise específica para varejo"""
    resultados = []
    
    for ticker in tickers_varejo:
        url = f"https://brapi.dev/api/quote/{ticker}?modules=defaultKeyStatistics,financialData&token={token}"
        response = requests.get(url)
        data = response.json()
        
        acao = data['results'][0]
        stats = acao.get('defaultKeyStatistics', {})
        financials = acao.get('financialData', {})
        
        analise = {
            'ticker': ticker,
            'nome': acao['shortName'],
            'p_l': stats.get('forwardPE', 0),
            'p_vendas': stats.get('priceToSalesTrailing12Months', 0),
            'margem_liquida': financials.get('profitMargins', 0) * 100,
            'roe': financials.get('returnOnEquity', 0) * 100,
            'crescimento_receita': calcular_crescimento_receita(ticker, token),
            'liquidez_corrente': financials.get('currentRatio', 0),
            'endividamento': calcular_endividamento(ticker, token)
        }
        
        resultados.append(analise)
    
    return sorted(resultados, key=lambda x: x['roe'], reverse=True)

varejo = ['MGLU3', 'LREN3', 'AMER3', 'GUAR3', 'SOMA3']
ranking_varejo = analisar_varejo(varejo, 'SEU_TOKEN')

import React, { useState, useEffect } from 'react';
import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ScatterChart, Scatter } from 'recharts';

const DashboardSetorial = () => {
  const [setorSelecionado, setSetorSelecionado] = useState('bancos');
  const [dadosSetor, setDadosSetor] = useState([]);
  const [loading, setLoading] = useState(false);

  const setores = {
    bancos: {
      nome: 'Setor Bancário',
      tickers: ['ITUB4', 'BBDC4', 'BBAS3', 'SANB11', 'BPAC11'],
      metricas: ['roe', 'p_vp', 'dividend_yield'],
      cor: '#3498db'
    },
    utilities: {
      nome: 'Utilities',
      tickers: ['EGIE3', 'SBSP3', 'CPLE6', 'TAEE11', 'CMIG4'],
      metricas: ['ev_ebitda', 'dividend_yield', 'margem_liquida'],
      cor: '#2ecc71'
    },
    varejo: {
      nome: 'Varejo',
      tickers: ['MGLU3', 'LREN3', 'AMER3', 'GUAR3', 'SOMA3'],
      metricas: ['p_l', 'margem_liquida', 'crescimento_receita'],
      cor: '#e74c3c'
    }
  };

  useEffect(() => {
    const buscarDadosSetor = async () => {
      setLoading(true);
      try {
        const setor = setores[setorSelecionado];
        const dados = await analisarSetor(setor.tickers, setorSelecionado);
        setDadosSetor(dados);
      } catch (error) {
        console.error('Erro ao buscar dados do setor:', error);
      } finally {
        setLoading(false);
      }
    };

    buscarDadosSetor();
  }, [setorSelecionado]);

  const analisarSetor = async (tickers, tipoSetor) => {
    const resultados = [];
    
    for (const ticker of tickers) {
      try {
        const response = await fetch(`https://brapi.dev/api/quote/${ticker}?modules=defaultKeyStatistics,financialData&token=${process.env.REACT_APP_BRAPI_TOKEN}`);
        const data = await response.json();
        
        const acao = data.results[0];
        const stats = acao.defaultKeyStatistics || {};
        const financials = acao.financialData || {};
        
        const dadosComuns = {
          ticker: acao.symbol,
          nome: acao.shortName,
          preco: acao.regularMarketPrice,
          variacao: acao.regularMarketChangePercent
        };
        
        // Métricas específicas por setor
        if (tipoSetor === 'bancos') {
          resultados.push({
            ...dadosComuns,
            roe: (financials.returnOnEquity || 0) * 100,
            p_vp: stats.priceToBook || 0,
            dividend_yield: (stats.dividendYield || 0) * 100
          });
        } else if (tipoSetor === 'utilities') {
          resultados.push({
            ...dadosComuns,
            ev_ebitda: stats.enterpriseToEbitda || 0,
            dividend_yield: (stats.dividendYield || 0) * 100,
            margem_liquida: (financials.profitMargins || 0) * 100
          });
        } else if (tipoSetor === 'varejo') {
          resultados.push({
            ...dadosComuns,
            p_l: stats.forwardPE || 0,
            margem_liquida: (financials.profitMargins || 0) * 100,
            roe: (financials.returnOnEquity || 0) * 100
          });
        }
      } catch (error) {
        console.error(`Erro ao processar ${ticker}:`, error);
      }
    }
    
    return resultados;
  };

  const renderGraficoComparativo = () => {
    if (!dadosSetor.length) return null;
    
    const setor = setores[setorSelecionado];
    
    return (
      <div className="graficos">
        <h3>Comparação {setor.nome}</h3>
        
        {/* Gráfico de barras para primeira métrica */}
        <div className="grafico-container">
          <h4>ROE / EV/EBITDA / P/L</h4>
          <BarChart width={800} height={300} data={dadosSetor}>
            <CartesianGrid strokeDasharray="3 3" />
            <XAxis dataKey="ticker" />
            <YAxis />
            <Tooltip />
            <Legend />
            <Bar 
              dataKey={setor.metricas[0]} 
              fill={setor.cor} 
              name={setor.metricas[0].toUpperCase().replace('_', '/')}
            />
          </BarChart>
        </div>
        
        {/* Scatter plot para análise cruzada */}
        <div className="grafico-container">
          <h4>Dividend Yield vs Margem Líquida</h4>
          <ScatterChart width={800} height={300} data={dadosSetor}>
            <CartesianGrid strokeDasharray="3 3" />
            <XAxis dataKey="dividend_yield" name="Dividend Yield" />
            <YAxis dataKey="margem_liquida" name="Margem Líquida" />
            <Tooltip />
            <Scatter fill={setor.cor} />
          </ScatterChart>
        </div>
      </div>
    );
  };

  const renderTabela = () => {
    if (!dadosSetor.length) return null;
    
    return (
      <div className="tabela-container">
        <h3>Ranking Detalhado</h3>
        <table className="tabela-setor">
          <thead>
            <tr>
              <th>Posição</th>
              <th>Ticker</th>
              <th>Nome</th>
              <th>Preço</th>
              <th>Variação</th>
              {setorSelecionado === 'bancos' && (
                <>
                  <th>ROE (%)</th>
                  <th>P/VP</th>
                  <th>DY (%)</th>
                </>
              )}
              {setorSelecionado === 'utilities' && (
                <>
                  <th>EV/EBITDA</th>
                  <th>DY (%)</th>
                  <th>Margem (%)</th>
                </>
              )}
              {setorSelecionado === 'varejo' && (
                <>
                  <th>P/L</th>
                  <th>ROE (%)</th>
                  <th>Margem (%)</th>
                </>
              )}
            </tr>
          </thead>
          <tbody>
            {dadosSetor.map((empresa, index) => (
              <tr key={empresa.ticker}>
                <td>{index + 1}</td>
                <td className="ticker">{empresa.ticker}</td>
                <td>{empresa.nome}</td>
                <td>R$ {empresa.preco.toFixed(2)}</td>
                <td className={empresa.variacao >= 0 ? 'positivo' : 'negativo'}>
                  {empresa.variacao >= 0 ? '+' : ''}{empresa.variacao.toFixed(2)}%
                </td>
                {setorSelecionado === 'bancos' && (
                  <>
                    <td>{empresa.roe.toFixed(1)}%</td>
                    <td>{empresa.p_vp.toFixed(2)}</td>
                    <td>{empresa.dividend_yield.toFixed(1)}%</td>
                  </>
                )}
                {setorSelecionado === 'utilities' && (
                  <>
                    <td>{empresa.ev_ebitda.toFixed(1)}x</td>
                    <td>{empresa.dividend_yield.toFixed(1)}%</td>
                    <td>{empresa.margem_liquida.toFixed(1)}%</td>
                  </>
                )}
                {setorSelecionado === 'varejo' && (
                  <>
                    <td>{empresa.p_l.toFixed(1)}x</td>
                    <td>{empresa.roe.toFixed(1)}%</td>
                    <td>{empresa.margem_liquida.toFixed(1)}%</td>
                  </>
                )}
              </tr>
            ))}
          </tbody>
        </table>
      </div>
    );
  };

  return (
    <div className="dashboard-setorial">
      <div className="header">
        <h1>Análise Setorial - B3</h1>
        <div className="seletores">
          {Object.entries(setores).map(([key, setor]) => (
            <button
              key={key}
              className={`setor-btn ${setorSelecionado === key ? 'ativo' : ''}`}
              onClick={() => setSetorSelecionado(key)}
              style={{ backgroundColor: setor.cor }}
            >
              {setor.nome}
            </button>
          ))}
        </div>
      </div>
      
      {loading ? (
        <div className="loading">Carregando dados do setor...</div>
      ) : (
        <>
          {renderGraficoComparativo()}
          {renderTabela()}
        </>
      )}
    </div>
  );
};

export default DashboardSetorial;

def analisar_ciclo_setorial(setor_tickers, periodo_anos=5, token=''):
    """Analisa ciclos históricos de um setor"""
    import pandas as pd
    from datetime import datetime, timedelta
    
    # Buscar dados históricos
    dados_setor = []
    
    for ticker in setor_tickers:
        url = f"https://brapi.dev/api/quote/{ticker}?range={periodo_anos}y&interval=1mo&token={token}"
        response = requests.get(url)
        data = response.json()
        
        historico = data['results'][0]['historicalDataPrice']
        df = pd.DataFrame(historico)
        df['date'] = pd.to_datetime(df['date'], unit='s')
        df['ticker'] = ticker
        df['retorno_mensal'] = df['close'].pct_change()
        
        dados_setor.append(df)
    
    # Combinar dados do setor
    df_setor = pd.concat(dados_setor, ignore_index=True)
    
    # Calcular performance média mensal do setor
    performance_setor = df_setor.groupby('date')['retorno_mensal'].mean().reset_index()
    performance_setor['retorno_acumulado'] = (1 + performance_setor['retorno_mensal']).cumprod()
    
    # Identificar ciclos (períodos de alta/baixa)
    performance_setor['media_movel_12m'] = performance_setor['retorno_acumulado'].rolling(12).mean()
    performance_setor['ciclo'] = performance_setor['retorno_acumulado'] > performance_setor['media_movel_12m']
    
    # Análise de sazonalidade
    performance_setor['mes'] = performance_setor['date'].dt.month
    sazonalidade = performance_setor.groupby('mes')['retorno_mensal'].mean()
    
    return {
        'performance_historica': performance_setor,
        'sazonalidade': sazonalidade,
        'momento_atual': avaliar_momento_ciclo(performance_setor),
        'melhores_meses': sazonalidade.nlargest(3).index.tolist(),
        'piores_meses': sazonalidade.nsmallest(3).index.tolist()
    }

def avaliar_momento_ciclo(df_performance):
    """Avalia em que momento do ciclo o setor se encontra"""
    ultimos_12m = df_performance.tail(12)
    performance_recente = ultimos_12m['retorno_mensal'].mean()
    
    if performance_recente > 0.02:  # 2% ao mês
        return "Alta do ciclo - CUIDADO"
    elif performance_recente < -0.02:  # -2% ao mês
        return "Baixa do ciclo - OPORTUNIDADE"
    else:
        return "Meio do ciclo - NEUTRO"

# Exemplo de uso
utilities_tickers = ['EGIE3', 'SBSP3', 'CPLE6', 'TAEE11']
analise_utilities = analisar_ciclo_setorial(utilities_tickers, 5, 'SEU_TOKEN')

print(f"Momento atual do setor: {analise_utilities['momento_atual']}")
print(f"Melhores meses historicamente: {analise_utilities['melhores_meses']}")

def identificar_pares_trading(setor_tickers, token):
    """Identifica oportunidades de pair trading no setor"""
    import numpy as np
    from scipy.stats import pearsonr
    
    # Buscar dados históricos de todas as ações
    dados_acoes = {}
    
    for ticker in setor_tickers:
        url = f"https://brapi.dev/api/quote/{ticker}?range=1y&interval=1d&token={token}"
        response = requests.get(url)
        data = response.json()
        
        historico = data['results'][0]['historicalDataPrice']
        precos = [item['close'] for item in historico]
        dados_acoes[ticker] = np.array(precos)
    
    # Calcular correlações entre todos os pares
    pares_correlacao = []
    tickers = list(dados_acoes.keys())
    
    for i in range(len(tickers)):
        for j in range(i+1, len(tickers)):
            ticker1, ticker2 = tickers[i], tickers[j]
            
            # Garantir mesmo tamanho de arrays
            min_len = min(len(dados_acoes[ticker1]), len(dados_acoes[ticker2]))
            precos1 = dados_acoes[ticker1][-min_len:]
            precos2 = dados_acoes[ticker2][-min_len:]
            
            # Calcular correlação
            correlacao, p_value = pearsonr(precos1, precos2)
            
            # Calcular ratio atual
            ratio_atual = precos1[-1] / precos2[-1]
            ratio_historico = precos1 / precos2
            ratio_media = np.mean(ratio_historico)
            ratio_std = np.std(ratio_historico)
            
            # Z-score do ratio atual
            z_score = (ratio_atual - ratio_media) / ratio_std
            
            pares_correlacao.append({
                'par': f"{ticker1}/{ticker2}",
                'ticker1': ticker1,
                'ticker2': ticker2,
                'correlacao': correlacao,
                'p_value': p_value,
                'z_score': z_score,
                'oportunidade': abs(z_score) > 2,  # Divergência significativa
                'sugestao': 'LONG ' + ticker1 + ' / SHORT ' + ticker2 if z_score < -2 
                           else 'SHORT ' + ticker1 + ' / LONG ' + ticker2 if z_score > 2 
                           else 'NEUTRO'
            })
    
    # Filtrar pares com alta correlação e oportunidades
    pares_interessantes = [
        par for par in pares_correlacao 
        if par['correlacao'] > 0.7 and par['oportunidade'] and par['p_value'] < 0.05
    ]
    
    return sorted(pares_interessantes, key=lambda x: abs(x['z_score']), reverse=True)

# Exemplo para setor bancário
bancos = ['ITUB4', 'BBDC4', 'BBAS3', 'SANB11']
oportunidades_pairs = identificar_pares_trading(bancos, 'SEU_TOKEN')

print("🔄 OPORTUNIDADES PAIR TRADING")
print("-" * 50)
for par in oportunidades_pairs[:5]:
    print(f"Par: {par['par']}")
    print(f"Correlação: {par['correlacao']:.3f}")
    print(f"Z-Score: {par['z_score']:+.2f}")
    print(f"Sugestão: {par['sugestao']}")
    print("-" * 30)

def gerar_relatorio_setorial(setor_config, token):
    """Gera relatório completo de análise setorial"""
    from datetime import datetime
    
    relatorio = {
        'setor': setor_config['nome'],
        'data_analise': datetime.now().strftime('%d/%m/%Y %H:%M'),
        'resumo_executivo': {},
        'ranking_empresas': [],
        'analise_tecnica': {},
        'recomendacoes': []
    }
    
    # Análise fundamentalista
    dados_fundamentais = analisar_fundamentos_setor(setor_config['tickers'], token)
    relatorio['ranking_empresas'] = dados_fundamentais
    
    # Líder do setor
    lider = dados_fundamentais[0]
    relatorio['resumo_executivo']['lider_setor'] = {
        'ticker': lider['ticker'],
        'nome': lider['nome'],
        'motivo': 'Maior ROE e melhor eficiência operacional'
    }
    
    # Oportunidade de valor
    melhor_valor = min(dados_fundamentais, key=lambda x: x.get('p_l', float('inf')))
    relatorio['resumo_executivo']['melhor_valor'] = {
        'ticker': melhor_valor['ticker'],
        'p_l': melhor_valor.get('p_l', 0),
        'motivo': 'Menor múltiplo P/L do setor'
    }
    
    # Maior dividend yield
    melhor_dy = max(dados_fundamentais, key=lambda x: x.get('dividend_yield', 0))
    relatorio['resumo_executivo']['melhor_dividendo'] = {
        'ticker': melhor_dy['ticker'],
        'dy': melhor_dy.get('dividend_yield', 0),
        'motivo': 'Maior dividend yield do setor'
    }
    
    # Análise técnica do setor
    analise_tecnica = analisar_tendencia_setor(setor_config['tickers'], token)
    relatorio['analise_tecnica'] = analise_tecnica
    
    # Recomendações
    relatorio['recomendacoes'] = gerar_recomendacoes_setor(dados_fundamentais, analise_tecnica)
    
    return relatorio

def formatar_relatorio_markdown(relatorio):
    """Converte relatório para formato Markdown"""
    md = f"""
# Relatório Setorial: {relatorio['setor']}
*Análise realizada em {relatorio['data_analise']}*

## 📊 Resumo Executivo

### 🏆 Líder do Setor
**{relatorio['resumo_executivo']['lider_setor']['ticker']}** - {relatorio['resumo_executivo']['lider_setor']['nome']}
*{relatorio['resumo_executivo']['lider_setor']['motivo']}*

### 💰 Melhor Valor
**{relatorio['resumo_executivo']['melhor_valor']['ticker']}** (P/L: {relatorio['resumo_executivo']['melhor_valor']['p_l']:.1f}x)
*{relatorio['resumo_executivo']['melhor_valor']['motivo']}*

### 🎯 Maior Dividend Yield
**{relatorio['resumo_executivo']['melhor_dividendo']['ticker']}** ({relatorio['resumo_executivo']['melhor_dividendo']['dy']:.1f}%)
*{relatorio['resumo_executivo']['melhor_dividendo']['motivo']}*

## 📈 Ranking de Empresas

| Posição | Ticker | Nome | ROE | P/L | DY | Score |
|---------|--------|------|-----|-----|----|----- |
"""
    
    for i, empresa in enumerate(relatorio['ranking_empresas'][:10], 1):
        roe = empresa.get('roe', 0)
        pl = empresa.get('p_l', 0)
        dy = empresa.get('dividend_yield', 0)
        score = empresa.get('score', 0)
        
        md += f"| {i} | {empresa['ticker']} | {empresa['nome']} | {roe:.1f}% | {pl:.1f}x | {dy:.1f}% | {score:.1f} |\n"
    
    md += f"""

## 🔍 Análise Técnica do Setor

**Tendência Geral:** {relatorio['analise_tecnica'].get('tendencia', 'Indefinida')}
**Força da Tendência:** {relatorio['analise_tecnica'].get('forca', 'Moderada')}
**Suporte:** R$ {relatorio['analise_tecnica'].get('suporte', 0):.2f}
**Resistência:** R$ {relatorio['analise_tecnica'].get('resistencia', 0):.2f}

## 💡 Recomendações

"""
    
    for recomendacao in relatorio['recomendacoes']:
        md += f"- **{recomendacao['tipo']}:** {recomendacao['descricao']}\n"
    
    md += """

---
*Relatório gerado automaticamente pela API brapi.dev*
"""
    
    return md

# Exemplo de uso
setor_utilities = {
    'nome': 'Utilities (Energia e Saneamento)',
    'tickers': ['EGIE3', 'SBSP3', 'CPLE6', 'TAEE11', 'CMIG4']
}

relatorio = gerar_relatorio_setorial(setor_utilities, 'SEU_TOKEN')
markdown = formatar_relatorio_markdown(relatorio)

# Salvar relatório
with open(f"relatorio_utilities_{datetime.now().strftime('%Y%m%d')}.md", 'w', encoding='utf-8') as f:
    f.write(markdown)

print("Relatório setorial gerado com sucesso!")