// dashboard.js - Lógica principal do Dashboard (Atualizado)

document.addEventListener('DOMContentLoaded', () => {
    carregarDadosDashboard();
    
    // Atualizar a cada 5 minutos (300.000 ms)
    setInterval(carregarDadosDashboard, 300000);
});

async function carregarDadosDashboard() {
    try {
        mostrarLoading();

        // 1. Buscar Ativos do Banco de Dados
        const resAtivos = await ApiClient.get('api_ativos.php');
        const ativos = resAtivos.data || [];
        
        // 2. Extrair tickers para buscar cotações na Brapi
        const tickers = ativos.map(a => a.simbolo || a.ticker).filter(Boolean).join(',');
        
        let cotacoes = {};
        if (tickers) {
            try {
                const resCotacoes = await ApiClient.get(`api_cotacoes.php?tickers=${tickers}`);
                if (resCotacoes.status === 'success') {
                    cotacoes = resCotacoes.data;
                } else if (resCotacoes.code === 'NO_TOKEN') {
                    if (typeof Alertas !== 'undefined') {
                        Alertas.aviso('API Brapi não configurada. Preços não serão atualizados em tempo real.', 5000);
                    }
                }
            } catch (e) {
                console.warn('Erro ao buscar cotações:', e);
            }
        }
        
        // 3. Processar dados com a biblioteca de Cálculos
        let totalInvestido = 0;
        let valorAtualTotal = 0;
        let composicaoLabels = [];
        let composicaoData = [];
        let acoesBloqueadas = 0;
        
        const tbody = document.getElementById('tbody-ativos');
        if (tbody) tbody.innerHTML = '';
        
        if (ativos.length === 0 && tbody) {
            tbody.innerHTML = '<tr><td colspan="6" class="text-center py-4 text-gray-500">Nenhum ativo cadastrado.</td></tr>';
        }
        
        ativos.forEach(ativo => {
            const ticker = ativo.simbolo || ativo.ticker;
            const qtd = parseInt(ativo.quantidade_total || 0);
            const pm = parseFloat(ativo.preco_medio || 0);
            const bloqueada = parseInt(ativo.quantidade_bloqueada || 0);
            
            // Valor Investido (Custo)
            const investido = qtd * pm;
            totalInvestido += investido;
            
            // Valor Atual (Usando cotação da Brapi se disponível, senão usa PM)
            let precoAtual = pm;
            let temCotacao = false;
            
            if (cotacoes[ticker]) {
                precoAtual = parseFloat(cotacoes[ticker].preco_atual);
                temCotacao = true;
            }
            
            const valorAtual = qtd * precoAtual;
            valorAtualTotal += valorAtual;
            
            // Dados para o Gráfico de Composição
            if (valorAtual > 0) {
                composicaoLabels.push(ticker);
                composicaoData.push(valorAtual);
            }
            
            // Estatísticas rápidas
            acoesBloqueadas += bloqueada;
            
            // Calcular P&L Não Realizado para a tabela
            const pnl = typeof Calculos !== 'undefined' ? 
                Calculos.calcularPnLNaoRealizado(qtd, pm, precoAtual) : 
                (valorAtual - investido);
                
            const pnlClass = pnl >= 0 ? 'text-green-600' : 'text-red-600';
            
            // Preencher tabela se ela existir na página
            if (tbody) {
                const tr = document.createElement('tr');
                tr.innerHTML = `
                    <td class="font-bold text-blue-600">
                        ${ticker} 
                        ${temCotacao ? '<span class="text-xs text-green-500 ml-1" title="Preço atualizado em tempo real">⚡</span>' : ''}
                    </td>
                    <td>${qtd}</td>
                    <td class="text-red-500">${bloqueada}</td>
                    <td>${formatarMoedaLocal(pm)}</td>
                    <td class="font-bold">${formatarMoedaLocal(valorAtual)}</td>
                    <td class="${pnlClass} font-bold">${formatarMoedaLocal(pnl)}</td>
                `;
                tbody.appendChild(tr);
            }
        });
        
        // 4. Atualizar Cards Superiores
        const lucroTotal = valorAtualTotal - totalInvestido;
        const roa = typeof Calculos !== 'undefined' ? 
            Calculos.calcularROA(lucroTotal, totalInvestido) : 
            (totalInvestido > 0 ? (lucroTotal / totalInvestido) * 100 : 0);
        
        atualizarCardsSuperiores(totalInvestido, valorAtualTotal, lucroTotal, roa);
        
        // 5. Renderizar Gráfico de Composição
        if (typeof Graficos !== 'undefined') {
            Graficos.initComposicao('grafico-composicao', composicaoLabels, composicaoData);
        }
        
        // 6. Atualizar Informações Rápidas
        const elInfoAtivos = document.getElementById('info-ativos');
        const elInfoBloqueadas = document.getElementById('info-bloqueadas');
        
        if (elInfoAtivos) elInfoAtivos.textContent = ativos.length;
        if (elInfoBloqueadas) elInfoBloqueadas.textContent = acoesBloqueadas;
        
        // Buscar operações abertas para completar as infos rápidas
        buscarInfoOperacoes();
        
    } catch (e) {
        console.error('Erro geral no dashboard:', e);
        if (typeof Alertas !== 'undefined') {
            Alertas.erro('Erro ao carregar dados do dashboard');
        }
    }
}

function mostrarLoading() {
    const elementos = document.querySelectorAll('.stat-value');
    elementos.forEach(el => {
        if (!el.innerHTML.includes('animate-pulse')) {
            el.innerHTML = '<span class="animate-pulse text-gray-300">Carregando...</span>';
        }
    });
}

function atualizarCardsSuperiores(investido, atual, lucro, roa) {
    const elInvestido = document.getElementById('card-investido');
    const elAtual = document.getElementById('card-atual');
    const elPnl = document.getElementById('card-pnl');
    const elRoa = document.getElementById('card-roa');
    
    if (elInvestido) elInvestido.textContent = formatarMoedaLocal(investido);
    if (elAtual) elAtual.textContent = formatarMoedaLocal(atual);
    
    if (elPnl) {
        elPnl.textContent = formatarMoedaLocal(lucro);
        elPnl.className = `stat-value text-2xl font-bold mt-2 ${lucro >= 0 ? 'text-green-500' : 'text-red-500'}`;
    }
    
    if (elRoa) {
        elRoa.textContent = typeof Calculos !== 'undefined' ? 
            Calculos.formatarPercentual(roa) : 
            roa.toFixed(2) + '%';
        elRoa.className = `stat-value text-2xl font-bold mt-2 ${roa >= 0 ? 'text-blue-500' : 'text-red-500'}`;
    }
}

async function buscarInfoOperacoes() {
    try {
        const res = await ApiClient.get('api_operacoes.php?tipo=abertas');
        const operacoes = res.data || [];
        
        const elInfoAbertas = document.getElementById('info-abertas');
        if (elInfoAbertas) elInfoAbertas.textContent = operacoes.length;
        
        // Somar prêmios recebidos
        let premios = 0;
        operacoes.forEach(op => {
            const premium = parseFloat(op.preco_unitario || op.premium || 0);
            const qtd = parseInt(op.quantidade || op.contracts || 0);
            
            // Se for VENDA COBERTA
            if (op.tipo_operacao === 'VENDA_COBERTA' || (op.tipo_opcao === 'CALL' && op.direcao === 'VENDA')) {
                premios += premium * qtd;
            }
        });
        
        const elInfoPremios = document.getElementById('info-premios');
        if (elInfoPremios) elInfoPremios.textContent = formatarMoedaLocal(premios);
        
    } catch (e) {
        console.error('Erro ao buscar operações:', e);
    }
}

function formatarMoedaLocal(valor) {
    if (typeof Calculos !== 'undefined') {
        return Calculos.formatarMoeda(valor);
    }
    return new Intl.NumberFormat('pt-BR', {
        style: 'currency',
        currency: 'BRL'
    }).format(valor || 0);
}
