const express = require('express');
const router = express.Router();
const { DateTime } = require('luxon');
const axios = require('axios');

// Importă conexiunea la baza de date
const pool = require('../db'); 

// Importă middleware-ul de autentificare
const authenticateToken = require('../middleware/auth');

// Endpoint pentru a obține produsele - protejează ruta cu middleware-ul de autentificare
router.get('/last-receipt-number', async (req, res) => {
    const sql = 'SELECT MAX(nr_bon) AS last_receipt_number FROM receipts WHERE DATE(date) = CURRENT_DATE';

    try {
        const [result] = await pool.promise().query(sql);
        const lastReceiptNumber = result[0].last_receipt_number || 0;
        console.log('Last receipt number from DB for current day:', lastReceiptNumber);
        res.json({ last_receipt_number: lastReceiptNumber });
    } catch (err) {
        console.error('Database error:', err);
        res.status(500).json({ error: 'Database error' });
    }
});
router.post('/inregistrare-bon', async (req, res) => {
    const { total_valoare_bon, metode_incasare, username } = req.body; // Obține total_valoare_bon și metode_incasare din corpul cererii

    try {
        // Obține data curentă cu fusul orar București
        const nowBucharest = DateTime.now().setZone('Europe/Bucharest');
        const today = nowBucharest.toISODate(); // Formatul YYYY-MM-DD
        const fullDateTime = nowBucharest.toSQL({ includeOffset: false }); // Formatul complet SQL

        // Obține numărul următor de bon
        const [results] = await pool.promise().query('SELECT COUNT(*) AS count FROM receipts WHERE DATE(date) = ?', [today]);
        const nextNumber = results[0].count + 1;

        // Inserează noul bon în baza de date cu total_valoare_bon și status "emis"
        const [result] = await pool.promise().query(
            'INSERT INTO receipts (nr_bon, date, total_valoare_bon, username, status) VALUES (?, ?, ?, ?, ?)', 
            [nextNumber, fullDateTime, total_valoare_bon, username, 'emis']  // Setăm status la 'emis'
        );
        const receiptId = result.insertId; // Obține ID-ul bonului creat

        // Inserează metodele de încasare pentru acest bon
        if (Array.isArray(metode_incasare) && metode_incasare.length > 0) {
            const metodeIncasareValues = metode_incasare.map(({ id_incasare, valoare_total }) => 
                [receiptId, nextNumber, fullDateTime, id_incasare, valoare_total]
            );

            // Construim o singură interogare de inserare pentru toate metodele de încasare
            await pool.promise().query(
                'INSERT INTO moduri_incasare_bon (receipt_id, nr_bon, date, id_incasare, valoare_total) VALUES ?', 
                [metodeIncasareValues]
            );
        }

       

        // Răspuns JSON cu detaliile bonului
        res.json({ receipt_id: receiptId, nr_bon: nextNumber, total_valoare_bon, status: 'emis' });

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

router.post('/produse-bon', async (req, res) => {
    const { receipt_id, product_id, quantity, price } = req.body;

    // Inserare în receipt_items
    const insertReceiptItemSql = `
        INSERT INTO receipt_items (receipt_id, product_id, quantity, pret)
        VALUES (?, ?, ?, ?)
    `;

    try {
        // 1. Inserăm produsul în bon
        await pool.promise().query(insertReceiptItemSql, [receipt_id, product_id, quantity, price]);

        // 2. Apelăm procedura consuma_produs_fifo
        await pool.promise().query('CALL consuma_produs_fifo(?, ?)', [product_id, quantity]);

        res.status(200).json({ message: 'Produs adăugat și stoc actualizat FIFO' });
    } catch (err) {
        console.error('Eroare în endpointul /produse-bon:', err);
        res.status(500).json({ error: 'Eroare la inserare sau apel procedură' });
    }
});

router.get('/bonuri_produse', async (req, res) => {
    const { startDate, endDate } = req.query;

    // Verificăm dacă datele de început și sfârșit sunt definite
    if (!startDate || !endDate) {
        return res.status(400).json({ error: 'Datele de început și sfârșit trebuie să fie definite.' });
    }

    // Interogarea SQL pentru a aduce atât bonurile, cât și produsele lor
    const sql = `
        SELECT r.id AS receipt_id, r.status, r.date, r.nr_bon, r.total_valoare_bon, 
               p.id AS item_id, p.product_id, p.quantity
        FROM receipts r
        LEFT JOIN receipt_items p ON r.id = p.receipt_id
        WHERE DATE(r.date) BETWEEN ? AND ?
    `;

    try {
        const [results] = await pool.promise().query(sql, [startDate, endDate]);

        // Grupăm datele pentru a le organiza corect
        const bonuri = results.reduce((acc, row) => {
            // Căutăm bonul pe baza id-ului său (receipt_id din rezultate)
            let bon = acc.find(item => item.receipt_id === row.receipt_id);

            // Dacă bonul nu a fost adăugat încă în array, adăugăm un obiect nou pentru acesta
            if (!bon) {
                bon = { 
                    receipt_id: row.receipt_id, 
                    date: row.date, 
                    nr_bon: row.nr_bon,
                    status: row.status,
                    total_valoare_bon: row.total_valoare_bon,
                    receipt_items: [] 
                };
                acc.push(bon);
            }

            // Adăugăm produsul corespunzător bonului în receipt_items
            if (row.product_id) {
                bon.receipt_items.push({
                    item_id: row.item_id,  // Folosim item_id pentru a diferenția de id-ul bonului
                    product_id: row.product_id,
                    quantity: row.quantity,
                });
            }

            return acc;
        }, []);

        // Pentru fiecare produs, apelăm API-ul /api/get_product pentru a adăuga detaliile produsului
        for (let bon of bonuri) {
            for (let item of bon.receipt_items) {
                // Apelăm API-ul pentru detaliile produsului
                const productDetails = await getProductDetails(item.product_id);
                item.product_details = productDetails;
            }
        }

        // Trimitem răspunsul final
        res.json(bonuri);
    } catch (err) {
        console.error('Database error:', err);
        res.status(500).json({ error: 'Database error' });
    }
});

// Funcție auxiliară pentru a apela API-ul /api/get_product folosind GET
async function getProductDetails(productId) {
    try {
        // Asigură-te că folosești URL-ul complet pentru cererea GET
        const response = await axios.get(`http://localhost:5000/api/products/get_product/${productId}`);
        return response.data;
    } catch (err) {
        console.error('Error fetching product details:', err);
        return null;
    }
}
router.get('/get_bon', async (req, res) => {
    const { id } = req.query;

    if (!id) {
        return res.status(400).json({ error: 'ID-ul bonului este necesar.' });
    }

    const sql = `
        SELECT DISTINCT 
            r.id AS receipt_id, 
            r.date, 
            r.nr_bon, 
            r.total_valoare_bon,
            r.status, 
            ri.id AS item_id, 
            ri.product_id, 
            ri.quantity, 
            p.name AS product_name, 
            p.vat_rate, 
            p.unit_of_measure, 
            p.garantie_sgr,
            p.price,  
            ct.valoare_tva, 
            mi.id_incasare AS incasare_id,      
            mi.valoare_total AS incasare_valoare
        FROM receipts r
        LEFT JOIN receipt_items ri ON r.id = ri.receipt_id
        LEFT JOIN products p ON ri.product_id = p.id
        LEFT JOIN cote_tva ct ON p.vat_rate = ct.id_cota
        LEFT JOIN moduri_incasare_bon mi ON r.id = mi.receipt_id
        WHERE r.id = ?;
    `;

    try {
        const [results] = await pool.promise().query(sql, [id]);

        if (results.length === 0) {
            return res.status(404).json({ error: 'Bonul nu a fost găsit.' });
        }

        const bon = {
            receipt_id: results[0].receipt_id,
            date: results[0].date,
            nr_bon: results[0].nr_bon,
            totalBon: results[0].total_valoare_bon,
            receipt_items: [],
            incasareData: {}
        };

        // Grupăm produsele unice după item_id
        const seenItems = new Set();
        results.forEach((row) => {
            if (row.item_id && !seenItems.has(row.item_id)) {
                bon.receipt_items.push({
                    item_id: row.item_id,
                    product_id: row.product_id,
                    name: row.product_name,
                    price: row.price,
                    quantity: row.quantity,
                    vat_rate: row.vat_rate,
                    unit_of_measure: row.unit_of_measure,
                    garantie_sgr: row.garantie_sgr,
                    valoare_tva: row.valoare_tva
                });
                seenItems.add(row.item_id);
            }
        });

        // Grupăm valorile de încasare utilizând id_incasare ca și cheie
        const incasareData = {};
        let hasZeroIncasare = false;

        results.forEach((row) => {
            if (row.incasare_id !== null) {
                const valoare = parseFloat(row.incasare_valoare || 0).toFixed(2);

                if (row.incasare_id === 0) {
                    hasZeroIncasare = true;
                    incasareData["0"] = valoare;
                } else {
                    incasareData[row.incasare_id] = valoare;
                }
            }
        });

        // Dacă `id_incasare` este 0 și este singura înregistrare, returnăm doar acea valoare
        bon.incasareData = hasZeroIncasare ? incasareData : incasareData;

        res.json(bon);
    } catch (err) {
        console.error('Eroare la interogarea bazei de date:', err);
        res.status(500).json({ error: 'Eroare la interogarea bazei de date.' });
    }
});

router.post('/update-receipt-status', async (req, res) => {
    const { nr_bon, status } = req.body; // Preluăm și statusul din corpul cererii

    // Obținem data curentă în format YYYY-MM-DD
    const currentDate = new Date().toISOString().split('T')[0];

    // SQL pentru actualizarea coloanei `status` în baza `nr_bon` și a datei curente
    const updateStatusSql = `
        UPDATE receipts 
        SET status = ? 
        WHERE nr_bon = ? AND DATE(date) = ?
    `;

    try {
        // Executăm interogarea SQL pentru a actualiza statusul
        const [result] = await pool.promise().query(updateStatusSql, [status, nr_bon, currentDate]);

        if (result.affectedRows > 0) {
            console.log(`Status updated to '${status}' for nr_bon: ${nr_bon} on date: ${currentDate}`);
            res.send('Status updated successfully');
        } else {
            console.log(`No receipt found for nr_bon: ${nr_bon} on date: ${currentDate}`);
            res.status(404).json({ error: 'No receipt found for the given nr_bon and date' });
        }
    } catch (err) {
        console.error('Database error occurred:', err); // Log detaliat pentru eroare
        console.log(`Error details: nr_bon = ${nr_bon}, status = ${status}, date = ${currentDate}`);
        res.status(500).json({ error: 'Database error' });
    }
});



module.exports = router;
