const express = require('express');
const router = express.Router();

const pool = require('../db');

router.get('/data', async (req, res) => {
    const date = req.query.date;
    if (!date) {
        return res.status(400).json({ error: 'Data nu este definită.' });
    }
    const sql = `
        SELECT DATE(date) AS zi, SUM(total_valoare_bon) AS suma_totala
        FROM receipts
        WHERE DATE(date) = ?
        GROUP BY DATE(date)
        ORDER BY DATE(date) DESC
    `;
    try {
        const [results] = await pool.promise().query(sql, [date]);
        res.json(results);
    } catch (err) {
        console.error('Database error:', err);
        res.status(500).json({ error: 'Database error' });
    }
});

router.get('/informatii_receptii', async (req, res) => {
    const { data_document } = req.query;
    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
    res.setHeader('Pragma', 'no-cache');
    res.setHeader('Expires', '0');
    
    if (!data_document) {
        return res.status(400).json({ error: 'Parametrul data_document este necesar' });
    }
    const sqlReceptii = `
        SELECT 
            r.id_furnizor, 
            f.denumire AS nume_furnizor,
            r.total_vanzare,
            r.total_vanzare_cu_tva,
            DATE_FORMAT(r.data_document, '%Y-%m-%d') AS data_document,
            r.numar_document
        FROM receptii r
        LEFT JOIN furnizori f ON r.id_furnizor = f.id_furnizor
        WHERE r.data_document = ?
        ORDER BY r.data_document ASC
    `;
    try {
        const [results] = await pool.promise().query(sqlReceptii, [data_document]);
        let cumulativeBalance = 0;
        const output = [];
        results.forEach((row, index) => {
            let totalVanzare = parseFloat(row.total_vanzare) || 0;
            cumulativeBalance += totalVanzare;
            output.push({
                ...row,
                cumulative_balance: cumulativeBalance.toFixed(2),
                previous_balance: index === 0 ? 0 : output[index - 1].cumulative_balance
            });
        });
        res.json(output);
    } catch (err) {
        console.error('Eroare la interogarea bazei de date:', err);
        res.status(500).json({ error: 'Eroare la baza de date' });
    }
});

router.get('/intrari', async (req, res) => {
    const { data, _t } = req.query;
    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
    res.setHeader('Pragma', 'no-cache');
    res.setHeader('Expires', '0');
    
    if (!data) {
        return res.status(400).json({ error: 'Data lipsește din cerere' });
    }

    try {
        // 1. SOLD ANTERIOR: soldul final al zilei anterioare (cumulat până la ziua anterioară)
        const previousDate = new Date(data);
        previousDate.setDate(previousDate.getDate() - 1);
        const previousDateStr = previousDate.toISOString().split('T')[0];
        
        // Calcul pentru soldul până la ziua anterioară (inclusiv)
        const sqlSoldAnterior = `
            SELECT 
                COALESCE(SUM(val_intrare), 0) AS intrari_totale,
                COALESCE(SUM(val_iesire), 0) AS iesiri_totale
            FROM raport_gestiune
            WHERE data_document <= ?;
        `;
        const [soldAnteriorResults] = await pool.promise().query(sqlSoldAnterior, [previousDateStr]);
        const intrari_totale = parseFloat(soldAnteriorResults[0]?.intrari_totale || 0);
        const iesiri_totale = parseFloat(soldAnteriorResults[0]?.iesiri_totale || 0);

        // Bonuri până la ziua anterioară (inclusiv)
        const sqlBonuriAnterioare = `
            SELECT COALESCE(SUM(total_valoare_bon), 0) AS bonuri_totale
            FROM receipts
            WHERE DATE(date) <= ?;
        `;
        const [bonuriAnterioareResults] = await pool.promise().query(sqlBonuriAnterioare, [previousDateStr]);
        const bonuri_totale = parseFloat(bonuriAnterioareResults[0]?.bonuri_totale || 0);

        // Soldul anterior = total intrări - (total ieșiri + total bonuri) până la ziua anterioară
        const sold_anterior = intrari_totale - (iesiri_totale + bonuri_totale);

        // 2. Tranzacțiile zilei anterioare (doar pentru afișare)
        const sqlZiAnterioara = `
            SELECT 
                COALESCE(SUM(val_intrare), 0) AS intrari_zi,
                COALESCE(SUM(val_iesire), 0) AS iesiri_zi
            FROM raport_gestiune
            WHERE data_document = ?;
        `;
        const [ziAnterioaraResults] = await pool.promise().query(sqlZiAnterioara, [previousDateStr]);
        const intrari_zi_anterioara = parseFloat(ziAnterioaraResults[0]?.intrari_zi || 0);
        const iesiri_zi_anterioara = parseFloat(ziAnterioaraResults[0]?.iesiri_zi || 0);

        const sqlBonuriZiAnterioara = `
            SELECT COALESCE(SUM(total_valoare_bon), 0) AS bonuri_zi
            FROM receipts
            WHERE DATE(date) = ?;
        `;
        const [bonuriZiAnterioaraResults] = await pool.promise().query(sqlBonuriZiAnterioara, [previousDateStr]);
        const bonuri_zi_anterioara = parseFloat(bonuriZiAnterioaraResults[0]?.bonuri_zi || 0);

        const diferenta_anterioara = intrari_zi_anterioara - (iesiri_zi_anterioara + bonuri_zi_anterioara);

        // 3. DATE PENTRU ZIUA CURENTĂ
        // Intrări pentru ziua curentă (doar din raport_gestiune)
        const sqlIntrariCurente = `
            SELECT COALESCE(SUM(val_intrare), 0) AS suma_totala_intrari
            FROM raport_gestiune
            WHERE data_document = ?;
        `;
        const [intrariResults] = await pool.promise().query(sqlIntrariCurente, [data]);
        const suma_totala_intrari = parseFloat(intrariResults[0]?.suma_totala_intrari || 0);

        // Ieșiri pentru ziua curentă
        const sqlIesiriCurente = `
            SELECT COALESCE(SUM(val_iesire), 0) AS suma_totala_iesiri
            FROM raport_gestiune
            WHERE data_document = ?;
        `;
        const [iesiriResults] = await pool.promise().query(sqlIesiriCurente, [data]);
        const suma_totala_iesiri = parseFloat(iesiriResults[0]?.suma_totala_iesiri || 0);

        // Inventar pentru ziua curentă (doar pentru afișare)
        const sqlInventar = `
            SELECT COALESCE(SUM(total_valoare_diferenta), 0) AS suma_inventar
            FROM inventar
            WHERE data_inventar = ?;
        `;
        const [inventarResults] = await pool.promise().query(sqlInventar, [data]);
        const suma_inventar = parseFloat(inventarResults[0]?.suma_inventar || 0);

        // Bonuri pentru ziua curentă
        const sqlBonuriCurente = `
            SELECT COALESCE(SUM(total_valoare_bon), 0) AS suma_total_bonuri
            FROM receipts
            WHERE DATE(date) = ?;
        `;
        const [bonuriResults] = await pool.promise().query(sqlBonuriCurente, [data]);
        const suma_total_bonuri = parseFloat(bonuriResults[0]?.suma_total_bonuri || 0);

        // 4. TOTALURI ZI CURENTĂ
        const total_intrari = suma_totala_intrari;
        const total_iesiri = suma_totala_iesiri + suma_total_bonuri;
        const diferenta_selectata = total_intrari - total_iesiri;

        // 5. SOLD FINAL
        const sold_final = sold_anterior + diferenta_selectata;

        res.json({
            total_intrari: total_intrari,
            total_iesiri: total_iesiri,
            suma_total_bonuri,
            diferenta_selectata,
            intrari_anterioare: intrari_zi_anterioara,
            iesiri_anterioare: iesiri_zi_anterioara + bonuri_zi_anterioara,
            diferenta_anterioara,
            suma_inventar,
            sold: sold_final,
            sold_anterior: sold_anterior,
            timestamp: new Date().getTime()
        });

    } catch (err) {
        console.error('Database error:', err);
        res.status(500).json({ error: 'Database error' });
    }
});

module.exports = router;