P/VP = Preço da Ação ÷ Valor Patrimonial por Ação

import requests
import json

def calcular_pvp_detalhado(ticker, token=''):
    """Calcula P/VP com análise detalhada"""
    
    url = f"https://brapi.dev/api/quote/{ticker}?modules=summaryProfile,defaultKeyStatistics,balanceSheetHistory&token={token}"
    
    try:
        response = requests.get(url)
        data = response.json()
        
        if not data['results']:
            return None
        
        resultado = data['results'][0]
        
        # Dados básicos
        preco_atual = resultado.get('regularMarketPrice', 0)
        acoes_em_circulacao = resultado.get('sharesOutstanding', 0)
        
        # Valor patrimonial do balanço
        balanco = resultado.get('balanceSheetHistory', {}).get('balanceSheetHistory', [])
        
        if not balanco:
            return None
        
        balanco_recente = balanco[0]
        patrimonio_liquido = balanco_recente.get('totalStockholdersEquity', 0)
        
        # Calcular VPA (Valor Patrimonial por Ação)
        vpa = patrimonio_liquido / acoes_em_circulacao if acoes_em_circulacao > 0 else 0
        
        # Calcular P/VP
        pvp = preco_atual / vpa if vpa > 0 else 0
        
        return {
            'ticker': ticker,
            'preco_atual': preco_atual,
            'patrimonio_liquido': patrimonio_liquido,
            'acoes_circulacao': acoes_em_circulacao,
            'vpa': vpa,
            'pvp': pvp,
            'interpretacao': interpretar_pvp(pvp),
            'valor_mercado': preco_atual * acoes_em_circulacao,
            'desconto_premio': ((pvp - 1) * 100)
        }
        
    except Exception as e:
        print(f"Erro ao calcular P/VP para {ticker}: {e}")
        return None

def interpretar_pvp(pvp):
    """Interpreta o valor do P/VP"""
    if pvp < 0.5:
        return {
            'classificacao': 'MUITO DESCONTADA',
            'descricao': 'Negociada a menos de 50% do valor contábil',
            'alerta': 'Investigar motivos - possível distress financeiro',
            'cor': 'azul'
        }
    elif pvp < 1.0:
        return {
            'classificacao': 'DESCONTADA',
            'descricao': 'Negociada abaixo do valor contábil',
            'alerta': 'Potencial oportunidade de value investing',
            'cor': 'verde'
        }
    elif pvp <= 1.5:
        return {
            'classificacao': 'FAIRLY VALUED',
            'descricao': 'Avaliação próxima do valor contábil',
            'alerta': 'Preço justo considerando ativos tangíveis',
            'cor': 'amarelo'
        }
    elif pvp <= 3.0:
        return {
            'classificacao': 'PREMIUM',
            'descricao': 'Prêmio por qualidade ou crescimento',
            'alerta': 'Mercado reconhece valor além dos ativos',
            'cor': 'laranja'
        }
    else:
        return {
            'classificacao': 'MUITO CARA',
            'descricao': 'Múltiplo elevado do valor contábil',
            'alerta': 'Possível sobrevalorização',
            'cor': 'vermelho'
        }

# Exemplo prático
analise_pvp = calcular_pvp_detalhado('ITUB4')

if analise_pvp:
    print("📊 ANÁLISE P/VP - ITUB4")
    print("=" * 50)
    print(f"Preço Atual: R$ {analise_pvp['preco_atual']:.2f}")
    print(f"VPA (Valor Patrimonial por Ação): R$ {analise_pvp['vpa']:.2f}")
    print(f"P/VP: {analise_pvp['pvp']:.2f}")
    print(f"Desconto/Prêmio: {analise_pvp['desconto_premio']:+.1f}%")
    
    interpretacao = analise_pvp['interpretacao']
    print(f"\n🎯 INTERPRETAÇÃO:")
    print(f"Classificação: {interpretacao['classificacao']}")
    print(f"Descrição: {interpretacao['descricao']}")
    print(f"Alerta: {interpretacao['alerta']}")
    
    print(f"\n💰 DADOS FINANCEIROS:")
    print(f"Patrimônio Líquido: R$ {analise_pvp['patrimonio_liquido']/1e9:.2f}B")
    print(f"Valor de Mercado: R$ {analise_pvp['valor_mercado']/1e9:.2f}B")

def analisar_pvp_setorial(setor_empresas, token=''):
    """Analisa P/VP por setor"""
    
    resultados_setor = []
    
    for ticker in setor_empresas:
        analise = calcular_pvp_detalhado(ticker, token)
        if analise:
            resultados_setor.append(analise)
    
    if not resultados_setor:
        return None
    
    # Calcular estatísticas do setor
    pvps = [r['pvp'] for r in resultados_setor if r['pvp'] > 0]
    
    estatisticas = {
        'pvp_medio': sum(pvps) / len(pvps),
        'pvp_mediano': sorted(pvps)[len(pvps)//2],
        'pvp_min': min(pvps),
        'pvp_max': max(pvps),
        'empresas_desconto': len([p for p in pvps if p < 1.0]),
        'empresas_premium': len([p for p in pvps if p > 1.5]),
        'total_empresas': len(pvps)
    }
    
    # Ranking por P/VP
    ranking = sorted(resultados_setor, key=lambda x: x['pvp'])
    
    return {
        'estatisticas': estatisticas,
        'ranking': ranking,
        'oportunidades': [r for r in ranking if r['pvp'] < 1.0 and r['pvp'] > 0]
    }

# Análise setorial - Bancos
bancos = ['ITUB4', 'BBDC4', 'BBAS3', 'SANB11', 'BPAC11']
analise_bancos = analisar_pvp_setorial(bancos)

if analise_bancos:
    stats = analise_bancos['estatisticas']
    
    print("🏦 ANÁLISE P/VP - SETOR BANCÁRIO")
    print("=" * 50)
    print(f"P/VP Médio do Setor: {stats['pvp_medio']:.2f}")
    print(f"P/VP Mediano: {stats['pvp_mediano']:.2f}")
    print(f"Faixa: {stats['pvp_min']:.2f} - {stats['pvp_max']:.2f}")
    print(f"Empresas com Desconto: {stats['empresas_desconto']}/{stats['total_empresas']}")
    
    print(f"\n🎯 RANKING P/VP (MENOR → MAIOR):")
    for i, empresa in enumerate(analise_bancos['ranking'][:5], 1):
        print(f"{i}. {empresa['ticker']}: {empresa['pvp']:.2f}")
    
    if analise_bancos['oportunidades']:
        print(f"\n💎 OPORTUNIDADES (P/VP < 1.0):")
        for opp in analise_bancos['oportunidades']:
            desconto = (1 - opp['pvp']) * 100
            print(f"• {opp['ticker']}: P/VP {opp['pvp']:.2f} ({desconto:.1f}% desconto)")

def screening_value_investing_pvp(universo_acoes, criterios, token=''):
    """Screening focado em P/VP para value investing"""
    
    candidatos = []
    
    for ticker in universo_acoes:
        try:
            # Análise P/VP
            analise_pvp = calcular_pvp_detalhado(ticker, token)
            if not analise_pvp:
                continue
            
            # Buscar dados complementares
            url = f"https://brapi.dev/api/quote/{ticker}?modules=defaultKeyStatistics,financialData&token={token}"
            response = requests.get(url)
            data = response.json()
            
            if not data['results']:
                continue
            
            resultado = data['results'][0]
            
            # Métricas complementares
            roe = resultado.get('returnOnEquity', 0)
            debt_equity = resultado.get('debtToEquity', 0)
            current_ratio = resultado.get('currentRatio', 0)
            pl = resultado.get('trailingPE', 0)
            
            # Aplicar filtros
            pvp = analise_pvp['pvp']
            
            # Critérios de value investing
            if (pvp > 0 and pvp <= criterios['pvp_max'] and
                roe >= criterios['roe_min'] and
                debt_equity <= criterios['debt_equity_max'] and
                current_ratio >= criterios['liquidez_min'] and
                pl > 0 and pl <= criterios['pl_max']):
                
                score_value = calcular_score_value(pvp, roe, debt_equity, current_ratio, pl)
                
                candidatos.append({
                    'ticker': ticker,
                    'pvp': pvp,
                    'roe': roe,
                    'debt_equity': debt_equity,
                    'current_ratio': current_ratio,
                    'pl': pl,
                    'score_value': score_value,
                    'desconto_vpa': (1 - pvp) * 100 if pvp < 1 else 0,
                    'interpretacao': analise_pvp['interpretacao']['classificacao']
                })
                
        except Exception as e:
            print(f"Erro ao analisar {ticker}: {e}")
            continue
    
    # Ordenar por score de value
    return sorted(candidatos, key=lambda x: x['score_value'], reverse=True)

def calcular_score_value(pvp, roe, debt_equity, current_ratio, pl):
    """Calcula score de value investing"""
    score = 0
    
    # Score P/VP (peso 30%)
    if pvp < 0.5:
        score += 30
    elif pvp < 0.8:
        score += 25
    elif pvp < 1.0:
        score += 20
    elif pvp < 1.2:
        score += 15
    else:
        score += 5
    
    # Score ROE (peso 25%)
    if roe >= 20:
        score += 25
    elif roe >= 15:
        score += 20
    elif roe >= 10:
        score += 15
    elif roe >= 5:
        score += 10
    
    # Score Endividamento (peso 20%)
    if debt_equity < 0.3:
        score += 20
    elif debt_equity < 0.5:
        score += 15
    elif debt_equity < 1.0:
        score += 10
    elif debt_equity < 1.5:
        score += 5
    
    # Score Liquidez (peso 15%)
    if current_ratio >= 2.0:
        score += 15
    elif current_ratio >= 1.5:
        score += 12
    elif current_ratio >= 1.2:
        score += 8
    elif current_ratio >= 1.0:
        score += 5
    
    # Score P/L (peso 10%)
    if pl < 10:
        score += 10
    elif pl < 15:
        score += 8
    elif pl < 20:
        score += 5
    
    return min(score, 100)  # Máximo 100

# Critérios para screening value
criterios_value = {
    'pvp_max': 1.2,
    'roe_min': 10,
    'debt_equity_max': 1.0,
    'liquidez_min': 1.0,
    'pl_max': 15
}

# Universo de ações para análise
universo_value = [
    'ITUB4', 'BBDC4', 'PETR4', 'VALE3', 'ABEV3', 'MGLU3', 'EGIE3', 'SBSP3',
    'BBSE3', 'TAEE11', 'CMIG4', 'ENBR3', 'CCRO3', 'EQTL3', 'CSAN3', 'USIM5'
]

candidatos_value = screening_value_investing_pvp(universo_value, criterios_value)

print("💎 SCREENING VALUE INVESTING - P/VP")
print("=" * 70)
print("Critérios aplicados:")
print(f"• P/VP ≤ {criterios_value['pvp_max']}")
print(f"• ROE ≥ {criterios_value['roe_min']}%")
print(f"• Debt/Equity ≤ {criterios_value['debt_equity_max']}")
print(f"• Liquidez Corrente ≥ {criterios_value['liquidez_min']}")
print(f"• P/L ≤ {criterios_value['pl_max']}")

print(f"\n📊 RESULTADOS ({len(candidatos_value)} empresas aprovadas):")
print("-" * 70)

for i, candidato in enumerate(candidatos_value[:10], 1):
    print(f"{i:2d}. {candidato['ticker']} - Score: {candidato['score_value']:.0f}/100")
    print(f"    P/VP: {candidato['pvp']:.2f} | ROE: {candidato['roe']:.1f}% | P/L: {candidato['pl']:.1f}")
    if candidato['desconto_vpa'] > 0:
        print(f"    💰 Desconto ao VPA: {candidato['desconto_vpa']:.1f}%")
    print(f"    📊 {candidato['interpretacao']}")
    print()

def matriz_valor_pvp_combinada(ticker, token=''):
    """Análise combinada P/VP com outros indicadores"""
    
    # Buscar dados completos
    url = f"https://brapi.dev/api/quote/{ticker}?modules=defaultKeyStatistics,financialData,summaryDetail&token={token}"
    response = requests.get(url)
    data = response.json()
    
    if not data['results']:
        return None
    
    resultado = data['results'][0]
    
    # Calcular P/VP
    analise_pvp = calcular_pvp_detalhado(ticker, token)
    if not analise_pvp:
        return None
    
    # Outros múltiplos
    pl = resultado.get('trailingPE', 0)
    psr = resultado.get('priceToSalesTrailing12Months', 0)
    ev_ebitda = resultado.get('enterpriseToEbitda', 0)
    
    # Indicadores de qualidade
    roe = resultado.get('returnOnEquity', 0)
    roa = resultado.get('returnOnAssets', 0)
    margem_liquida = resultado.get('profitMargins', 0) * 100
    
    # Análise combinada
    matriz_analise = {
        'ticker': ticker,
        'multiplos': {
            'pvp': analise_pvp['pvp'],
            'pl': pl,
            'psr': psr,
            'ev_ebitda': ev_ebitda
        },
        'qualidade': {
            'roe': roe,
            'roa': roa,
            'margem_liquida': margem_liquida
        },
        'avaliacao_combinada': avaliar_combinacao_indicadores(
            analise_pvp['pvp'], pl, roe, margem_liquida
        )
    }
    
    return matriz_analise

def avaliar_combinacao_indicadores(pvp, pl, roe, margem_liquida):
    """Avalia empresa com base em combinação de indicadores"""
    
    # Classificação P/VP
    if pvp < 1.0:
        classe_pvp = "Descontada"
        score_pvp = 20
    elif pvp < 1.5:
        classe_pvp = "Justa"
        score_pvp = 15
    else:
        classe_pvp = "Premium"
        score_pvp = 10
    
    # Classificação P/L
    if pl < 10:
        classe_pl = "Barata"
        score_pl = 15
    elif pl < 15:
        classe_pl = "Moderada"
        score_pl = 12
    elif pl < 20:
        classe_pl = "Cara"
        score_pl = 8
    else:
        classe_pl = "Muito Cara"
        score_pl = 3
    
    # Classificação Qualidade
    if roe >= 15 and margem_liquida >= 10:
        classe_qualidade = "Alta Qualidade"
        score_qualidade = 25
    elif roe >= 10 and margem_liquida >= 5:
        classe_qualidade = "Boa Qualidade"
        score_qualidade = 20
    elif roe >= 5:
        classe_qualidade = "Qualidade Média"
        score_qualidade = 15
    else:
        classe_qualidade = "Baixa Qualidade"
        score_qualidade = 5
    
    score_total = score_pvp + score_pl + score_qualidade
    
    # Recomendação final
    if score_total >= 50:
        recomendacao = "COMPRA FORTE"
    elif score_total >= 40:
        recomendacao = "COMPRA"
    elif score_total >= 30:
        recomendacao = "NEUTRO"
    else:
        recomendacao = "EVITAR"
    
    return {
        'classes': {
            'pvp': classe_pvp,
            'pl': classe_pl,
            'qualidade': classe_qualidade
        },
        'scores': {
            'pvp': score_pvp,
            'pl': score_pl,
            'qualidade': score_qualidade,
            'total': score_total
        },
        'recomendacao': recomendacao,
        'justificativa': f"{classe_pvp} (P/VP) + {classe_pl} (P/L) + {classe_qualidade}"
    }

# Exemplo de análise multivariada
matriz_itub4 = matriz_valor_pvp_combinada('ITUB4')

if matriz_itub4:
    print("🔍 MATRIZ DE VALOR COMBINADA - ITUB4")
    print("=" * 60)
    
    multiplos = matriz_itub4['multiplos']
    print(f"📊 MÚLTIPLOS:")
    print(f"P/VP: {multiplos['pvp']:.2f}")
    print(f"P/L: {multiplos['pl']:.1f}")
    print(f"PSR: {multiplos['psr']:.2f}")
    
    qualidade = matriz_itub4['qualidade']
    print(f"\n⭐ INDICADORES DE QUALIDADE:")
    print(f"ROE: {qualidade['roe']:.1f}%")
    print(f"ROA: {qualidade['roa']:.1f}%")
    print(f"Margem Líquida: {qualidade['margem_liquida']:.1f}%")
    
    avaliacao = matriz_itub4['avaliacao_combinada']
    print(f"\n🎯 AVALIAÇÃO COMBINADA:")
    print(f"Score Total: {avaliacao['scores']['total']}/60")
    print(f"Recomendação: {avaliacao['recomendacao']}")
    print(f"Justificativa: {avaliacao['justificativa']}")

def pvp_ajustado_qualidade_ativos(ticker, token=''):
    """P/VP ajustado pela qualidade dos ativos"""
    
    analise_base = calcular_pvp_detalhado(ticker, token)
    if not analise_base:
        return None
    
    # Buscar detalhes do balanço
    url = f"https://brapi.dev/api/quote/{ticker}?modules=balanceSheetHistory&token={token}"
    response = requests.get(url)
    data = response.json()
    
    balanco = data['results'][0]['balanceSheetHistory']['balanceSheetHistory'][0]
    
    # Analisar composição dos ativos
    total_assets = balanco.get('totalAssets', 0)
    current_assets = balanco.get('totalCurrentAssets', 0)
    cash = balanco.get('cash', 0)
    inventory = balanco.get('inventory', 0)
    goodwill = balanco.get('goodWill', 0) or 0
    
    # Calcular qualidade dos ativos
    if total_assets > 0:
        liquidez_ativos = current_assets / total_assets
        participacao_cash = cash / total_assets
        participacao_goodwill = goodwill / total_assets
        participacao_estoque = inventory / total_assets if inventory else 0
    else:
        return analise_base
    
    # Score de qualidade (0-1)
    quality_score = (
        min(liquidez_ativos * 0.4, 0.4) +          # Max 40% para liquidez
        min(participacao_cash * 2, 0.3) +          # Max 30% para cash
        max(0, 0.2 - participacao_goodwill) +      # Penaliza goodwill alto
        max(0, 0.1 - participacao_estoque * 0.5)   # Penaliza estoque alto
    )
    
    # P/VP ajustado
    pvp_original = analise_base['pvp']
    pvp_ajustado = pvp_original / quality_score if quality_score > 0 else pvp_original
    
    return {
        **analise_base,
        'pvp_ajustado': pvp_ajustado,
        'quality_score': quality_score,
        'analise_ativos': {
            'liquidez_ativos': liquidez_ativos * 100,
            'participacao_cash': participacao_cash * 100,
            'participacao_goodwill': participacao_goodwill * 100,
            'participacao_estoque': participacao_estoque * 100
        },
        'ajuste_recomendado': quality_score < 0.7
    }

# Exemplo de P/VP ajustado
analise_ajustada = pvp_ajustado_qualidade_ativos('MGLU3')

if analise_ajustada:
    print("🔧 P/VP AJUSTADO POR QUALIDADE DOS ATIVOS")
    print("=" * 55)
    print(f"P/VP Original: {analise_ajustada['pvp']:.2f}")
    print(f"P/VP Ajustado: {analise_ajustada['pvp_ajustado']:.2f}")
    print(f"Score Qualidade: {analise_ajustada['quality_score']:.2f}")
    
    ativos = analise_ajustada['analise_ativos']
    print(f"\n📋 COMPOSIÇÃO DOS ATIVOS:")
    print(f"Liquidez dos Ativos: {ativos['liquidez_ativos']:.1f}%")
    print(f"Participação Cash: {ativos['participacao_cash']:.1f}%")
    print(f"Participação Goodwill: {ativos['participacao_goodwill']:.1f}%")
    print(f"Participação Estoque: {ativos['participacao_estoque']:.1f}%")
    
    if analise_ajustada['ajuste_recomendado']:
        print("\n⚠️ RECOMENDAÇÃO: Considerar P/VP ajustado devido à baixa qualidade dos ativos")