<?php

namespace Modules\BI\Controllers;

use Gestoreasy\Core\Http\Request;
use Gestoreasy\Core\Http\Response;
use Gestoreasy\Core\Tenant\ConnectionManager;
use Gestoreasy\Core\Cache\CacheService;
use PDO;

class BIController {
    private CacheService $cache;

    public function __construct() {
        $this->cache = new CacheService();
    }

    /**
     * Obtém KPIs principais do dashboard
     */
    public function getKPIs(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $cacheKey = CacheService::tenantKey('bi', 'kpis', $tenantId);
            
            $kpis = $this->cache->remember($cacheKey, function() use ($pdo) {
                return $this->calculateKPIs($pdo);
            }, 300); // Cache por 5 minutos

            return Response::json(['data' => $kpis]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula KPIs principais
     */
    private function calculateKPIs(PDO $pdo): array {
        $hoje = date('Y-m-d');
        $mesAtual = date('Y-m');
        $mesAnterior = date('Y-m', strtotime('-1 month'));

        // Vendas do mês atual
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(valor_total), 0) as total
            FROM sales_orders
            WHERE DATE_FORMAT(created_at, "%Y-%m") = ? AND status != "cancelado"
        ');
        $stmt->execute([$mesAtual]);
        $vendasMesAtual = (float)$stmt->fetchColumn();

        // Vendas do mês anterior
        $stmt->execute([$mesAnterior]);
        $vendasMesAnterior = (float)$stmt->fetchColumn();

        // Vendas de hoje
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(valor_total), 0) as total
            FROM sales_orders
            WHERE DATE(created_at) = ? AND status != "cancelado"
        ');
        $stmt->execute([$hoje]);
        $vendasHoje = (float)$stmt->fetchColumn();

        // Contas a receber
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(valor), 0) as total
            FROM contas_receber
            WHERE status = "pendente"
        ');
        $stmt->execute();
        $contasReceber = (float)$stmt->fetchColumn();

        // Contas a pagar
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(valor), 0) as total
            FROM contas_pagar
            WHERE status = "pendente"
        ');
        $stmt->execute();
        $contasPagar = (float)$stmt->fetchColumn();

        // Estoque baixo
        $stmt = $pdo->prepare('
            SELECT COUNT(*) as total
            FROM products
            WHERE estoque <= estoque_minimo AND estoque_minimo > 0
        ');
        $stmt->execute();
        $estoqueBaixo = (int)$stmt->fetchColumn();

        // Crescimento de vendas
        $crescimentoVendas = 0;
        if ($vendasMesAnterior > 0) {
            $crescimentoVendas = (($vendasMesAtual - $vendasMesAnterior) / $vendasMesAnterior) * 100;
        }

        return [
            'vendas_mes_atual' => $vendasMesAtual,
            'vendas_mes_anterior' => $vendasMesAnterior,
            'vendas_hoje' => $vendasHoje,
            'crescimento_vendas' => round($crescimentoVendas, 2),
            'contas_receber' => $contasReceber,
            'contas_pagar' => $contasPagar,
            'estoque_baixo' => $estoqueBaixo,
        ];
    }

    /**
     * Obtém dados para gráfico de vendas
     */
    public function getVendasChart(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $periodo = $req->query['periodo'] ?? '30d'; // 7d, 30d, 90d, 1y
            $cacheKey = CacheService::tenantKey('bi', "vendas_chart_{$periodo}", $tenantId);
            
            $data = $this->cache->remember($cacheKey, function() use ($pdo, $periodo) {
                return $this->calculateVendasChart($pdo, $periodo);
            }, 600); // Cache por 10 minutos

            return Response::json(['data' => $data]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula dados do gráfico de vendas
     */
    private function calculateVendasChart(PDO $pdo, string $periodo): array {
        $days = match($periodo) {
            '7d' => 7,
            '30d' => 30,
            '90d' => 90,
            '1y' => 365,
            default => 30
        };

        $dataInicio = date('Y-m-d', strtotime("-{$days} days"));

        $stmt = $pdo->prepare('
            SELECT DATE(created_at) as data, COALESCE(SUM(valor_total), 0) as total
            FROM sales_orders
            WHERE DATE(created_at) >= ? AND status != "cancelado"
            GROUP BY DATE(created_at)
            ORDER BY data ASC
        ');
        $stmt->execute([$dataInicio]);
        $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);

        return [
            'labels' => array_column($rows, 'data'),
            'values' => array_map('floatval', array_column($rows, 'total')),
        ];
    }

    /**
     * Obtém dados para gráfico de estoque
     */
    public function getEstoqueChart(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $cacheKey = CacheService::tenantKey('bi', 'estoque_chart', $tenantId);
            
            $data = $this->cache->remember($cacheKey, function() use ($pdo) {
                return $this->calculateEstoqueChart($pdo);
            }, 600);

            return Response::json(['data' => $data]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula dados do gráfico de estoque
     */
    private function calculateEstoqueChart(PDO $pdo): array {
        // Top 10 produtos por valor de estoque
        $stmt = $pdo->prepare('
            SELECT p.codigo, p.estoque, p.preco, (p.estoque * p.preco) as valor_total
            FROM products p
            WHERE p.estoque > 0
            ORDER BY valor_total DESC
            LIMIT 10
        ');
        $stmt->execute();
        $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);

        return [
            'labels' => array_column($rows, 'codigo'),
            'quantidades' => array_map('intval', array_column($rows, 'estoque')),
            'valores' => array_map('floatval', array_column($rows, 'valor_total')),
        ];
    }

    /**
     * Obtém dados para gráfico financeiro
     */
    public function getFinanceiroChart(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $periodo = $req->query['periodo'] ?? '30d';
            $cacheKey = CacheService::tenantKey('bi', "financeiro_chart_{$periodo}", $tenantId);
            
            $data = $this->cache->remember($cacheKey, function() use ($pdo, $periodo) {
                return $this->calculateFinanceiroChart($pdo, $periodo);
            }, 600);

            return Response::json(['data' => $data]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula dados do gráfico financeiro
     */
    private function calculateFinanceiroChart(PDO $pdo, string $periodo): array {
        $days = match($periodo) {
            '7d' => 7,
            '30d' => 30,
            '90d' => 90,
            '1y' => 365,
            default => 30
        };

        $dataInicio = date('Y-m-d', strtotime("-{$days} days"));

        // Recebimentos
        $stmt = $pdo->prepare('
            SELECT DATE(data_recebimento) as data, COALESCE(SUM(valor), 0) as total
            FROM contas_receber
            WHERE DATE(data_recebimento) >= ? AND status = "pago"
            GROUP BY DATE(data_recebimento)
            ORDER BY data ASC
        ');
        $stmt->execute([$dataInicio]);
        $recebimentos = $stmt->fetchAll(PDO::FETCH_ASSOC);

        // Pagamentos
        $stmt = $pdo->prepare('
            SELECT DATE(data_pagamento) as data, COALESCE(SUM(valor), 0) as total
            FROM contas_pagar
            WHERE DATE(data_pagamento) >= ? AND status = "pago"
            GROUP BY DATE(data_pagamento)
            ORDER BY data ASC
        ');
        $stmt->execute([$dataInicio]);
        $pagamentos = $stmt->fetchAll(PDO::FETCH_ASSOC);

        return [
            'labels' => array_unique(array_merge(
                array_column($recebimentos, 'data'),
                array_column($pagamentos, 'data')
            )),
            'recebimentos' => array_map('floatval', array_column($recebimentos, 'total')),
            'pagamentos' => array_map('floatval', array_column($pagamentos, 'total')),
        ];
    }

    /**
     * Gera DRE (Demonstração do Resultado do Exercício)
     */
    public function getDRE(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $ano = (int)($req->query['ano'] ?? date('Y'));
            $mes = $req->query['mes'] ?? null;
            
            $cacheKey = CacheService::tenantKey('bi', "dre_{$ano}" . ($mes ? "_{$mes}" : ''), $tenantId);
            
            $dre = $this->cache->remember($cacheKey, function() use ($pdo, $ano, $mes) {
                return $this->calculateDRE($pdo, $ano, $mes);
            }, 3600); // Cache por 1 hora

            return Response::json(['data' => $dre]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula DRE
     */
    private function calculateDRE(PDO $pdo, int $ano, ?string $mes): array {
        $dataInicio = $mes ? "{$ano}-{$mes}-01" : "{$ano}-01-01";
        $dataFim = $mes ? date("{$ano}-{$mes}-t") : "{$ano}-12-31";

        // Receita bruta (vendas de pedidos)
        $stmt = $pdo->prepare("
            SELECT COALESCE(SUM(valor_total), 0) as total
            FROM sales_orders
            WHERE DATE(created_at) BETWEEN ? AND ? AND status != 'cancelado'
        ");
        $stmt->execute([$dataInicio, $dataFim]);
        $receitaBrutaPedidos = (float)$stmt->fetchColumn();

        // Receita bruta (vendas do PDV)
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(valor_final), 0) as total
                FROM pos_sales
                WHERE DATE(created_at) BETWEEN ? AND ?
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $receitaBrutaPDV = (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            // Se não tiver campo valor_final, usar valor_total
            try {
                $stmt = $pdo->prepare("
                    SELECT COALESCE(SUM(valor_total), 0) as total
                    FROM pos_sales
                    WHERE DATE(created_at) BETWEEN ? AND ?
                ");
                $stmt->execute([$dataInicio, $dataFim]);
                $receitaBrutaPDV = (float)$stmt->fetchColumn();
            } catch (\Exception $e2) {
                $receitaBrutaPDV = 0;
            }
        }

        $receitaBruta = $receitaBrutaPedidos + $receitaBrutaPDV;

        // Calcular deduções (incluindo PDV)
        $deducoesDetalhes = $this->calcularDeducoes($pdo, $dataInicio, $dataFim, $receitaBrutaPedidos, $receitaBrutaPDV);
        $deducoes = $deducoesDetalhes['total'];

        // Receita líquida
        $receitaLiquida = $receitaBruta - $deducoes;

        // Custo das mercadorias vendidas (CMV) - melhorado
        $cmvDetalhes = $this->calcularCMVMelhorado($pdo, $dataInicio, $dataFim);
        $cmv = $cmvDetalhes['total'];

        // Lucro bruto
        $lucroBruto = $receitaLiquida - $cmv;

        // Despesas operacionais
        $despesasOperacionais = $this->calcularDespesasOperacionais($pdo, $dataInicio, $dataFim);

        // Lucro operacional
        $lucroOperacional = $lucroBruto - $despesasOperacionais;

        // Outras receitas/despesas
        $outrasReceitas = $this->calcularOutrasReceitas($pdo, $dataInicio, $dataFim);
        $outrasDespesas = $this->calcularOutrasDespesas($pdo, $dataInicio, $dataFim);

        // Lucro líquido
        $lucroLiquido = $lucroOperacional + $outrasReceitas - $outrasDespesas;

        return [
            'periodo' => $mes ? "{$mes}/{$ano}" : "{$ano}",
            'data_inicio' => $dataInicio,
            'data_fim' => $dataFim,
            'receita_bruta' => $receitaBruta,
            'receita_bruta_pedidos' => $receitaBrutaPedidos,
            'receita_bruta_pdv' => $receitaBrutaPDV,
            'deducoes' => $deducoes,
            'receita_liquida' => $receitaLiquida,
            'cmv' => $cmv,
            'lucro_bruto' => $lucroBruto,
            'margem_bruta_percent' => $receitaLiquida > 0 ? round(($lucroBruto / $receitaLiquida) * 100, 2) : 0,
            'despesas_operacionais' => $despesasOperacionais,
            'lucro_operacional' => $lucroOperacional,
            'margem_operacional_percent' => $receitaLiquida > 0 ? round(($lucroOperacional / $receitaLiquida) * 100, 2) : 0,
            'outras_receitas' => $outrasReceitas,
            'outras_despesas' => $outrasDespesas,
            'lucro_liquido' => $lucroLiquido,
            'margem_liquida_percent' => $receitaLiquida > 0 ? round(($lucroLiquido / $receitaLiquida) * 100, 2) : 0,
            'detalhes' => [
                'impostos_sobre_vendas' => $deducoesDetalhes['impostos'] ?? 0,
                'devolucoes' => $deducoesDetalhes['devolucoes'] ?? 0,
                'descontos' => $deducoesDetalhes['descontos'] ?? 0,
                'abatimentos' => $deducoesDetalhes['abatimentos'] ?? 0,
                'cmv_estoque_inicial' => $cmvDetalhes['estoque_inicial'] ?? 0,
                'cmv_compras' => $cmvDetalhes['compras'] ?? 0,
                'cmv_estoque_final' => $cmvDetalhes['estoque_final'] ?? 0,
                'cmv_metodo' => $cmvDetalhes['metodo'] ?? 'PEPS'
            ]
        ];
    }

    /**
     * Calcula deduções da receita bruta
     */
    private function calcularDeducoes(PDO $pdo, string $dataInicio, string $dataFim, float $receitaBrutaPedidos, float $receitaBrutaPDV): array {
        $total = 0;
        $impostos = 0;
        $devolucoes = 0;
        $descontos = 0;
        $abatimentos = 0;

        // Impostos sobre vendas (ICMS, PIS, COFINS, IPI)
        // Primeiro tentar buscar de notas fiscais de saída
        try {
            $stmt = $pdo->prepare("
                SELECT 
                    COALESCE(SUM(valor_icms), 0) as icms,
                    COALESCE(SUM(valor_pis), 0) as pis,
                    COALESCE(SUM(valor_cofins), 0) as cofins,
                    COALESCE(SUM(valor_ipi), 0) as ipi
                FROM nfe_saida
                WHERE DATE(data_emissao) BETWEEN ? AND ? AND status = 'autorizada'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $impostosData = $stmt->fetch(PDO::FETCH_ASSOC);
            
            if ($impostosData && ((float)($impostosData['icms'] ?? 0) > 0 || (float)($impostosData['pis'] ?? 0) > 0)) {
                $impostosTotal = (float)($impostosData['icms'] ?? 0) + 
                                (float)($impostosData['pis'] ?? 0) + 
                                (float)($impostosData['cofins'] ?? 0) + 
                                (float)($impostosData['ipi'] ?? 0);
                $impostos = $impostosTotal;
                $total += $impostosTotal;
            } else {
                throw new \Exception('Impostos não encontrados em NF-e');
            }
        } catch (\Exception $e) {
            // Se não houver NF-e, calcular usando grupos tributários ou alíquotas padrão
            $receitaBruta = $receitaBrutaPedidos + $receitaBrutaPDV;
            
            // Tentar calcular usando grupos tributários dos produtos
            try {
                $stmt = $pdo->prepare("
                    SELECT 
                        SUM(soi.quantidade * soi.preco) as valor_total,
                        AVG(tg.icms_percent) as icms_avg,
                        AVG(tg.pis_percent) as pis_avg,
                        AVG(tg.cofins_percent) as cofins_avg,
                        AVG(tg.ipi_percent) as ipi_avg
                    FROM sales_order_items soi
                    INNER JOIN sales_orders so ON so.id = soi.order_id
                    LEFT JOIN products p ON p.id = soi.product_id
                    LEFT JOIN tax_groups tg ON tg.id = p.tax_group_id
                    WHERE DATE(so.created_at) BETWEEN ? AND ? AND so.status != 'cancelado'
                ");
                $stmt->execute([$dataInicio, $dataFim]);
                $taxData = $stmt->fetch(PDO::FETCH_ASSOC);
                
                if ($taxData && (float)($taxData['icms_avg'] ?? 0) > 0) {
                    $valorBase = (float)($taxData['valor_total'] ?? $receitaBruta);
                    $impostos = ($valorBase * (float)($taxData['icms_avg'] ?? 0) / 100) +
                               ($valorBase * (float)($taxData['pis_avg'] ?? 0) / 100) +
                               ($valorBase * (float)($taxData['cofins_avg'] ?? 0) / 100) +
                               ($valorBase * (float)($taxData['ipi_avg'] ?? 0) / 100);
                } else {
                    // Alíquotas padrão
                    $aliquotaICMS = 0.18;
                    $aliquotaPIS = 0.0165;
                    $aliquotaCOFINS = 0.076;
                    $impostos = ($receitaBruta * $aliquotaICMS) + 
                               ($receitaBruta * $aliquotaPIS) + 
                               ($receitaBruta * $aliquotaCOFINS);
                }
                $total += $impostos;
            } catch (\Exception $e2) {
                // Fallback: alíquotas padrão
                $aliquotaICMS = 0.18;
                $aliquotaPIS = 0.0165;
                $aliquotaCOFINS = 0.076;
                $impostos = ($receitaBruta * $aliquotaICMS) + 
                           ($receitaBruta * $aliquotaPIS) + 
                           ($receitaBruta * $aliquotaCOFINS);
                $total += $impostos;
            }
        }

        // Devoluções e cancelamentos
        $stmt = $pdo->prepare("
            SELECT COALESCE(SUM(valor_total), 0) as total
            FROM sales_orders
            WHERE DATE(created_at) BETWEEN ? AND ? AND status = 'cancelado'
        ");
        $stmt->execute([$dataInicio, $dataFim]);
        $devolucoes = (float)$stmt->fetchColumn();
        $total += $devolucoes;

        // Descontos concedidos em pedidos (buscar de itens se houver campo desconto)
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(desconto_percent * quantidade * preco / 100), 0) + COALESCE(SUM(desconto_valor), 0) as total
                FROM sales_order_items soi
                INNER JOIN sales_orders so ON so.id = soi.order_id
                WHERE DATE(so.created_at) BETWEEN ? AND ? AND so.status != 'cancelado'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $descontosPedidos = (float)$stmt->fetchColumn();
            $descontos += $descontosPedidos;
            $total += $descontosPedidos;
        } catch (\Exception $e) {
            // Tentar campo desconto simples
            try {
                $stmt = $pdo->prepare("
                    SELECT COALESCE(SUM(desconto), 0) as total
                    FROM sales_order_items soi
                    INNER JOIN sales_orders so ON so.id = soi.order_id
                    WHERE DATE(so.created_at) BETWEEN ? AND ? AND so.status != 'cancelado'
                ");
                $stmt->execute([$dataInicio, $dataFim]);
                $descontosPedidos = (float)$stmt->fetchColumn();
                $descontos += $descontosPedidos;
                $total += $descontosPedidos;
            } catch (\Exception $e2) {
                // Campo desconto não existe
            }
        }

        // Descontos do PDV
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(desconto_valor), 0) + COALESCE(SUM(desconto_percent * valor_total / 100), 0) as total
                FROM pos_sales
                WHERE DATE(created_at) BETWEEN ? AND ?
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $descontosPDV = (float)$stmt->fetchColumn();
            $descontos += $descontosPDV;
            $total += $descontosPDV;
        } catch (\Exception $e) {
            // Campos podem não existir
        }

        // Abatimentos (buscar de notas fiscais se existir)
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(valor_desconto), 0) as total
                FROM nfe_saida
                WHERE DATE(data_emissao) BETWEEN ? AND ? AND status = 'autorizada'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $abatimentos = (float)$stmt->fetchColumn();
            $total += $abatimentos;
        } catch (\Exception $e) {
            // Campo pode não existir
        }

        return [
            'total' => $total,
            'impostos' => $impostos,
            'devolucoes' => $devolucoes,
            'descontos' => $descontos,
            'abatimentos' => $abatimentos
        ];
    }

    /**
     * Calcula CMV (Custo de Mercadoria Vendida) melhorado
     * Usa fórmula: CMV = Estoque Inicial + Compras - Estoque Final
     * Considera método de custeio (PEPS, UEPS, Média Ponderada)
     */
    private function calcularCMVMelhorado(PDO $pdo, string $dataInicio, string $dataFim): array {
        // Obter método de custeio (padrão: PEPS)
        $metodoCusteio = 'PEPS'; // Pode ser configurável no futuro
        
        // Calcular estoque inicial (valor de custo no início do período)
        $estoqueInicial = $this->calcularEstoqueValor($pdo, $dataInicio, 'inicial');
        
        // Calcular compras no período
        $compras = $this->calcularCompras($pdo, $dataInicio, $dataFim);
        
        // Calcular estoque final (valor de custo no fim do período)
        $estoqueFinal = $this->calcularEstoqueValor($pdo, $dataFim, 'final');
        
        // CMV = Estoque Inicial + Compras - Estoque Final
        $cmv = $estoqueInicial + $compras - $estoqueFinal;
        
        // Se CMV for negativo ou muito baixo, calcular baseado em vendas
        if ($cmv <= 0 || $cmv < ($estoqueInicial * 0.1)) {
            $cmvVendas = $this->calcularCMVPorVendas($pdo, $dataInicio, $dataFim, $metodoCusteio);
            if ($cmvVendas > 0) {
                $cmv = $cmvVendas;
            }
        }
        
        return [
            'total' => max(0, $cmv),
            'estoque_inicial' => $estoqueInicial,
            'compras' => $compras,
            'estoque_final' => $estoqueFinal,
            'metodo' => $metodoCusteio
        ];
    }

    /**
     * Calcula valor do estoque em uma data específica
     */
    private function calcularEstoqueValor(PDO $pdo, string $data, string $tipo): float {
        try {
            // Para estoque inicial: calcular estoque atual e subtrair movimentações durante o período
            // Para estoque final: usar estoque atual
            if ($tipo === 'final') {
                // Estoque final: usar estoque atual
                $stmt = $pdo->prepare("
                    SELECT COALESCE(SUM(estoque * COALESCE(preco_custo, custo_medio, preco * 0.6, 0)), 0) as total
                    FROM products
                    WHERE estoque > 0
                ");
                $stmt->execute();
                return (float)$stmt->fetchColumn();
            } else {
                // Estoque inicial: calcular estoque atual menos movimentações após a data de início
                // Isso é uma aproximação - o ideal seria ter um snapshot de estoque
                $stmt = $pdo->prepare("
                    SELECT 
                        p.id,
                        p.estoque as estoque_atual,
                        COALESCE(p.preco_custo, p.custo_medio, p.preco * 0.6, 0) as custo_unitario,
                        COALESCE((
                            SELECT SUM(CASE 
                                WHEN im.tipo LIKE 'entrada%' OR im.tipo = 'in' THEN -im.quantidade
                                WHEN im.tipo LIKE 'saida%' OR im.tipo = 'out' THEN im.quantidade
                                ELSE 0
                            END)
                            FROM inventory_movements im
                            WHERE im.product_id = p.id AND DATE(im.created_at) >= ?
                        ), 0) as ajuste
                    FROM products p
                    WHERE p.estoque > 0 OR EXISTS (
                        SELECT 1 FROM inventory_movements im2 
                        WHERE im2.product_id = p.id
                    )
                ");
                $stmt->execute([$data]);
                $produtos = $stmt->fetchAll(PDO::FETCH_ASSOC);
                
                $valorTotal = 0;
                foreach ($produtos as $prod) {
                    $estoqueAtual = (float)max(0, $prod['estoque_atual']);
                    $ajuste = (float)$prod['ajuste'];
                    $estoqueInicial = max(0, $estoqueAtual + $ajuste); // Reverter movimentações
                    $custoUnitario = (float)$prod['custo_unitario'];
                    $valorTotal += $estoqueInicial * $custoUnitario;
                }
                
                return $valorTotal;
            }
        } catch (\Exception $e) {
            // Fallback: calcular usando estoque atual (para ambos)
            try {
                $stmt = $pdo->prepare("
                    SELECT COALESCE(SUM(estoque * COALESCE(preco_custo, custo_medio, preco * 0.6, 0)), 0) as total
                    FROM products
                    WHERE estoque > 0
                ");
                $stmt->execute();
                return (float)$stmt->fetchColumn();
            } catch (\Exception $e2) {
                return 0;
            }
        }
    }

    /**
     * Calcula valor de compras no período
     */
    private function calcularCompras(PDO $pdo, string $dataInicio, string $dataFim): float {
        $compras = 0;
        
        // Buscar compras de pedidos de compra
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(poi.quantidade * COALESCE(poi.preco_custo, p.preco_custo, p.custo_medio, p.preco * 0.6, 0)), 0) as total
                FROM purchase_order_items poi
                INNER JOIN purchase_orders po ON po.id = poi.order_id
                LEFT JOIN products p ON p.id = poi.product_id
                WHERE DATE(po.created_at) BETWEEN ? AND ? 
                AND po.status IN ('recebido', 'confirmado', 'faturado')
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $compras = (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            // Tabela pode não existir
        }
        
        // Buscar compras de notas fiscais de entrada
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(nfi.quantidade * COALESCE(nfi.preco_custo, p.preco_custo, p.custo_medio, p.preco * 0.6, 0)), 0) as total
                FROM nfe_entrada_items nfi
                INNER JOIN nfe_entrada nfe ON nfe.id = nfi.nfe_id
                LEFT JOIN products p ON p.id = nfi.product_id
                WHERE DATE(nfe.data_emissao) BETWEEN ? AND ? 
                AND nfe.status = 'autorizada'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $comprasNF = (float)$stmt->fetchColumn();
            $compras += $comprasNF;
        } catch (\Exception $e) {
            // Tabela pode não existir
        }
        
        // Buscar entradas de estoque (movimentações)
        try {
            $stmt = $pdo->prepare("
                SELECT 
                    im.product_id,
                    ABS(im.quantidade) as quantidade,
                    p.preco_custo,
                    p.custo_medio,
                    p.preco
                FROM inventory_movements im
                INNER JOIN products p ON p.id = im.product_id
                WHERE (im.tipo LIKE 'entrada%' OR im.tipo = 'in')
                AND DATE(im.created_at) BETWEEN ? AND ?
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $movimentos = $stmt->fetchAll(PDO::FETCH_ASSOC);
            
            foreach ($movimentos as $mov) {
                $quantidade = (float)$mov['quantidade'];
                $custoUnitario = (float)($mov['preco_custo'] ?? $mov['custo_medio'] ?? ($mov['preco'] * 0.6));
                $compras += $quantidade * $custoUnitario;
            }
        } catch (\Exception $e) {
            // Tabela pode não existir
        }
        
        return $compras;
    }

    /**
     * Calcula CMV baseado em vendas (método alternativo)
     */
    private function calcularCMVPorVendas(PDO $pdo, string $dataInicio, string $dataFim, string $metodo): float {
        $cmv = 0;
        
        // Buscar itens vendidos (pedidos)
        $stmt = $pdo->prepare("
            SELECT 
                soi.product_id,
                soi.quantidade,
                p.preco_custo,
                p.custo_medio,
                p.preco as preco_atual,
                p.codigo
            FROM sales_order_items soi
            INNER JOIN sales_orders so ON so.id = soi.order_id
            LEFT JOIN products p ON p.id = soi.product_id
            WHERE DATE(so.created_at) BETWEEN ? AND ? AND so.status != 'cancelado'
        ");
        $stmt->execute([$dataInicio, $dataFim]);
        $itensPedidos = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        foreach ($itensPedidos as $item) {
            $quantidade = (float)$item['quantidade'];
            $custoUnitario = (float)($item['preco_custo'] ?? $item['custo_medio'] ?? ($item['preco_atual'] * 0.6));
            $cmv += $quantidade * $custoUnitario;
        }
        
        // Buscar itens vendidos (PDV)
        try {
            $stmt = $pdo->prepare("
                SELECT 
                    psi.product_id,
                    psi.quantidade,
                    p.preco_custo,
                    p.custo_medio,
                    p.preco as preco_atual
                FROM pos_sale_items psi
                INNER JOIN pos_sales ps ON ps.id = psi.sale_id
                LEFT JOIN products p ON p.id = psi.product_id
                WHERE DATE(ps.created_at) BETWEEN ? AND ?
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $itensPDV = $stmt->fetchAll(PDO::FETCH_ASSOC);
            
            foreach ($itensPDV as $item) {
                $quantidade = (float)$item['quantidade'];
                $custoUnitario = (float)($item['preco_custo'] ?? $item['custo_medio'] ?? ($item['preco_atual'] * 0.6));
                $cmv += $quantidade * $custoUnitario;
            }
        } catch (\Exception $e) {
            // Tabela pode não existir
        }
        
        return $cmv;
    }

    /**
     * Calcula despesas operacionais
     */
    private function calcularDespesasOperacionais(PDO $pdo, string $dataInicio, string $dataFim): float {
        $total = 0;

        // Despesas pagas no período
        $stmt = $pdo->prepare("
            SELECT COALESCE(SUM(valor), 0) as total
            FROM contas_pagar
            WHERE DATE(data_pagamento) BETWEEN ? AND ? 
            AND status = 'pago'
            AND tipo IN ('despesa', 'operacional')
        ");
        $stmt->execute([$dataInicio, $dataFim]);
        $total += (float)$stmt->fetchColumn();

        // Se não houver campo tipo, buscar todas as despesas
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(valor), 0) as total
                FROM contas_pagar
                WHERE DATE(data_pagamento) BETWEEN ? AND ? 
                AND status = 'pago'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $total = (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            // Pode não ter campo tipo
        }

        return $total;
    }

    /**
     * Calcula outras receitas
     */
    private function calcularOutrasReceitas(PDO $pdo, string $dataInicio, string $dataFim): float {
        $total = 0;

        // Receitas não operacionais
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(valor), 0) as total
                FROM contas_receber
                WHERE DATE(data_recebimento) BETWEEN ? AND ? 
                AND status = 'pago'
                AND tipo = 'outras_receitas'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $total += (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            // Campo tipo pode não existir
        }

        return $total;
    }

    /**
     * Calcula outras despesas
     */
    private function calcularOutrasDespesas(PDO $pdo, string $dataInicio, string $dataFim): float {
        $total = 0;

        // Despesas não operacionais
        try {
            $stmt = $pdo->prepare("
                SELECT COALESCE(SUM(valor), 0) as total
                FROM contas_pagar
                WHERE DATE(data_pagamento) BETWEEN ? AND ? 
                AND status = 'pago'
                AND tipo = 'outras_despesas'
            ");
            $stmt->execute([$dataInicio, $dataFim]);
            $total += (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            // Campo tipo pode não existir
        }

        return $total;
    }

    /**
     * Gera Balanço Patrimonial
     */
    public function getBalanco(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $data = $req->query['data'] ?? date('Y-m-d');
            $cacheKey = CacheService::tenantKey('bi', "balanco_{$data}", $tenantId);
            
            $balanco = $this->cache->remember($cacheKey, function() use ($pdo, $data) {
                return $this->calculateBalanco($pdo, $data);
            }, 3600);

            return Response::json(['data' => $balanco]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula Balanço Patrimonial
     */
    private function calculateBalanco(PDO $pdo, string $data): array {
        // ATIVO
        // Ativo Circulante
        
        // Caixa e equivalentes (saldo de contas recebidas menos pagas até a data)
        $stmt = $pdo->prepare('
            SELECT 
                (SELECT COALESCE(SUM(valor), 0) FROM contas_receber WHERE data_recebimento <= ? AND status = "pago") -
                (SELECT COALESCE(SUM(valor), 0) FROM contas_pagar WHERE data_pagamento <= ? AND status = "pago") as saldo
        ');
        $stmt->execute([$data, $data]);
        $caixa = (float)$stmt->fetchColumn();
        $caixa = max(0, $caixa); // Não pode ser negativo no ativo

        // Contas a receber (duplicatas)
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(valor), 0) as total
            FROM contas_receber
            WHERE data_vencimento <= ? AND status = "pendente"
        ');
        $stmt->execute([$data]);
        $contasReceber = (float)$stmt->fetchColumn();

        // Estoque (valor de custo)
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(estoque * COALESCE(preco_custo, custo_medio, preco * 0.6, 0)), 0) as total
            FROM products
            WHERE estoque > 0
        ');
        $stmt->execute();
        $estoque = (float)$stmt->fetchColumn();

        // Duplicatas a receber (pedidos faturados mas não recebidos)
        try {
            $stmt = $pdo->prepare('
                SELECT COALESCE(SUM(valor_total), 0) as total
                FROM sales_orders
                WHERE DATE(created_at) <= ? 
                AND status IN ("faturado", "confirmado")
                AND id NOT IN (
                    SELECT DISTINCT order_id FROM contas_receber WHERE order_id IS NOT NULL
                )
            ');
            $stmt->execute([$data]);
            $duplicatasReceber = (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            $duplicatasReceber = 0;
        }

        // Impostos a recuperar (ICMS a recuperar, etc.)
        $impostosRecuperar = 0; // Placeholder - pode ser calculado de notas fiscais de entrada

        $ativoCirculante = $caixa + $contasReceber + $estoque + $duplicatasReceber + $impostosRecuperar;

        // Ativo Não Circulante
        // Investimentos
        $investimentos = 0; // Placeholder
        
        // Imobilizado (máquinas, equipamentos, veículos)
        $imobilizado = 0; // Placeholder - pode ser uma tabela de ativos fixos
        
        // Intangível (marcas, patentes, software)
        $intangivel = 0; // Placeholder
        
        // Depreciação acumulada
        $depreciacaoAcumulada = 0; // Placeholder
        
        $imobilizadoLiquido = max(0, $imobilizado - $depreciacaoAcumulada);

        $ativoNaoCirculante = $investimentos + $imobilizadoLiquido + $intangivel;

        $ativoTotal = $ativoCirculante + $ativoNaoCirculante;

        // PASSIVO
        // Passivo Circulante
        
        // Contas a pagar
        $stmt = $pdo->prepare('
            SELECT COALESCE(SUM(valor), 0) as total
            FROM contas_pagar
            WHERE data_vencimento <= ? AND status = "pendente"
        ');
        $stmt->execute([$data]);
        $contasPagar = (float)$stmt->fetchColumn();

        // Fornecedores a pagar (compras não pagas)
        try {
            $stmt = $pdo->prepare('
                SELECT COALESCE(SUM(valor_total), 0) as total
                FROM purchase_orders
                WHERE DATE(created_at) <= ? 
                AND status IN ("recebido", "confirmado", "faturado")
                AND id NOT IN (
                    SELECT DISTINCT order_id FROM contas_pagar WHERE order_id IS NOT NULL
                )
            ');
            $stmt->execute([$data]);
            $fornecedoresPagar = (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            $fornecedoresPagar = 0;
        }

        // Impostos a recolher (calcular de notas fiscais ou estimar)
        $impostosRecolher = 0;
        try {
            // Tentar buscar de notas fiscais de saída
            $stmt = $pdo->prepare('
                SELECT 
                    COALESCE(SUM(valor_icms), 0) +
                    COALESCE(SUM(valor_pis), 0) +
                    COALESCE(SUM(valor_cofins), 0) +
                    COALESCE(SUM(valor_ipi), 0) as total
                FROM nfe_saida
                WHERE DATE(data_emissao) <= ? AND status = "autorizada"
                AND id NOT IN (
                    SELECT DISTINCT nfe_id FROM contas_pagar WHERE nfe_id IS NOT NULL
                )
            ');
            $stmt->execute([$data]);
            $impostosRecolher = (float)$stmt->fetchColumn();
        } catch (\Exception $e) {
            // Se não houver NF-e, estimar baseado em vendas
            try {
                $stmt = $pdo->prepare('
                    SELECT COALESCE(SUM(valor_total), 0) as total
                    FROM sales_orders
                    WHERE DATE(created_at) <= ? AND status != "cancelado"
                ');
                $stmt->execute([$data]);
                $vendasTotal = (float)$stmt->fetchColumn();
                
                // Adicionar vendas do PDV
                try {
                    $stmt = $pdo->prepare('
                        SELECT COALESCE(SUM(valor_final), 0) as total
                        FROM pos_sales
                        WHERE DATE(created_at) <= ?
                    ');
                    $stmt->execute([$data]);
                    $vendasPDV = (float)$stmt->fetchColumn();
                    $vendasTotal += $vendasPDV;
                } catch (\Exception $e2) {
                    // Ignorar
                }
                
                $impostosRecolher = $vendasTotal * 0.27; // Estimativa: ICMS + PIS + COFINS
            } catch (\Exception $e2) {
                $impostosRecolher = 0;
            }
        }

        // Salários a pagar
        $salariosPagar = 0; // Placeholder

        // Encargos sociais a pagar
        $encargosSociaisPagar = 0; // Placeholder

        $passivoCirculante = $contasPagar + $fornecedoresPagar + $impostosRecolher + $salariosPagar + $encargosSociaisPagar;

        // Passivo Não Circulante
        // Empréstimos de longo prazo
        $emprestimosLongoPrazo = 0; // Placeholder
        
        // Financiamentos
        $financiamentos = 0; // Placeholder
        
        // Obrigações fiscais de longo prazo
        $obrigacoesFiscaisLongoPrazo = 0; // Placeholder

        $passivoNaoCirculante = $emprestimosLongoPrazo + $financiamentos + $obrigacoesFiscaisLongoPrazo;

        $passivoTotal = $passivoCirculante + $passivoNaoCirculante;

        // PATRIMÔNIO LÍQUIDO
        $patrimonioLiquido = $ativoTotal - $passivoTotal;

        // Capital social (configurável ou calculado)
        $capitalSocial = 0;
        try {
            // Tentar buscar de configurações ou tabela de patrimônio
            $stmt = $pdo->prepare('SELECT valor FROM config WHERE chave = "capital_social" LIMIT 1');
            $stmt->execute();
            $config = $stmt->fetch();
            if ($config) {
                $capitalSocial = (float)$config['valor'];
            }
        } catch (\Exception $e) {
            // Não existe configuração
        }

        // Calcular lucros acumulados
        // Lucro líquido acumulado = Receitas - Despesas até a data
        $lucrosAcumulados = 0;
        try {
            // Receitas (vendas)
            $stmt = $pdo->prepare('
                SELECT COALESCE(SUM(valor_total), 0) as total
                FROM sales_orders
                WHERE DATE(created_at) <= ? AND status != "cancelado"
            ');
            $stmt->execute([$data]);
            $receitas = (float)$stmt->fetchColumn();
            
            // Adicionar vendas do PDV
            try {
                $stmt = $pdo->prepare('
                    SELECT COALESCE(SUM(valor_final), 0) as total
                    FROM pos_sales
                    WHERE DATE(created_at) <= ?
                ');
                $stmt->execute([$data]);
                $receitasPDV = (float)$stmt->fetchColumn();
                $receitas += $receitasPDV;
            } catch (\Exception $e2) {
                // Ignorar
            }
            
            // Despesas (pagamentos)
            $stmt = $pdo->prepare('
                SELECT COALESCE(SUM(valor), 0) as total
                FROM contas_pagar
                WHERE DATE(data_pagamento) <= ? AND status = "pago"
            ');
            $stmt->execute([$data]);
            $despesas = (float)$stmt->fetchColumn();
            
            // CMV (custo das mercadorias vendidas) - usar método simplificado
            $cmv = 0;
            try {
                $stmt = $pdo->prepare('
                    SELECT COALESCE(SUM(soi.quantidade * COALESCE(p.preco_custo, p.custo_medio, p.preco * 0.6, 0)), 0) as total
                    FROM sales_order_items soi
                    INNER JOIN sales_orders so ON so.id = soi.order_id
                    LEFT JOIN products p ON p.id = soi.product_id
                    WHERE DATE(so.created_at) <= ? AND so.status != "cancelado"
                ');
                $stmt->execute([$data]);
                $cmv = (float)$stmt->fetchColumn();
                
                // Adicionar CMV do PDV
                try {
                    $stmt = $pdo->prepare('
                        SELECT COALESCE(SUM(psi.quantidade * COALESCE(p.preco_custo, p.custo_medio, p.preco * 0.6, 0)), 0) as total
                        FROM pos_sale_items psi
                        INNER JOIN pos_sales ps ON ps.id = psi.sale_id
                        LEFT JOIN products p ON p.id = psi.product_id
                        WHERE DATE(ps.created_at) <= ?
                    ');
                    $stmt->execute([$data]);
                    $cmvPDV = (float)$stmt->fetchColumn();
                    $cmv += $cmvPDV;
                } catch (\Exception $e3) {
                    // Ignorar
                }
            } catch (\Exception $e2) {
                // Ignorar
            }
            
            $lucrosAcumulados = $receitas - $despesas - $cmv;
        } catch (\Exception $e) {
            $lucrosAcumulados = 0;
        }

        // Reservas (reservas de lucros, reservas de capital, etc.)
        $reservas = 0; // Placeholder

        // Se capital social não foi definido, calcular como diferença
        if ($capitalSocial == 0) {
            $capitalSocial = max(0, $patrimonioLiquido - $lucrosAcumulados - $reservas);
        }

        return [
            'data' => $data,
            'ativo' => [
                'circulante' => [
                    'caixa' => $caixa,
                    'contas_receber' => $contasReceber,
                    'estoque' => $estoque,
                    'duplicatas_receber' => $duplicatasReceber,
                    'impostos_recuperar' => $impostosRecuperar,
                    'total' => $ativoCirculante,
                ],
                'nao_circulante' => [
                    'investimentos' => $investimentos,
                    'imobilizado' => $imobilizado,
                    'depreciacao_acumulada' => $depreciacaoAcumulada,
                    'imobilizado_liquido' => $imobilizadoLiquido,
                    'intangivel' => $intangivel,
                    'total' => $ativoNaoCirculante,
                ],
                'total' => $ativoTotal,
            ],
            'passivo' => [
                'circulante' => [
                    'contas_pagar' => $contasPagar,
                    'fornecedores_pagar' => $fornecedoresPagar,
                    'impostos_recolher' => $impostosRecolher,
                    'salarios_pagar' => $salariosPagar,
                    'encargos_sociais_pagar' => $encargosSociaisPagar,
                    'total' => $passivoCirculante,
                ],
                'nao_circulante' => [
                    'emprestimos_longo_prazo' => $emprestimosLongoPrazo,
                    'financiamentos' => $financiamentos,
                    'obrigacoes_fiscais_longo_prazo' => $obrigacoesFiscaisLongoPrazo,
                    'total' => $passivoNaoCirculante,
                ],
                'total' => $passivoTotal,
            ],
            'patrimonio_liquido' => [
                'capital_social' => $capitalSocial,
                'reservas' => $reservas,
                'lucros_acumulados' => $lucrosAcumulados,
                'total' => $patrimonioLiquido,
            ],
            'equilibrio' => abs($ativoTotal - ($passivoTotal + $patrimonioLiquido)) < 0.01, // Verificar se está equilibrado
        ];
    }

    /**
     * Gera Fluxo de Caixa Projetado
     */
    public function getFluxoCaixa(Request $req): Response {
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            $dias = (int)($req->query['dias'] ?? 30);
            $cacheKey = CacheService::tenantKey('bi', "fluxo_caixa_{$dias}", $tenantId);
            
            $fluxo = $this->cache->remember($cacheKey, function() use ($pdo, $dias) {
                return $this->calculateFluxoCaixa($pdo, $dias);
            }, 1800); // Cache por 30 minutos

            return Response::json(['data' => $fluxo]);
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Calcula Fluxo de Caixa Projetado
     */
    private function calculateFluxoCaixa(PDO $pdo, int $dias): array {
        $hoje = date('Y-m-d');
        $dataFim = date('Y-m-d', strtotime("+{$dias} days"));

        // Projeção de recebimentos
        $stmt = $pdo->prepare('
            SELECT DATE(data_vencimento) as data, COALESCE(SUM(valor), 0) as total
            FROM contas_receber
            WHERE data_vencimento BETWEEN ? AND ? AND status = "pendente"
            GROUP BY DATE(data_vencimento)
            ORDER BY data ASC
        ');
        $stmt->execute([$hoje, $dataFim]);
        $recebimentos = $stmt->fetchAll(PDO::FETCH_ASSOC);

        // Projeção de pagamentos
        $stmt = $pdo->prepare('
            SELECT DATE(data_vencimento) as data, COALESCE(SUM(valor), 0) as total
            FROM contas_pagar
            WHERE data_vencimento BETWEEN ? AND ? AND status = "pendente"
            GROUP BY DATE(data_vencimento)
            ORDER BY data ASC
        ');
        $stmt->execute([$hoje, $dataFim]);
        $pagamentos = $stmt->fetchAll(PDO::FETCH_ASSOC);

        // Saldo inicial (hoje)
        $stmt = $pdo->prepare('
            SELECT 
                (SELECT COALESCE(SUM(valor), 0) FROM contas_receber WHERE status = "pago" AND data_recebimento <= ?) -
                (SELECT COALESCE(SUM(valor), 0) FROM contas_pagar WHERE status = "pago" AND data_pagamento <= ?) as saldo
        ');
        $stmt->execute([$hoje, $hoje]);
        $saldoInicial = (float)$stmt->fetchColumn();

        return [
            'periodo' => [
                'inicio' => $hoje,
                'fim' => $dataFim,
            ],
            'saldo_inicial' => $saldoInicial,
            'recebimentos' => $recebimentos,
            'pagamentos' => $pagamentos,
        ];
    }

    /**
     * Exporta relatório
     */
    public function exportReport(Request $req): Response {
        $tipo = $req->get('params')[0] ?? '';
        $formato = strtolower($req->query['formato'] ?? 'pdf'); // pdf, excel, csv
        
        try {
            $tenantId = \Gestoreasy\Core\Tenant\TenantContext::getTenantId();
            $pdo = ConnectionManager::forTenant();
            
            switch ($tipo) {
                case 'dre':
                    $ano = (int)($req->query['ano'] ?? date('Y'));
                    $mes = $req->query['mes'] ?? null;
                    $data = $this->calculateDRE($pdo, $ano, $mes);
                    
                    if ($formato === 'pdf') {
                        return $this->exportarDREPDF($data);
                    } elseif ($formato === 'excel' || $formato === 'xlsx') {
                        return $this->exportarDREExcel($data);
                    } else {
                        return $this->exportarDRECSV($data);
                    }
                    
                case 'balanco':
                    $dataRef = $req->query['data'] ?? date('Y-m-d');
                    $data = $this->calculateBalanco($pdo, $dataRef);
                    
                    if ($formato === 'pdf') {
                        return $this->exportarBalancoPDF($data);
                    } elseif ($formato === 'excel' || $formato === 'xlsx') {
                        return $this->exportarBalancoExcel($data);
                    } else {
                        return $this->exportarBalancoCSV($data);
                    }
                    
                default:
                    return new Response(400, ['error' => ['code' => 'invalid_type', 'message' => 'Tipo de relatório inválido']]);
            }
        } catch (\Exception $e) {
            return new Response(500, ['error' => ['code' => 'export_error', 'message' => $e->getMessage()]]);
        }
    }

    /**
     * Exporta DRE em PDF
     */
    private function exportarDREPDF(array $dre): Response {
        $html = $this->gerarDREHTML($dre);
        
        // Tentar usar DomPDF ou TCPDF
        if (class_exists('Dompdf\Dompdf')) {
            $dompdf = new \Dompdf\Dompdf();
            $dompdf->loadHtml($html);
            $dompdf->setPaper('A4', 'portrait');
            $dompdf->render();
            
            $pdfContent = $dompdf->output();
            $filename = 'dre_' . str_replace('/', '_', $dre['periodo']) . '_' . date('YmdHis') . '.pdf';
            
            return new Response(200, $pdfContent, [
                'Content-Type' => 'application/pdf',
                'Content-Disposition' => 'attachment; filename="' . $filename . '"',
            ]);
        } elseif (class_exists('TCPDF')) {
            $pdf = new \TCPDF(PDF_PAGE_ORIENTATION, PDF_UNIT, PDF_PAGE_FORMAT, true, 'UTF-8', false);
            $pdf->SetCreator('GestorEasy ERP');
            $pdf->SetAuthor('GestorEasy');
            $pdf->SetTitle('DRE ' . $dre['periodo']);
            $pdf->setPrintHeader(false);
            $pdf->setPrintFooter(false);
            $pdf->AddPage();
            $pdf->writeHTML($html, true, false, true, false, '');
            
            $filename = 'dre_' . str_replace('/', '_', $dre['periodo']) . '_' . date('YmdHis') . '.pdf';
            $pdfContent = $pdf->Output('', 'S');
            
            return new Response(200, $pdfContent, [
                'Content-Type' => 'application/pdf',
                'Content-Disposition' => 'attachment; filename="' . $filename . '"',
            ]);
        } else {
            // Fallback: retornar HTML
            return new Response(200, $html, [
                'Content-Type' => 'text/html; charset=utf-8',
            ]);
        }
    }

    /**
     * Exporta DRE em Excel (CSV formatado)
     */
    private function exportarDREExcel(array $dre): Response {
        $csv = "Demonstração do Resultado do Exercício - {$dre['periodo']}\n\n";
        $csv .= "Período,Valor\n";
        $csv .= "Receita Bruta (Pedidos)," . number_format($dre['receita_bruta_pedidos'], 2, ',', '.') . "\n";
        $csv .= "Receita Bruta (PDV)," . number_format($dre['receita_bruta_pdv'], 2, ',', '.') . "\n";
        $csv .= "Receita Bruta Total," . number_format($dre['receita_bruta'], 2, ',', '.') . "\n";
        $csv .= "(-) Deduções," . number_format($dre['deducoes'], 2, ',', '.') . "\n";
        $csv .= "  Impostos sobre Vendas," . number_format($dre['detalhes']['impostos_sobre_vendas'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  Devoluções," . number_format($dre['detalhes']['devolucoes'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  Descontos," . number_format($dre['detalhes']['descontos'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  Abatimentos," . number_format($dre['detalhes']['abatimentos'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "Receita Líquida," . number_format($dre['receita_liquida'], 2, ',', '.') . "\n";
        $csv .= "(-) CMV," . number_format($dre['cmv'], 2, ',', '.') . "\n";
        $csv .= "  Estoque Inicial," . number_format($dre['detalhes']['cmv_estoque_inicial'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  (+) Compras," . number_format($dre['detalhes']['cmv_compras'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  (-) Estoque Final," . number_format($dre['detalhes']['cmv_estoque_final'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "Lucro Bruto," . number_format($dre['lucro_bruto'], 2, ',', '.') . "\n";
        $csv .= "Margem Bruta %," . number_format($dre['margem_bruta_percent'], 2, ',', '.') . "\n";
        $csv .= "(-) Despesas Operacionais," . number_format($dre['despesas_operacionais'], 2, ',', '.') . "\n";
        $csv .= "Lucro Operacional," . number_format($dre['lucro_operacional'], 2, ',', '.') . "\n";
        $csv .= "Margem Operacional %," . number_format($dre['margem_operacional_percent'], 2, ',', '.') . "\n";
        $csv .= "(+) Outras Receitas," . number_format($dre['outras_receitas'], 2, ',', '.') . "\n";
        $csv .= "(-) Outras Despesas," . number_format($dre['outras_despesas'], 2, ',', '.') . "\n";
        $csv .= "Lucro Líquido," . number_format($dre['lucro_liquido'], 2, ',', '.') . "\n";
        $csv .= "Margem Líquida %," . number_format($dre['margem_liquida_percent'], 2, ',', '.') . "\n";
        
        $filename = 'dre_' . str_replace('/', '_', $dre['periodo']) . '_' . date('YmdHis') . '.csv';
        
        return new Response(200, $csv, [
            'Content-Type' => 'text/csv; charset=utf-8',
            'Content-Disposition' => 'attachment; filename="' . $filename . '"',
        ]);
    }

    /**
     * Exporta DRE em CSV
     */
    private function exportarDRECSV(array $dre): Response {
        return $this->exportarDREExcel($dre); // Mesmo formato
    }

    /**
     * Gera HTML do DRE
     */
    private function gerarDREHTML(array $dre): string {
        $html = '<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>DRE ' . htmlspecialchars($dre['periodo']) . '</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1 { text-align: center; }
        table { width: 100%; border-collapse: collapse; margin: 20px 0; }
        th, td { padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }
        th { background-color: #f2f2f2; font-weight: bold; }
        .valor { text-align: right; }
        .total { font-weight: bold; background-color: #e8f4f8; }
        .subtitulo { padding-left: 20px; }
    </style>
</head>
<body>
    <h1>Demonstração do Resultado do Exercício</h1>
    <p><strong>Período:</strong> ' . htmlspecialchars($dre['periodo']) . '</p>
    <p><strong>Data de Início:</strong> ' . htmlspecialchars($dre['data_inicio']) . '</p>
    <p><strong>Data de Fim:</strong> ' . htmlspecialchars($dre['data_fim']) . '</p>
    
    <table>
        <tr><th>Descrição</th><th class="valor">Valor (R$)</th></tr>
        <tr><td>Receita Bruta (Pedidos)</td><td class="valor">' . number_format($dre['receita_bruta_pedidos'], 2, ',', '.') . '</td></tr>
        <tr><td>Receita Bruta (PDV)</td><td class="valor">' . number_format($dre['receita_bruta_pdv'], 2, ',', '.') . '</td></tr>
        <tr class="total"><td>Receita Bruta Total</td><td class="valor">' . number_format($dre['receita_bruta'], 2, ',', '.') . '</td></tr>
        <tr><td>(-) Deduções</td><td class="valor">' . number_format($dre['deducoes'], 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  Impostos sobre Vendas</td><td class="valor">' . number_format($dre['detalhes']['impostos_sobre_vendas'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  Devoluções</td><td class="valor">' . number_format($dre['detalhes']['devolucoes'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  Descontos</td><td class="valor">' . number_format($dre['detalhes']['descontos'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  Abatimentos</td><td class="valor">' . number_format($dre['detalhes']['abatimentos'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="total"><td>Receita Líquida</td><td class="valor">' . number_format($dre['receita_liquida'], 2, ',', '.') . '</td></tr>
        <tr><td>(-) CMV</td><td class="valor">' . number_format($dre['cmv'], 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  Estoque Inicial</td><td class="valor">' . number_format($dre['detalhes']['cmv_estoque_inicial'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  (+) Compras</td><td class="valor">' . number_format($dre['detalhes']['cmv_compras'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="subtitulo"><td>  (-) Estoque Final</td><td class="valor">' . number_format($dre['detalhes']['cmv_estoque_final'] ?? 0, 2, ',', '.') . '</td></tr>
        <tr class="total"><td>Lucro Bruto</td><td class="valor">' . number_format($dre['lucro_bruto'], 2, ',', '.') . ' (' . number_format($dre['margem_bruta_percent'], 2, ',', '.') . '%)</td></tr>
        <tr><td>(-) Despesas Operacionais</td><td class="valor">' . number_format($dre['despesas_operacionais'], 2, ',', '.') . '</td></tr>
        <tr class="total"><td>Lucro Operacional</td><td class="valor">' . number_format($dre['lucro_operacional'], 2, ',', '.') . ' (' . number_format($dre['margem_operacional_percent'], 2, ',', '.') . '%)</td></tr>
        <tr><td>(+) Outras Receitas</td><td class="valor">' . number_format($dre['outras_receitas'], 2, ',', '.') . '</td></tr>
        <tr><td>(-) Outras Despesas</td><td class="valor">' . number_format($dre['outras_despesas'], 2, ',', '.') . '</td></tr>
        <tr class="total"><td><strong>Lucro Líquido</strong></td><td class="valor"><strong>' . number_format($dre['lucro_liquido'], 2, ',', '.') . ' (' . number_format($dre['margem_liquida_percent'], 2, ',', '.') . '%)</strong></td></tr>
    </table>
    
    <p style="margin-top: 30px; font-size: 12px; color: #666;">
        Gerado em ' . date('d/m/Y H:i:s') . '
    </p>
</body>
</html>';
        
        return $html;
    }

    /**
     * Exporta Balanço em PDF
     */
    private function exportarBalancoPDF(array $balanco): Response {
        $html = $this->gerarBalancoHTML($balanco);
        
        if (class_exists('Dompdf\Dompdf')) {
            $dompdf = new \Dompdf\Dompdf();
            $dompdf->loadHtml($html);
            $dompdf->setPaper('A4', 'landscape');
            $dompdf->render();
            
            $pdfContent = $dompdf->output();
            $filename = 'balanco_' . str_replace('-', '_', $balanco['data']) . '_' . date('YmdHis') . '.pdf';
            
            return new Response(200, $pdfContent, [
                'Content-Type' => 'application/pdf',
                'Content-Disposition' => 'attachment; filename="' . $filename . '"',
            ]);
        } elseif (class_exists('TCPDF')) {
            $pdf = new \TCPDF('L', PDF_UNIT, PDF_PAGE_FORMAT, true, 'UTF-8', false);
            $pdf->SetCreator('GestorEasy ERP');
            $pdf->SetAuthor('GestorEasy');
            $pdf->SetTitle('Balanço Patrimonial ' . $balanco['data']);
            $pdf->setPrintHeader(false);
            $pdf->setPrintFooter(false);
            $pdf->AddPage();
            $pdf->writeHTML($html, true, false, true, false, '');
            
            $filename = 'balanco_' . str_replace('-', '_', $balanco['data']) . '_' . date('YmdHis') . '.pdf';
            $pdfContent = $pdf->Output('', 'S');
            
            return new Response(200, $pdfContent, [
                'Content-Type' => 'application/pdf',
                'Content-Disposition' => 'attachment; filename="' . $filename . '"',
            ]);
        } else {
            return new Response(200, $html, [
                'Content-Type' => 'text/html; charset=utf-8',
            ]);
        }
    }

    /**
     * Exporta Balanço em Excel
     */
    private function exportarBalancoExcel(array $balanco): Response {
        $csv = "Balanço Patrimonial - {$balanco['data']}\n\n";
        $csv .= "ATIVO,Valor\n";
        $csv .= "ATIVO CIRCULANTE,\n";
        $csv .= "  Caixa," . number_format($balanco['ativo']['circulante']['caixa'], 2, ',', '.') . "\n";
        $csv .= "  Contas a Receber," . number_format($balanco['ativo']['circulante']['contas_receber'], 2, ',', '.') . "\n";
        $csv .= "  Estoque," . number_format($balanco['ativo']['circulante']['estoque'], 2, ',', '.') . "\n";
        $csv .= "  Duplicatas a Receber," . number_format($balanco['ativo']['circulante']['duplicatas_receber'], 2, ',', '.') . "\n";
        $csv .= "  Impostos a Recuperar," . number_format($balanco['ativo']['circulante']['impostos_recuperar'], 2, ',', '.') . "\n";
        $csv .= "TOTAL ATIVO CIRCULANTE," . number_format($balanco['ativo']['circulante']['total'], 2, ',', '.') . "\n";
        $csv .= "ATIVO NÃO CIRCULANTE,\n";
        $csv .= "  Investimentos," . number_format($balanco['ativo']['nao_circulante']['investimentos'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  Imobilizado," . number_format($balanco['ativo']['nao_circulante']['imobilizado'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  (-) Depreciação Acumulada," . number_format($balanco['ativo']['nao_circulante']['depreciacao_acumulada'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  Imobilizado Líquido," . number_format($balanco['ativo']['nao_circulante']['imobilizado_liquido'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "  Intangível," . number_format($balanco['ativo']['nao_circulante']['intangivel'] ?? 0, 2, ',', '.') . "\n";
        $csv .= "TOTAL ATIVO NÃO CIRCULANTE," . number_format($balanco['ativo']['nao_circulante']['total'], 2, ',', '.') . "\n";
        $csv .= "TOTAL ATIVO," . number_format($balanco['ativo']['total'], 2, ',', '.') . "\n\n";
        
        $csv .= "PASSIVO,Valor\n";
        $csv .= "PASSIVO CIRCULANTE,\n";
        $csv .= "  Contas a Pagar," . number_format($balanco['passivo']['circulante']['contas_pagar'], 2, ',', '.') . "\n";
        $csv .= "  Fornecedores a Pagar," . number_format($balanco['passivo']['circulante']['fornecedores_pagar'], 2, ',', '.') . "\n";
        $csv .= "  Impostos a Recolher," . number_format($balanco['passivo']['circulante']['impostos_recolher'], 2, ',', '.') . "\n";
        $csv .= "  Salários a Pagar," . number_format($balanco['passivo']['circulante']['salarios_pagar'], 2, ',', '.') . "\n";
        $csv .= "  Encargos Sociais a Pagar," . number_format($balanco['passivo']['circulante']['encargos_sociais_pagar'], 2, ',', '.') . "\n";
        $csv .= "TOTAL PASSIVO CIRCULANTE," . number_format($balanco['passivo']['circulante']['total'], 2, ',', '.') . "\n";
        $csv .= "PASSIVO NÃO CIRCULANTE,\n";
        $csv .= "  Empréstimos de Longo Prazo," . number_format($balanco['passivo']['nao_circulante']['emprestimos_longo_prazo'], 2, ',', '.') . "\n";
        $csv .= "  Financiamentos," . number_format($balanco['passivo']['nao_circulante']['financiamentos'], 2, ',', '.') . "\n";
        $csv .= "  Obrigações Fiscais de Longo Prazo," . number_format($balanco['passivo']['nao_circulante']['obrigacoes_fiscais_longo_prazo'], 2, ',', '.') . "\n";
        $csv .= "TOTAL PASSIVO NÃO CIRCULANTE," . number_format($balanco['passivo']['nao_circulante']['total'], 2, ',', '.') . "\n";
        $csv .= "TOTAL PASSIVO," . number_format($balanco['passivo']['total'], 2, ',', '.') . "\n\n";
        
        $csv .= "PATRIMÔNIO LÍQUIDO,Valor\n";
        $csv .= "  Capital Social," . number_format($balanco['patrimonio_liquido']['capital_social'], 2, ',', '.') . "\n";
        $csv .= "  Reservas," . number_format($balanco['patrimonio_liquido']['reservas'], 2, ',', '.') . "\n";
        $csv .= "  Lucros Acumulados," . number_format($balanco['patrimonio_liquido']['lucros_acumulados'], 2, ',', '.') . "\n";
        $csv .= "TOTAL PATRIMÔNIO LÍQUIDO," . number_format($balanco['patrimonio_liquido']['total'], 2, ',', '.') . "\n";
        
        $filename = 'balanco_' . str_replace('-', '_', $balanco['data']) . '_' . date('YmdHis') . '.csv';
        
        return new Response(200, $csv, [
            'Content-Type' => 'text/csv; charset=utf-8',
            'Content-Disposition' => 'attachment; filename="' . $filename . '"',
        ]);
    }

    /**
     * Exporta Balanço em CSV
     */
    private function exportarBalancoCSV(array $balanco): Response {
        return $this->exportarBalancoExcel($balanco);
    }

    /**
     * Gera HTML do Balanço
     */
    private function gerarBalancoHTML(array $balanco): string {
        $html = '<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Balanço Patrimonial ' . htmlspecialchars($balanco['data']) . '</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1 { text-align: center; }
        table { width: 100%; border-collapse: collapse; margin: 20px 0; }
        th, td { padding: 8px; text-align: left; border: 1px solid #ddd; }
        th { background-color: #f2f2f2; font-weight: bold; }
        .valor { text-align: right; }
        .total { font-weight: bold; background-color: #e8f4f8; }
        .subtitulo { padding-left: 20px; }
        .coluna { width: 50%; float: left; }
    </style>
</head>
<body>
    <h1>Balanço Patrimonial</h1>
    <p><strong>Data de Referência:</strong> ' . htmlspecialchars($balanco['data']) . '</p>
    
    <div class="coluna">
        <h2>ATIVO</h2>
        <table>
            <tr><th>Descrição</th><th class="valor">Valor (R$)</th></tr>
            <tr><td colspan="2"><strong>ATIVO CIRCULANTE</strong></td></tr>
            <tr class="subtitulo"><td>  Caixa</td><td class="valor">' . number_format($balanco['ativo']['circulante']['caixa'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Contas a Receber</td><td class="valor">' . number_format($balanco['ativo']['circulante']['contas_receber'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Estoque</td><td class="valor">' . number_format($balanco['ativo']['circulante']['estoque'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Duplicatas a Receber</td><td class="valor">' . number_format($balanco['ativo']['circulante']['duplicatas_receber'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Impostos a Recuperar</td><td class="valor">' . number_format($balanco['ativo']['circulante']['impostos_recuperar'], 2, ',', '.') . '</td></tr>
            <tr class="total"><td>TOTAL ATIVO CIRCULANTE</td><td class="valor">' . number_format($balanco['ativo']['circulante']['total'], 2, ',', '.') . '</td></tr>
            <tr><td colspan="2"><strong>ATIVO NÃO CIRCULANTE</strong></td></tr>
            <tr class="subtitulo"><td>  Investimentos</td><td class="valor">' . number_format($balanco['ativo']['nao_circulante']['investimentos'] ?? 0, 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Imobilizado</td><td class="valor">' . number_format($balanco['ativo']['nao_circulante']['imobilizado'] ?? 0, 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  (-) Depreciação Acumulada</td><td class="valor">' . number_format($balanco['ativo']['nao_circulante']['depreciacao_acumulada'] ?? 0, 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Imobilizado Líquido</td><td class="valor">' . number_format($balanco['ativo']['nao_circulante']['imobilizado_liquido'] ?? 0, 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Intangível</td><td class="valor">' . number_format($balanco['ativo']['nao_circulante']['intangivel'] ?? 0, 2, ',', '.') . '</td></tr>
            <tr class="total"><td>TOTAL ATIVO NÃO CIRCULANTE</td><td class="valor">' . number_format($balanco['ativo']['nao_circulante']['total'], 2, ',', '.') . '</td></tr>
            <tr class="total"><td><strong>TOTAL ATIVO</strong></td><td class="valor"><strong>' . number_format($balanco['ativo']['total'], 2, ',', '.') . '</strong></td></tr>
        </table>
    </div>
    
    <div class="coluna">
        <h2>PASSIVO + PATRIMÔNIO LÍQUIDO</h2>
        <table>
            <tr><th>Descrição</th><th class="valor">Valor (R$)</th></tr>
            <tr><td colspan="2"><strong>PASSIVO CIRCULANTE</strong></td></tr>
            <tr class="subtitulo"><td>  Contas a Pagar</td><td class="valor">' . number_format($balanco['passivo']['circulante']['contas_pagar'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Fornecedores a Pagar</td><td class="valor">' . number_format($balanco['passivo']['circulante']['fornecedores_pagar'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Impostos a Recolher</td><td class="valor">' . number_format($balanco['passivo']['circulante']['impostos_recolher'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Salários a Pagar</td><td class="valor">' . number_format($balanco['passivo']['circulante']['salarios_pagar'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Encargos Sociais a Pagar</td><td class="valor">' . number_format($balanco['passivo']['circulante']['encargos_sociais_pagar'], 2, ',', '.') . '</td></tr>
            <tr class="total"><td>TOTAL PASSIVO CIRCULANTE</td><td class="valor">' . number_format($balanco['passivo']['circulante']['total'], 2, ',', '.') . '</td></tr>
            <tr><td colspan="2"><strong>PASSIVO NÃO CIRCULANTE</strong></td></tr>
            <tr class="subtitulo"><td>  Empréstimos de Longo Prazo</td><td class="valor">' . number_format($balanco['passivo']['nao_circulante']['emprestimos_longo_prazo'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Financiamentos</td><td class="valor">' . number_format($balanco['passivo']['nao_circulante']['financiamentos'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Obrigações Fiscais de Longo Prazo</td><td class="valor">' . number_format($balanco['passivo']['nao_circulante']['obrigacoes_fiscais_longo_prazo'], 2, ',', '.') . '</td></tr>
            <tr class="total"><td>TOTAL PASSIVO NÃO CIRCULANTE</td><td class="valor">' . number_format($balanco['passivo']['nao_circulante']['total'], 2, ',', '.') . '</td></tr>
            <tr class="total"><td><strong>TOTAL PASSIVO</strong></td><td class="valor"><strong>' . number_format($balanco['passivo']['total'], 2, ',', '.') . '</strong></td></tr>
            <tr><td colspan="2"><strong>PATRIMÔNIO LÍQUIDO</strong></td></tr>
            <tr class="subtitulo"><td>  Capital Social</td><td class="valor">' . number_format($balanco['patrimonio_liquido']['capital_social'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Reservas</td><td class="valor">' . number_format($balanco['patrimonio_liquido']['reservas'], 2, ',', '.') . '</td></tr>
            <tr class="subtitulo"><td>  Lucros Acumulados</td><td class="valor">' . number_format($balanco['patrimonio_liquido']['lucros_acumulados'], 2, ',', '.') . '</td></tr>
            <tr class="total"><td><strong>TOTAL PATRIMÔNIO LÍQUIDO</strong></td><td class="valor"><strong>' . number_format($balanco['patrimonio_liquido']['total'], 2, ',', '.') . '</strong></td></tr>
        </table>
    </div>
    
    <div style="clear: both;"></div>
    <p style="margin-top: 30px; font-size: 12px; color: #666;">
        Gerado em ' . date('d/m/Y H:i:s') . ' | Equilíbrio: ' . ($balanco['equilibrio'] ? 'Sim' : 'Não') . '
    </p>
</body>
</html>';
        
        return $html;
    }
}

