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

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

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

router.post('/total-diferenta', async (req, res) => {
  const { data_inventar } = req.body;

  if (!data_inventar) {
    return res.status(400).json({ error: 'Data inventarului este necesară!' });
  }

  try {
    const sql = `
      SELECT 
        SUM(total_valoare_diferenta) AS valoare
      FROM inventar
      WHERE data_inventar = ?
    `;

    const [rows] = await pool.promise().query(sql, [data_inventar]);

    if (rows.length === 0 || rows[0].valoare === null) {
      return res.json({
        denumire_inventar: data_inventar,
        valoare: null
      });
    }

    res.json({
      denumire_inventar: data_inventar,
      valoare: rows[0].valoare
    });
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ error: 'Eroare la interogarea inventarului.' });
  }
});

// în fișierul inventar.js sau unde ai endpoint-ul pentru inventar
router.post('/', async (req, res) => {
  const produse = req.body; // array cu stoc, data_inventar și pret

  if (!Array.isArray(produse) || produse.length === 0) {
    return res.status(400).json({ error: 'Trebuie să trimiți o listă de produse!' });
  }

  const connection = await pool.promise().getConnection();
  await connection.beginTransaction();

  try {
    // 1. Preiau seria și ultimul număr pentru INVENTAR
    const [rows] = await connection.query(
      `SELECT ultimul_numar, serie_document 
       FROM serii_documente 
       WHERE nume_document = 'INVENTAR' 
       LIMIT 1`
    );

    if (rows.length === 0) {
      throw new Error("Nu există serie definită pentru documentul INVENTAR!");
    }

    let { ultimul_numar, serie_document } = rows[0];
    ultimul_numar = ultimul_numar + 1; // incrementez numărul

    // Construiesc id_document
    const id_document = `${serie_document}_${ultimul_numar}`;
    const dataDocument = produse[0].data_inventar; // presupun că toate au aceeași dată

    // 2. Pregătesc valorile pentru inventar și miscari_stoc
    const inventarValues = [];
    const miscariStocValues = [];

    for (const produs of produse) {
      const { 
        id_produs, 
        stoc_scriptic, 
        stoc_faptic, 
        data_inventar, 
        pret_produs, 
        id_gestiune 
      } = produs;

      if (
        !id_produs ||
        stoc_scriptic === undefined ||
        stoc_faptic === undefined ||
        !data_inventar ||
        pret_produs === undefined
      ) {
        throw new Error(`Date incomplete pentru produsul ${id_produs}`);
      }

      const stocScriptic = parseFloat(stoc_scriptic);
      const stocFaptic = parseFloat(stoc_faptic);
      const pret = parseFloat(pret_produs);
      const diferenta = stocFaptic - stocScriptic;
      const total_valoare_diferenta = diferenta * pret;

      inventarValues.push([
        id_produs,
        stocScriptic,
        stocFaptic,
        diferenta,
        data_inventar,
        pret,
        total_valoare_diferenta,
        ultimul_numar,
        serie_document,
        id_gestiune || null
      ]);

      // Pregătesc valori pentru miscari_stoc doar dacă există diferență
      if (diferenta !== 0) {
        miscariStocValues.push([
          'INVENTAR',           // tip_document
          ultimul_numar,        // id_document (numarul documentului)
          id_produs,
          id_gestiune || 1,     // id_gestiune (implicit 1)
          diferenta,            // cantitate (poate fi pozitivă sau negativă)
          pret,                 // pret_achizitie
          0,                    // pret_vanzare
          data_inventar         // data_miscare
        ]);
      }
    }

    // 3. Inserare în inventar
    const sqlInventar = `INSERT INTO inventar 
      (id_produs, stoc_scriptic, stoc_faptic, diferenta, data_inventar, pret_produs, total_valoare_diferenta, numar_document, serie_document, id_gestiune) 
      VALUES ?`;

    const [inventarResults] = await connection.query(sqlInventar, [inventarValues]);

    // 4. Inserare în miscari_stoc (dacă există valori)
    if (miscariStocValues.length > 0) {
      const sqlMiscariStoc = `INSERT INTO miscari_stoc 
        (tip_document, id_document, id_produs, id_gestiune, cantitate, pret_achizitie, pret_vanzare, data_miscare)
        VALUES ?`;

      await connection.query(sqlMiscariStoc, [miscariStocValues]);
    }

    // 5. Calculez totalul pentru raport_gestiune
    const totalValoare = inventarValues.reduce((sum, row) => sum + row[6], 0);

    // Inserare un singur rând în raport_gestiune
    const sqlRaport = `INSERT INTO raport_gestiune 
      (data_document, id_document, nr_document, val_intrare) 
      VALUES (?, ?, ?, ?)`;

    const [raportResults] = await connection.query(sqlRaport, [
      dataDocument,
      id_document,
      ultimul_numar,
      totalValoare
    ]);

    // 6. Actualizez ultimul_numar în tabelul serii_documente
    await connection.query(
      `UPDATE serii_documente 
       SET ultimul_numar = ? 
       WHERE nume_document = 'INVENTAR'`,
      [ultimul_numar]
    );

    await connection.commit();

    res.status(201).json({
      message: 'Inventarul și raportul de gestiune au fost actualizate cu succes!',
      serie_document,
      numar_document: ultimul_numar,
      id_document,
      total_valoare_inventar: totalValoare,
      produse_procesate: inventarValues.length,
      miscari_stoc_adaugate: miscariStocValues.length
    });
  } catch (err) {
    await connection.rollback();
    console.error('Database error:', err);
    res.status(500).json({ error: 'Eroare la actualizarea inventarului și raportului de gestiune.' });
  } finally {
    connection.release();
  }
});
// Endpoint pentru ștergerea unui inventar
router.delete('/:id_inventar', async (req, res) => {
  const { id_inventar } = req.params;

  try {
    await pool.promise().query('START TRANSACTION');

    // 1. Obține detaliile inventarului înainte de ștergere
    const [inventar] = await pool.promise().query(
      `SELECT * FROM inventar WHERE id_inventar = ?`,
      [id_inventar]
    );

    if (inventar.length === 0) {
      await pool.promise().query('ROLLBACK');
      return res.status(404).json({ message: 'Inventarul nu a fost găsit' });
    }

    // 2. Șterge mișcările de stoc asociate
    await pool.promise().query(
      `DELETE FROM miscari_stoc 
       WHERE tip_document = 'INVENTAR' 
       AND id_document = ? 
       AND id_produs = ?`,
      [inventar[0].numar_document, inventar[0].id_produs]
    );

    // 3. Șterge inventarul
    await pool.promise().query(`DELETE FROM inventar WHERE id_inventar = ?`, [id_inventar]);

    // 4. Recalculează totalul pentru raport_gestiune
    const [totalInventar] = await pool.promise().query(
      `SELECT SUM(total_valoare_diferenta) AS total 
       FROM inventar 
       WHERE serie_document = ? AND numar_document = ?`,
      [inventar[0].serie_document, inventar[0].numar_document]
    );

    const id_document = `${inventar[0].serie_document}_${inventar[0].numar_document}`;

    if (totalInventar[0].total === null) {
      // Dacă nu mai sunt înregistrări, șterge raportul
      await pool.promise().query(
        `DELETE FROM raport_gestiune WHERE id_document = ?`,
        [id_document]
      );
    } else {
      // Actualizează raportul cu noul total
      await pool.promise().query(
        `UPDATE raport_gestiune 
         SET val_intrare = ? 
         WHERE id_document = ?`,
        [totalInventar[0].total, id_document]
      );
    }

    await pool.promise().query('COMMIT');

    res.status(200).json({ 
      message: 'Inventarul a fost șters cu succes',
      id_inventar 
    });
  } catch (err) {
    await pool.promise().query('ROLLBACK');
    console.error('Eroare la ștergerea inventarului:', err);
    res.status(500).json({ error: 'Eroare la ștergerea inventarului' });
  }
});

// Endpoint pentru editarea unui inventar
router.put('/:id_inventar', async (req, res) => {
  const { id_inventar } = req.params;
  const { stoc_scriptic, stoc_faptic, data_inventar, pret_produs, id_gestiune } = req.body;

  try {
    await pool.promise().query('START TRANSACTION');

    // 1. Obține vechile date
    const [inventar] = await pool.promise().query(
      `SELECT * FROM inventar WHERE id_inventar = ?`,
      [id_inventar]
    );

    if (inventar.length === 0) {
      await pool.promise().query('ROLLBACK');
      return res.status(404).json({ message: 'Inventarul nu a fost găsit' });
    }

    const vechiStocScriptic = parseFloat(inventar[0].stoc_scriptic);
    const vechiStocFaptic = parseFloat(inventar[0].stoc_faptic);
    const vechDif = vechiStocFaptic - vechiStocScriptic;
    const vechiPret = parseFloat(inventar[0].pret_produs);

    // 2. Calculează noile valori
    const nouStocScriptic = parseFloat(stoc_scriptic);
    const nouStocFaptic = parseFloat(stoc_faptic);
    const nouaDif = nouStocFaptic - nouStocScriptic;
    const nouPret = parseFloat(pret_produs);
    const nouTotalValoare = nouaDif * nouPret;

    // 3. Actualizează inventarul
    await pool.promise().query(
      `UPDATE inventar 
       SET stoc_scriptic = ?, stoc_faptic = ?, diferenta = ?, 
           pret_produs = ?, total_valoare_diferenta = ?, 
           id_gestiune = ?, data_inventar = ?
       WHERE id_inventar = ?`,
      [nouStocScriptic, nouStocFaptic, nouaDif, nouPret, 
       nouTotalValoare, id_gestiune || 1, data_inventar, id_inventar]
    );

    // 4. Actualizează mișcarea de stoc
    // Șterge vechea mișcare
    await pool.promise().query(
      `DELETE FROM miscari_stoc 
       WHERE tip_document = 'INVENTAR' 
       AND id_document = ? 
       AND id_produs = ?`,
      [inventar[0].numar_document, inventar[0].id_produs]
    );

    // Adaugă noua mișcare (dacă există diferență)
    if (nouaDif !== 0) {
      await pool.promise().query(
        `INSERT INTO miscari_stoc 
         (tip_document, id_document, id_produs, id_gestiune, cantitate, 
          pret_achizitie, pret_vanzare, data_miscare)
         VALUES ('INVENTAR', ?, ?, ?, ?, ?, ?, ?)`,
        [inventar[0].numar_document, inventar[0].id_produs, 
         id_gestiune || 1, nouaDif, nouPret, 0, data_inventar]
      );
    }

    // 5. Recalculează totalul pentru raport_gestiune
    const [totalInventar] = await pool.promise().query(
      `SELECT SUM(total_valoare_diferenta) AS total 
       FROM inventar 
       WHERE serie_document = ? AND numar_document = ?`,
      [inventar[0].serie_document, inventar[0].numar_document]
    );

    const id_document = `${inventar[0].serie_document}_${inventar[0].numar_document}`;

    await pool.promise().query(
      `UPDATE raport_gestiune 
       SET val_intrare = ?, data_document = ?
       WHERE id_document = ?`,
      [totalInventar[0].total || 0, data_inventar, id_document]
    );

    await pool.promise().query('COMMIT');

    res.status(200).json({ 
      message: 'Inventarul a fost actualizat cu succes',
      id_inventar,
      modificari_stoc: nouaDif - vechDif
    });
  } catch (err) {
    await pool.promise().query('ROLLBACK');
    console.error('Eroare la actualizarea inventarului:', err);
    res.status(500).json({ error: 'Eroare la actualizarea inventarului' });
  }
});
router.get('/', async (req, res) => {
  try {
    const sql = `
      SELECT 
        inv.*,
        p.name AS nume_produs,
        p.barcode,
        g.denumire_gestiune
      FROM inventar inv
      LEFT JOIN products p ON inv.id_produs = p.id
      LEFT JOIN gestiuni g ON inv.id_gestiune = g.id_gestiune
      ORDER BY inv.data_inventar DESC, inv.id_inventar DESC
    `;
    const [rows] = await pool.promise().query(sql);
    res.json(rows);
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ error: 'Eroare la preluarea inventarelor.' });
  }
});
// Ruta pentru inventare grupate
router.get('/grupate', async (req, res) => {
  try {
    const sql = `
      SELECT 
        inv.serie_document,
        inv.numar_document,
        MIN(inv.data_inventar) as data_inventar,
        COUNT(*) as numar_produse,
        SUM(inv.total_valoare_diferenta) as total_valoare_diferenta,
        g.denumire_gestiune
      FROM inventar inv
      LEFT JOIN gestiuni g ON inv.id_gestiune = g.id_gestiune
      GROUP BY inv.serie_document, inv.numar_document, g.denumire_gestiune
      ORDER BY inv.numar_document DESC, inv.serie_document DESC
    `;
    const [rows] = await pool.promise().query(sql);
    res.json(rows);
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ error: 'Eroare la preluarea inventarelor grupate.' });
  }
});

// Ruta pentru detalii inventar (după serie și număr)
router.get('/detalii', async (req, res) => {
  const { serie_document, numar_document } = req.query;

  if (!serie_document || !numar_document) {
    return res.status(400).json({ error: 'Serie și numar document sunt necesare!' });
  }

  try {
    const sql = `
      SELECT 
        inv.*,
        p.name AS nume_produs,
        p.barcode,
        g.denumire_gestiune
      FROM inventar inv
      LEFT JOIN products p ON inv.id_produs = p.id
      LEFT JOIN gestiuni g ON inv.id_gestiune = g.id_gestiune
      WHERE inv.serie_document = ? AND inv.numar_document = ?
      ORDER BY p.name ASC
    `;
    const [rows] = await pool.promise().query(sql, [serie_document, numar_document]);
    res.json(rows);
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ error: 'Eroare la preluarea detaliilor inventarului.' });
  }
});

// Ruta pentru ștergerea întregului grup de inventar
router.delete('/grup/:serie_document/:numar_document', async (req, res) => {
  const { serie_document, numar_document } = req.params;

  const connection = await pool.promise().getConnection();
  await connection.beginTransaction();

  try {
    // 1. Șterge mișcările de stoc asociate
    await connection.query(
      `DELETE FROM miscari_stoc 
       WHERE tip_document = 'INVENTAR' 
       AND id_document = ?`,
      [numar_document]
    );

    // 2. Șterge inventarele
    await connection.query(
      `DELETE FROM inventar 
       WHERE serie_document = ? AND numar_document = ?`,
      [serie_document, numar_document]
    );

    // 3. Șterge din raport_gestiune
    const id_document = `${serie_document}_${numar_document}`;
    await connection.query(
      `DELETE FROM raport_gestiune 
       WHERE id_document = ?`,
      [id_document]
    );

    await connection.commit();

    res.status(200).json({ 
      message: 'Grupul de inventar a fost șters cu succes',
      serie_document,
      numar_document
    });
  } catch (err) {
    await connection.rollback();
    console.error('Eroare la ștergerea grupului de inventar:', err);
    res.status(500).json({ error: 'Eroare la ștergerea grupului de inventar' });
  } finally {
    connection.release();
  }
});

module.exports = router;
