const express = require('express');
const router = express.Router();
const pool = require('../db');
const authenticateToken = require('../middleware/auth');

// POST - Creare document stoc inițial
router.post('/',  async (req, res) => {
  const produse = req.body; // array cu produse pentru stoc inițial

  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 STOC_INITIAL
    const [serieRows] = await connection.query(
      `SELECT ultimul_numar, serie_document 
       FROM serii_documente 
       WHERE nume_document = 'STOC_INITIAL' 
       LIMIT 1`
    );

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

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

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

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

    for (const produs of produse) {
      const { 
        id_produs, 
        cantitate, 
        pret, 
        data_document, 
        id_gestiune 
      } = produs;

      if (!id_produs || cantitate === undefined || pret === undefined || !data_document) {
        throw new Error(`Date incomplete pentru produsul ${id_produs}`);
      }

      const cant = parseFloat(cantitate);
      const pretProd = parseFloat(pret);
      const valoare = cant * pretProd;

      stocInitialValues.push([
        id_produs,
        cant,
        pretProd,
        valoare,
        data_document,
        serie_document,
        ultimul_numar,
        id_gestiune || null
      ]);

      // Pregătesc valori pentru miscari_stoc (cantitatea este pozitivă pentru stoc inițial)
      miscariStocValues.push([
        'STOC_INITIAL',           // tip_document
        ultimul_numar,            // id_document (numarul documentului)
        id_produs,
        id_gestiune || 1,         // id_gestiune
        cant,                     // cantitate (pozitivă pentru stoc inițial)
        pretProd,                 // pret_achizitie
        0,                        // pret_vanzare
        data_document             // data_miscare
      ]);
    }

    // 3. Inserare în stocuri_initiale
    const sqlStocInitial = `INSERT INTO stocuri_initiale 
      (id_produs, cantitate, pret, valoare, data_document, serie_document, numar_document, id_gestiune) 
      VALUES ?`;

    await connection.query(sqlStocInitial, [stocInitialValues]);

    // 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 = stocInitialValues.reduce((sum, row) => sum + row[3], 0);

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

    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 = 'STOC_INITIAL'`,
      [ultimul_numar]
    );

    await connection.commit();

    res.status(201).json({
      message: 'Stocul inițial a fost creat cu succes!',
      serie_document,
      numar_document: ultimul_numar,
      id_document,
      total_valoare: totalValoare,
      produse_procesate: stocInitialValues.length
    });
  } catch (err) {
    await connection.rollback();
    console.error('Database error:', err);
    
    // Verifică dacă eroarea este legată de tip_document
    if (err.message.includes("Data truncated for column 'tip_document'")) {
      res.status(500).json({ 
        error: 'Eroare de baza de date: Tipul documentului este prea lung. Contactează administratorul.',
        details: 'Câmpul tip_document din tabelul miscari_stoc trebuie extins la minim 15 caractere.'
      });
    } else {
      res.status(500).json({ 
        error: 'Eroare la crearea stocului inițial.',
        details: err.message 
      });
    }
  } finally {
    connection.release();
  }
});

// GET - Căutare produs după barcode
router.get('/cauta-produs/:barcode',  async (req, res) => {
  const { barcode } = req.params;

  try {
    // Caut produsul după barcode
    const sql = `SELECT * FROM products WHERE barcode = ?`;
    const [produsRows] = await pool.promise().query(sql, [barcode]);

    if (produsRows.length > 0) {
      // Produsul există
      return res.json({
        exista: true,
        produs: produsRows[0]
      });
    } else {
      // Produsul nu există
      return res.json({
        exista: false,
        barcode: barcode
      });
    }
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ 
      error: 'Eroare la căutarea produsului.',
      details: err.message 
    });
  }
});

// POST - Adaugă produs nou (similar cu receptia)
router.post('/adauga-produs', async (req, res) => {
  const {
    name,
    barcode,
    price,
    vatRate,
    category,
    unitOfMeasure,
    garantieSgr,
    cod_nc,
    cod_cpv,
    tip_produs,
    id_garantie,
    cod_cantar // ✅ NOU
  } = req.body;

  const vatRateDecimal = parseFloat(vatRate);
  const garantieSgrValue = garantieSgr === 'da' ? 'da' : 'nu';
  const finalBarcode = barcode || generateEAN13();

  const codNcValue = cod_nc || 0;
  const codCpvValue = cod_cpv || 0;
  const idGarantieValue = garantieSgr === 'da' && id_garantie ? parseInt(id_garantie) : null;
  const codCantarValue = cod_cantar || null;

  const sql = `
    INSERT INTO products
    (name, barcode, price, vat_rate, category, unit_of_measure, garantie_sgr, cod_nc, cod_cpv, tip_produs, id_garantie, cod_cantar)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
  `;

  try {
    await pool.promise().query(sql, [
      name,
      finalBarcode,
      price,
      vatRateDecimal,
      category,
      unitOfMeasure,
      garantieSgrValue,
      codNcValue,
      codCpvValue,
      tip_produs,
      idGarantieValue,
      codCantarValue // ✅ NOU
    ]);

    res.send('Product added');
  } catch (err) {
    console.error('Error inserting product:', err);
    res.status(500).send('Error adding product');
  }
});


// GET - Stocuri inițiale grupate pe documente
router.get('/grupate',  async (req, res) => {
  try {
    const sql = `
      SELECT 
        si.serie_document,
        si.numar_document,
        MIN(si.data_document) as data_document,
        COUNT(*) as numar_produse,
        SUM(si.valoare) as total_valoare,
        MAX(g.denumire_gestiune) as denumire_gestiune
      FROM stocuri_initiale si
      LEFT JOIN gestiuni g ON si.id_gestiune = g.id_gestiune
      GROUP BY si.serie_document, si.numar_document
      ORDER BY si.numar_document DESC, si.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 stocurilor inițiale grupate.',
      details: err.message 
    });
  }
});

// GET - Detalii document (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 
        si.*,
        p.name AS nume_produs,
        p.barcode,
        p.unit_of_measure,
        g.denumire_gestiune
      FROM stocuri_initiale si
      LEFT JOIN products p ON si.id_produs = p.id
      LEFT JOIN gestiuni g ON si.id_gestiune = g.id_gestiune
      WHERE si.serie_document = ? AND si.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 stocului inițial.',
      details: err.message 
    });
  }
});

// PUT - Editare stoc inițial
router.put('/:id_stoc_initial',  async (req, res) => {
  const { id_stoc_initial } = req.params;
  const { cantitate, pret, data_document, id_gestiune } = req.body;

  if (cantitate === undefined || pret === undefined) {
    return res.status(400).json({ error: 'Cantitate și preț sunt obligatorii!' });
  }

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

  try {
    // 1. Obține vechile date
    const [stoc] = await connection.query(
      `SELECT * FROM stocuri_initiale WHERE id_stoc_initial = ?`,
      [id_stoc_initial]
    );

    if (stoc.length === 0) {
      await connection.rollback();
      return res.status(404).json({ message: 'Stocul inițial nu a fost găsit' });
    }

    const vecheCantitate = parseFloat(stoc[0].cantitate);
    const vechePret = parseFloat(stoc[0].pret);
    const vecheValoare = vecheCantitate * vechePret;

    // 2. Calculează noile valori
    const nouaCantitate = parseFloat(cantitate);
    const nouPret = parseFloat(pret);
    const nouaValoare = nouaCantitate * nouPret;
    const diferentaCantitate = nouaCantitate - vecheCantitate;

    // 3. Actualizează stocul inițial
    await connection.query(
      `UPDATE stocuri_initiale 
       SET cantitate = ?, pret = ?, valoare = ?, 
           data_document = ?, id_gestiune = ?, updated_at = CURRENT_TIMESTAMP
       WHERE id_stoc_initial = ?`,
      [nouaCantitate, nouPret, nouaValoare, data_document, id_gestiune || null, id_stoc_initial]
    );

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

    // Adaugă noua mișcare (doar dacă cantitatea > 0)
    if (nouaCantitate > 0) {
      await connection.query(
        `INSERT INTO miscari_stoc 
         (tip_document, id_document, id_produs, id_gestiune, cantitate, 
          pret_achizitie, pret_vanzare, data_miscare)
         VALUES ('STOC_INITIAL', ?, ?, ?, ?, ?, ?, ?)`,
        [stoc[0].numar_document, stoc[0].id_produs, 
         id_gestiune || 1, nouaCantitate, nouPret, 0, data_document]
      );
    }

    // 5. Recalculează totalul pentru raport_gestiune
    const [totalStoc] = await connection.query(
      `SELECT SUM(valoare) AS total 
       FROM stocuri_initiale 
       WHERE serie_document = ? AND numar_document = ?`,
      [stoc[0].serie_document, stoc[0].numar_document]
    );

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

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

    await connection.commit();

    res.status(200).json({ 
      message: 'Stocul inițial a fost actualizat cu succes',
      id_stoc_initial,
      modificari_valoare: nouaValoare - vecheValoare,
      diferenta_cantitate: diferentaCantitate
    });
  } catch (err) {
    await connection.rollback();
    console.error('Database error:', err);
    res.status(500).json({ 
      error: 'Eroare la actualizarea stocului inițial.',
      details: err.message 
    });
  } finally {
    connection.release();
  }
});

// DELETE - Ștergere stoc inițial (un singur produs)
router.delete('/:id_stoc_initial',  async (req, res) => {
  const { id_stoc_initial } = req.params;

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

  try {
    // 1. Obține detaliile stocului înainte de ștergere
    const [stoc] = await connection.query(
      `SELECT * FROM stocuri_initiale WHERE id_stoc_initial = ?`,
      [id_stoc_initial]
    );

    if (stoc.length === 0) {
      await connection.rollback();
      return res.status(404).json({ message: 'Stocul inițial nu a fost găsit' });
    }

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

    // 3. Șterge stocul inițial
    await connection.query(
      `DELETE FROM stocuri_initiale WHERE id_stoc_initial = ?`, 
      [id_stoc_initial]
    );

    // 4. Recalculează totalul pentru raport_gestiune
    const [totalStoc] = await connection.query(
      `SELECT SUM(valoare) AS total 
       FROM stocuri_initiale 
       WHERE serie_document = ? AND numar_document = ?`,
      [stoc[0].serie_document, stoc[0].numar_document]
    );

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

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

    await connection.commit();

    res.status(200).json({ 
      message: 'Stocul inițial a fost șters cu succes',
      id_stoc_initial 
    });
  } catch (err) {
    await connection.rollback();
    console.error('Database error:', err);
    res.status(500).json({ 
      error: 'Eroare la ștergerea stocului inițial.',
      details: err.message 
    });
  } finally {
    connection.release();
  }
});

// DELETE - Ștergere întregul grup de stoc inițial
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 = 'STOC_INITIAL' 
       AND id_document = ?`,
      [numar_document]
    );

    // 2. Șterge stocurile inițiale
    await connection.query(
      `DELETE FROM stocuri_initiale 
       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 stoc inițial a fost șters cu succes',
      serie_document,
      numar_document
    });
  } catch (err) {
    await connection.rollback();
    console.error('Database error:', err);
    res.status(500).json({ 
      error: 'Eroare la ștergerea grupului de stoc inițial.',
      details: err.message 
    });
  } finally {
    connection.release();
  }
});

// GET - Verificare stoc inițial existent pentru gestiune
router.get('/verifica-stoc-existente/:id_gestiune',  async (req, res) => {
  const { id_gestiune } = req.params;

  try {
    const sql = `
      SELECT COUNT(*) as numar_stocuri_initiale
      FROM stocuri_initiale 
      WHERE id_gestiune = ?
      LIMIT 1
    `;
    const [rows] = await pool.promise().query(sql, [id_gestiune]);
    
    res.json({
      are_stoc_initial: rows[0].numar_stocuri_initiale > 0,
      numar_stocuri: rows[0].numar_stocuri_initiale
    });
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ 
      error: 'Eroare la verificarea stocurilor inițiale.',
      details: err.message 
    });
  }
});

// GET - Produse pentru auto-completare
router.get('/autocomplete',  async (req, res) => {
  const { term } = req.query;

  if (!term || term.length < 2) {
    return res.json([]);
  }

  try {
    const sql = `
      SELECT id, barcode, name, pret_achizitie, unitate_masura 
      FROM products 
      WHERE barcode LIKE ? OR name LIKE ?
      LIMIT 10
    `;
    const searchTerm = `%${term}%`;
    const [rows] = await pool.promise().query(sql, [searchTerm, searchTerm]);
    res.json(rows);
  } catch (err) {
    console.error('Database error:', err);
    res.status(500).json({ 
      error: 'Eroare la căutarea produselor.',
      details: err.message 
    });
  }
});

module.exports = router;