const express = require('express');
const router = express.Router();
const mongoose = require('mongoose').set('debug', false);
const { CfgServer } = require('../models/cfgserver');

const shared_consts = require('../tools/shared_nodejs');

const tools = require('../tools/general');

const { City } = require('../models/city');
const Product = require('../models/product');
const Inventariogm = require('../models/inventariogm');
const Importamacro = require('../models/importamacro');
const ProductInfo = require('../models/productInfo');
const CatProd = require('../models/catprod');
const Author = require('../models/author');
const Publisher = require('../models/publisher');
const SubCatProd = require('../models/subcatprod');
const Gasordine = require('../models/gasordine');

var { authenticate } = require('../middleware/authenticate');

router.post('/updateval', authenticate, async (req, res) => {
  console.log('/updateval', req.body.pairval);
  idapp = req.body.idapp;
  pair = req.body.pairval;

  return await CfgServer.findOneAndUpdate(
    { chiave: pair.chiave, idapp, userId: pair.userId }, { $set: pair },
    { new: false }).then((item) => {
      // CfgServer.find({ chiave: pair.chiave }, (err, item) => {
      if (!!item) {
        res.status(200).send();
      } else {
        res.status(400).send();
      }
    }).catch(err => {
      console.log('ERR:', err);
      res.status(400).send();
    });

});

function fixURL(url) {
  return url.replace(/https:\//g, 'https://');
}


async function completaSettaggioProduct_AndProductInfo(arrcampi_productInfo, arrcampi_product, rec, product, productInfo) {

  try {
    if (shared_consts.CAMPI_PRODUCTINFO_CONVERT.includes('weight_and_unit')) {
      if (rec.hasOwnProperty('weight_and_unit')) {
        const ris1 = tools.getWeightAndUnitByText(rec['weight_and_unit']);
        if (ris1) {
          productInfo.weight = ris1.weight;
          productInfo.unit = ris1.unit;
        }
      }

    }

    if (shared_consts.CAMPI_PRODUCTINFO_CONVERT.includes('weight_and_unit_lordo')) {
      if (rec.hasOwnProperty('weight_and_unit_lordo')) {
        const ris2 = tools.getWeightAndUnitByText(rec['weight_and_unit_lordo']);
        if (ris2) {
          productInfo.weight_lordo = ris2.weight;
          productInfo.unit_lordo = ris2.unit;
        }
      }
    }

    if (rec.hasOwnProperty('link_scheda')) {
      if (fixURL(rec['link_scheda']))
        productInfo['link_scheda'] = fixURL(rec['link_scheda'])
    }

    for (const campo of shared_consts.PRODUCTINFO.CAMPI_FIRST_UPPERCASE) {

      if (rec.hasOwnProperty(campo)) {
        let mystr = tools.capitalize(rec[campo]).trim();
        if (mystr)
          productInfo[campo] = mystr;
      }
    }

    // Conversione in Euro
    for (campoprezzo of shared_consts.CAMPI_EURO) {
      if (rec.hasOwnProperty(campoprezzo)) {
        product[campoprezzo] = tools.convertPriceEurToValue(rec[campoprezzo])
      }
    }

    if (!rec.hasOwnProperty('img') && product.code) {
      productInfo.img = 'upload/products/' + product.code + '.jpg';
    } else {
      if (rec.hasOwnProperty('img')) {
        productInfo.img = 'upload/products/' + rec['img'];
      }
    }

    if (rec.hasOwnProperty('old_code')) {
      const old_code = rec['old_code'];
      let oldrec = await ProductInfo.findOne({ code: old_code }).lean();
      if (oldrec) {
        const precid = productInfo._id;
        const preccode = productInfo.code;

        productInfo = oldrec;
        if (precid)
          productInfo._id = precid;
        else
          delete productInfo._id;

        productInfo.code = preccode;
      }
    }
    if (rec.hasOwnProperty('productType')) {
      productInfo.productType = rec.hasOwnProperty('productType');
    } else {
      productInfo.productType = shared_consts.PRODUCTTYPE.PRODUCT;
    }

    return { product, productInfo };

  } catch (e) {
    console.error('Err', e);
  }


  return { product, productInfo };
}

function getValoriAndIndice(dati, arrinclude) {
  const campi = dati;

  for (const key in campi) {
    if (Object.hasOwnProperty.call(obj, key)) {
      const value = obj[key];
      console.log(`${key}: ${value}`);
    }
  }

  const risultato = campi.map((campo, indice) => {
    let mycampo = campo.trim();
    if (arrinclude) {
      if (arrinclude.includes(mycampo))
        return { name: mycampo, ind: indice };
    } else {
      return { name: mycampo, ind: indice };
    }

  });

  return risultato;
}

function getValoriAndIndice_ProductInfo(dati) {
  //return getValoriAndIndice(dati, shared_consts.CAMPI_PRODUCTINFO)
  return shared_consts.CAMPI_PRODUCTINFO;
}

function getValoriAndIndice_Product(dati) {
  //return getValoriAndIndice(dati, shared_consts.CAMPI_PRODUCT);
  return shared_consts.CAMPI_PRODUCT;
}

async function extractArrayDataFromCSV(idapp, rec) {

  try {
    // la prima riga contiene il nome della proprietà:
    let productInfo = {
      idapp: idapp,
      idCatProds: [],
      idSubCatProds: [],
    };

    let product = {
      idapp,
    };

    arrcampi_productInfo = getValoriAndIndice_ProductInfo(null);
    arrcampi_product = getValoriAndIndice_Product(null);

    for (const campoobj of arrcampi_productInfo) {
      if (rec.hasOwnProperty(campoobj.name)) {
        let myval = tools.ripulisciCampo(rec[campoobj.name]);
        productInfo[campoobj.name] = (myval === 'TRUE' || myval.toUpperCase() === 'SI') ? true : ((myval === 'FALSE' || myval.toUpperCase() === 'NO') ? false : myval);
      }

    }

    for (const campoobj of arrcampi_product) {
      if (rec.hasOwnProperty(campoobj))
        product[campoobj] = rec[campoobj];
    }

    const ris = await completaSettaggioProduct_AndProductInfo(arrcampi_productInfo, arrcampi_product, rec, product, productInfo);

    /*
      // code: product.code,
      name: product.name,
      link: product.link,
      idCatProds: [],
      idSubCatProds: [],
      img: 'upload/products/' + product.code + '.jpg',
      weight: product.weight,
      unit: tools.getIdUnitsByText(product.unit),
    }
  
  
    */

    return ris;


  } catch (e) {
    console.error('Err', e);
  }

  return dataObjects;

};

function extractNameAndSurnameByComplete(name_complete) {

  if (name_complete) {
    const name = name_complete.split(' ')[0];
    const surname = name_complete.split(' ')[1];
    return { name, surname };
  } else {
    return { name: '', surname: '' };
  }
}

router.post('/import', authenticate, async (req, res) => {

  try {
    const cmd = req.body.cmd;
    const idapp = req.body.idapp;
    const data = req.body.data;
    const options = req.body.data.options;

    const liste = require('../data/liste');
    let dataObjects = null;

    if (cmd === shared_consts.Cmd.CITIES_SERVER) {
      return await City.insertMany(liste.Comuni).then((ris) => {
        return res.status(200).send(true);
      });
    } else if (cmd === shared_consts.Cmd.INVENTARIO) {
      dataObjects = JSON.parse(`[${data.arrdata}]`);
      let updated = 0;
      let imported = 0;
      let errors = 0;

      for (const recinv of dataObjects) {
        let isnuovo = false
        let setta = false

        let inventario = recinv;

        inventario.idapp = idapp;

        let risrec = await Inventariogm.findOneAndUpdate(queryprod, { $set: inventario }, { new: true, upsert: true });
      }

    } else if (cmd === shared_consts.Cmd.MACRO_CATALOGO_JSON) {
      let updated = 0;
      let imported = 0;
      let errors = 0;

      dataObjects = null;

      try {
        dataObjects = JSON.parse(`[${data.arrdata}]`);
      } catch (e) {
        dataObjects = null;
      }

      if (dataObjects && dataObjects[0]) {
        // Cancella la collection ImportaMacros
        await Importamacro.deleteMany({ idapp });

        // Aggiungi i record su ImportaMacros
        for (const recinv of dataObjects[0]) {
          let isnuovo = false
          let setta = false

          let recmacro = recinv;

          recmacro.idapp = idapp;

          recmacro._id = recmacro.id;

          delete recmacro.id;

          let queryprod = { idapp, _id: recmacro._id };

          try {
            let risrec = await Importamacro.findOneAndUpdate(queryprod, { $set: recmacro }, { new: true, upsert: true, strict: false });
            if (risrec) {
              imported++;
            }

          } catch (e) {
            console.error(e);
            errors++;
          }
        }
      }

      const cancella_categorie = true;

      if (cancella_categorie) {
        await CatProd.deleteMany({ idapp });
      }


      // Rileggi tutti i record di ImportaMacros
      dataObjects = await Importamacro.find({ idapp }).lean();

      console.log('*** INIZIO IMPORT PRODOTTI ... ');

      let indprod = 0;
      let newprod = 0;

      for (const product of dataObjects) {
        let isnuovo = false
        let setta = false

        let importa = true;

        if (!product.title || !product.isbn)
          importa = false;

        if (importa) {
          let productInfo = {
            idapp: product.idapp,
            code: product.isbn,
            id_wp: product._id,
            name: product.title,
            description: product.description,
            publisher: product.Editore,
            collezione: product.Collezione,
            // author: product.Autore ? product.Autore : '',
            link: product.link ? product.link : '',
            idCatProds: [],
            idSubCatProds: [],
            //img: 'upload/products/' + product.code + '.jpg',
            image_link: product.image_link ? product.image_link : '',
            img2: product.img2 ? product.img2 : '',
            img3: product.img3 ? product.img3 : '',
            img4: product.img4 ? product.img4 : '',

          }

          productInfo.productType = shared_consts.PRODUCTTYPE.LIBRO;

          if (product.Data)
            productInfo.date_publishing = new Date(product.Data * 1000);

          productInfo.name = productInfo.name.replace(/ - Usato$| - Nuovo$| - Epub$| - Ebook$| - Mobi$| - DVD$| - Streaming$| - Download$/, "");

          if (product.Pagine) {
            try {
              productInfo.numpages = 0;
              productInfo.numpages = parseInt(product.Pagine);
            } catch (e) {
              console.error(e);
            }
          }

          let reccateg = null;
          if (product.categories) {
            arrcat = product.categories.trim().split(',');
            for (const mycat of arrcat) {
              let mycatstr = mycat.trim();

              // Controlla se ci sono le sottocategorie:
              arrsubcat = mycatstr.trim().split('>');

              if (arrsubcat.length > 1) {
                // Ci sono delle sottocategorie
                mycatstr = arrsubcat[0].trim();
                product.subcat_name = arrsubcat[1].trim();;
              }

              // Cerca la Categoria
              reccateg = await CatProd.findOne({ idapp, name: mycatstr }).lean();
              if (!reccateg) {
                // Non esiste questo produttore, quindi lo creo !
                reccateg = new CatProd({ idapp, name: mycatstr });
                ris = await reccateg.save();
                reccateg = await CatProd.findOne({ idapp, name: mycatstr }).lean();
              }

              if (reccateg) {
                productInfo.idCatProds.push(reccateg._id);
              }
            }
          }

          // "Autore" : "Silia,Marucelli, Stefano,Cattinelli",
          let arrAuthor = [];
          if (product.Autore) {
            const arrrecauthor = product.Autore.trim().split(',');

            if (arrrecauthor.length >= 1) {
              try {
                let author = {
                  name: arrrecauthor[0].trim(),
                }
                if (arrrecauthor.length === 1) {
                  author = extractNameAndSurnameByComplete(arrrecauthor[0].trim());
                } else {
                  author.surname = arrrecauthor[1].trim();
                }
                arrAuthor.push(author);

                if (arrrecauthor.length > 1) {
                  for (let i = 2; i < arrrecauthor.length; i = i + 2) {
                    try {
                      author = {
                        name: arrrecauthor[i].trim()
                      }
                      if (arrrecauthor.length > i + 1) {
                        surname = arrrecauthor[i + 1].trim()
                      }
                      arrAuthor.push(author);
                    } catch (e) {
                    }
                  }
                }
                productInfo.idAuthors = [];

                for (const myauthor of arrAuthor) {
                  // Cerca l'Autore
                  recauthor = await Author.findOne({ idapp, name: myauthor.name, surname: myauthor.surname }).lean();
                  if (!recauthor) {
                    // Non esiste questo Autore, quindi lo creo !
                    recauthor = new Author({ idapp, name: myauthor.name, surname: myauthor.surname });
                    ris = await recauthor.save();
                    recauthor = await Author.findOne({ idapp, name: myauthor.name, surname: myauthor.surname }).lean();
                  }

                  if (recauthor) {
                    productInfo.idAuthors.push(recauthor._id);
                  }

                }

              } catch (e) {
                console.error(e);
              }
            }
          }

          // Cancella l'Autore dal record product
          delete product.Autore;

          if (product.subcat_name) {
            arrsubcat = product.subcat_name.trim().split(',');
            for (const mysubcat of arrsubcat) {
              let mysubcatstr = mysubcat.trim();

              // Cerca la Sotto Categoria
              let recsubcateg = await SubCatProd.findOne({ idapp, name: mysubcatstr }).lean();
              if (!recsubcateg) {
                // Non esiste questa Sotto Categoria, quindi la creo !
                const idCatProd = reccateg ? reccateg._id : ''
                recsubcateg = new SubCatProd({ idapp, name: mysubcatstr, idCatProd });
                ris = await recsubcateg.save();
                recsubcateg = await SubCatProd.findOne({ idapp, name: mysubcatstr, idCatProd }).lean();
              }

              if (recsubcateg) {
                productInfo.idSubCatProds.push(recsubcateg._id);
              }
            }
          }

          if (!product.hasOwnProperty('active')) {
            product.active = true;
          }

          if (product.code)
            delete product.code;
          if (product.name)
            delete product.name;
          if (product.link)
            delete product.link;

          let esisteindb = await ProductInfo.findOne({ code: productInfo.code }).lean();
          // Update ProductInfo
          let risrecInfo = await ProductInfo.findOneAndUpdate({ code: productInfo.code }, { $set: productInfo }, { new: true, upsert: true });
          if (risrecInfo) {
            product.idProductInfo = risrecInfo._id;
            recnewInfo = await ProductInfo.findOne({ code: productInfo.code }).lean();

            if (risrecInfo._id) {
              // Record existed, so it was updated
              let arrfieldchange = tools.differentObjects(productInfo, recnewInfo);
              if (arrfieldchange && arrfieldchange.length > 0) {
                updated++;
                console.log('Changed: ', recnewInfo.name + ': ' + arrfieldchange);
              }
            }

            // Cerca il GAS
            let recGas = null;
            if (product.gas_name) {
              // Cerca il GAS
              recGas = await Gasordine.findOne({ idapp, name: product.gas_name }).lean();
            }

            if (!recGas && !!product.gas_name) {
              recGas = new Gasordine({ idapp, name: product.gas_name, active: true });
              // Non esiste questo GAS, quindi lo creo !
              ris = await recGas.save();
              recGas = await Gasordine.findOne({ idapp, name: product.gas_name }).lean();
            }

            let myproduct = {};

            // Download, DVD, Epub, Mobi, Nuovo, PDF, Streaming, Usato
            if (product.Versione === 'Nuovo')
              myproduct.versione = shared_consts.VERSIONE.NUOVO
            else if (product.Versione === 'Usato')
              myproduct.versione = shared_consts.VERSIONE.USATO;
            else if (product.Versione === 'Download')
              myproduct.versione = shared_consts.VERSIONE.DOWNLOAD;
            else if (product.Versione === 'DVD')
              myproduct.versione = shared_consts.VERSIONE.DVD;
            else if (product.Versione === 'Epub')
              myproduct.versione = shared_consts.VERSIONE.EPUB;
            else if (product.Versione === 'Mobi')
              myproduct.versione = shared_consts.VERSIONE.MOBI;
            else if (product.Versione === 'PDF')
              myproduct.versione = shared_consts.VERSIONE.PDF;
            else if (product.Versione === 'Streaming')
              myproduct.versione = shared_consts.VERSIONE.STREAMING;
            else
              myproduct.versione = 100;

            delete product.Versione;

            let recProductExist = null;
            // ISBN e versione del prodotto sono le chiavi uniche
            let queryprod = { idProductInfo: product.idProductInfo, versione: myproduct.versione };

            if (recGas) {
              queryprod = { ...queryprod, idGasordine: recGas._id };
            }

            recProductExist = await Product.findOne({ queryprod }).lean();

            if (!recProductExist) {
              isnuovo = true;
            }

            if (!options.aggiornaStockQty && esisteindb && !isnuovo) {
              delete product.Quantità;
              // delete product.maxbookableGASQty;
            }

            myproduct.isbn = product.isbn;
            myproduct.maxbookableGASQty = product.maxbookableGASQty ? product.maxbookableGASQty : null;
            myproduct.active = product.active;
            myproduct.idGasordine = recGas ? recGas._id : null;
            myproduct.idProductInfo = product.idProductInfo;
            myproduct.price = product.price ? parseFloat(tools.convertPriceEurToValue(product.price)) : null;
            myproduct.sale_price = product.sale_price ? parseFloat(tools.convertPriceEurToValue(product.sale_price)) : null;
            myproduct.idapp = idapp;
            myproduct.status = product.status ? product.status : null;


            if (product.Quantità) {
              myproduct.stockQty = parseInt(product.Quantità);
            }

            let recold = await Product.findOne(queryprod).lean();

            // AGGIORNA PRODUCT
            let risrec = await Product.findOneAndUpdate(queryprod, { $set: myproduct }, { new: true, upsert: true });

            let recnew = await Product.findOne(queryprod).lean();

            if (risrec) {
              if (risrec._id) {

                if (recold) {
                  // Record existed, so it was updated
                  let arrfieldchange = tools.differentObjects(recold, recnew);
                  if (arrfieldchange.length > 0) {
                    updated++;
                    let modif = '';
                    for (const field of arrfieldchange) {
                      modif += field + ': ' + recold[field] + ' -> ' + recnew[field] + ' | ';
                    }

                    console.log('Changed: [' + indprod + '/' + dataObjects.length + ']', productInfo.name, '[' + myproduct.idProductInfo + '] : ' + modif);
                  }
                } else {
                  newprod++;
                  console.log('Nuovo Prodotto : [' + newprod + '/' + dataObjects.length + ']', productInfo.name);
                }
              } else {
                // Record didn't exist, so it was created
                imported++;
              }
            } else {
              // risrec is null or undefined, indicating an error
              console.error('Error: ', myproduct.productInfo.name);
              errors++;
            }

            await Product.singlerecconvert_AfterImport_AndSave(idapp, recnew, isnuovo);
          } else {
            console.error('Error ProductInfo: ', product.code);
            errors++;
          }
        }

        indprod++;
      }

      console.log('*** IMPORTATI: ', imported, 'AGGIORNATI = ' + updated + ' (su ' + dataObjects.length + ' RECORD)');

      return res.status(200).send({ updated, imported, errors });

    } else if (cmd === shared_consts.Cmd.PRODUCTS) {
      dataObjects = JSON.parse(`[${data.arrdata}]`);

      let updated = 0;
      let imported = 0;
      let errors = 0;

      for (const product of dataObjects) {
        let isnuovo = false
        let setta = false

        let productInfo = {
          idapp: product.idapp,
          code: product.code,
          name: product.name,
          link: product.link,
          idCatProds: [],
          idSubCatProds: [],
          img: 'upload/products/' + product.code + '.jpg',
          weight: product.weight,
          unit: tools.getIdUnitsByText(product.unit),
          productType: shared_consts.PRODUCTTYPE.PRODUCT,
        }

        let reccateg = null;
        if (product.cat_name) {
          arrcat = product.cat_name.trim().split(',');
          for (const mycat of arrcat) {
            let mycatstr = mycat.trim();

            // Cerca la Categoria
            reccateg = await CatProd.findOne({ idapp, name: mycatstr }).lean();
            if (!reccateg) {
              // Non esiste questo produttore, quindi lo creo !
              reccateg = new CatProd({ idapp, name: mycatstr });
              ris = await reccateg.save();
              reccateg = await CatProd.findOne({ idapp, name: mycatstr }).lean();
            }

            if (reccateg) {
              productInfo.idCatProds.push(reccateg._id);
            }
          }
        }

        if (product.subcat_name) {
          arrsubcat = product.subcat_name.trim().split(',');
          for (const mysubcat of arrsubcat) {
            let mysubcatstr = mysubcat.trim();

            // Cerca la Sotto Categoria
            let recsubcateg = await SubCatProd.findOne({ idapp, name: mysubcatstr }).lean();
            if (!recsubcateg) {
              // Non esiste questa Sotto Categoria, quindi la creo !
              const idCatProd = reccateg ? reccateg._id : ''
              recsubcateg = new SubCatProd({ idapp, name: mysubcatstr, idCatProd });
              ris = await recsubcateg.save();
              recsubcateg = await SubCatProd.findOne({ idapp, name: mysubcatstr, idCatProd }).lean();
            }

            if (recsubcateg) {
              productInfo.idSubCatProds.push(recsubcateg._id);
            }
          }
        }

        if (!product.hasOwnProperty('active')) {
          product.active = true;
        }

        if (product.code)
          delete product.code;
        if (product.name)
          delete product.name;
        if (product.link)
          delete product.link;

        let esisteindb = await ProductInfo.findOne({ code: productInfo.code }).lean();

        // Update ProductInfo
        let risrecInfo = await ProductInfo.findOneAndUpdate({ code: productInfo.code }, { $set: productInfo }, { new: true, upsert: true });
        if (risrecInfo) {
          product.idProductInfo = risrecInfo._id;

          recnewInfo = await ProductInfo.findOne({ code: productInfo.code }).lean();

          if (risrecInfo._id) {
            // Record existed, so it was updated
            let arrfieldchange = tools.differentObjects(productInfo, recnewInfo);
            if (arrfieldchange && arrfieldchange.length > 0) {
              // updated++;
              console.log('Changed: ', recnewInfo.name + ': ' + arrfieldchange);
            }
          }

          // Cerca il GAS
          let recGas = null;
          if (product.gas_name) {
            // Cerca il GAS
            recGas = await Gasordine.findOne({ idapp, name: product.gas_name }).lean();
          }

          if (!recGas && !!product.gas_name) {
            recGas = new Gasordine({ idapp, name: product.gas_name, active: true });
            // Non esiste questo GAS, quindi lo creo !
            ris = await recGas.save();
            recGas = await Gasordine.findOne({ idapp, name: product.gas_name }).lean();
          }

          let recProductExist = null;
          let queryprod = { idProductInfo: product.idProductInfo };

          if (recGas) {
            queryprod = { ...queryprod, idGasordine: recGas._id };
          }

          recProductExist = await Product.findOne({ queryprod }).lean();

          if (!recProductExist) {
            isnuovo = true;
          }

          if (!options.aggiornaStockQty && esisteindb && !isnuovo) {
            delete product.stockQty;
            delete product.maxbookableGASQty;
          }

          // AGGIORNA PRODUCT
          let risrec = await Product.findOneAndUpdate(queryprod, { $set: product }, { new: true, upsert: true });

          let recnew = await Product.findOne(queryprod).lean();

          if (risrec) {
            if (risrec._id) {
              // Record existed, so it was updated
              let arrfieldchange = tools.differentObjects(product, recnew);
              if (arrfieldchange.length > 0) {
                updated++;
                console.log('Changed:', product.idProductInfo + ': ' + arrfieldchange);
              }
            } else {
              // Record didn't exist, so it was created
              imported++;
            }
          } else {
            // risrec is null or undefined, indicating an error
            console.error('Error: ', product.productInfo.name);
            errors++;
          }

          await Product.singlerecconvert_AfterImport_AndSave(idapp, recnew, isnuovo);
        } else {
          console.error('Error ProductInfo: ', product.code);
          errors++;
        }

      }

      return res.status(200).send({ updated, imported, errors });

    } else if (cmd === shared_consts.Cmd.PRODUCTS_V2) {
      let mydata = `[${data.arrdata}]`;
      dataObjects = mydata.replace(/\n/g, '');
      let arrrec = [];
      try {
        arrrec = JSON.parse(dataObjects);
      } catch (e) {
        console.error("Errore durante l'analisi del JSON:", e);
        arrrec = [];
      }

      let updated = 0;
      let imported = 0;
      let errors = 0;

      let ind = 0

      const [, ...myarrshift] = arrrec;

      for (const rec of myarrshift) {

        let risprod = await extractArrayDataFromCSV(idapp, rec);
        let product = risprod.product;
        let productInfo = risprod.productInfo;



        let isnuovo = false
        let setta = false

        let reccateg = null;
        if (rec.cat_name) {
          arrcat = rec.cat_name.trim().split(',');
          for (const mycat of arrcat) {
            let mycatstr = mycat.trim();

            // Cerca la Categoria
            reccateg = await CatProd.findOne({ idapp, name: mycatstr }).lean();
            if (!reccateg) {
              // Non esiste questo produttore, quindi lo creo !
              reccateg = new CatProd({ idapp, name: mycatstr });
              ris = await reccateg.save();
              reccateg = await CatProd.findOne({ idapp, name: mycatstr }).lean();
            }

            if (reccateg) {
              productInfo.idCatProds.push(reccateg._id);
            }
          }
        }

        if (rec.subcat_name) {
          arrsubcat = rec.subcat_name.trim().split(',');
          for (const mysubcat of arrsubcat) {
            let mysubcatstr = mysubcat.trim();

            // Cerca la Sotto Categoria
            let recsubcateg = await SubCatProd.findOne({ idapp, name: mysubcatstr }).lean();
            if (!recsubcateg) {
              // Non esiste questa Sotto Categoria, quindi la creo !
              const idCatProd = reccateg ? reccateg._id : ''
              recsubcateg = new SubCatProd({ idapp, name: mysubcatstr, idCatProd });
              ris = await recsubcateg.save();
              recsubcateg = await SubCatProd.findOne({ idapp, name: mysubcatstr, idCatProd }).lean();
            }

            if (recsubcateg) {
              productInfo.idSubCatProds.push(recsubcateg._id);
            }
          }
        }


        if (!rec.hasOwnProperty('active')) {
          product.active = true;
        }

        let esisteindb = await ProductInfo.findOne({ code: productInfo.code }).lean();

        // Update ProductInfo
        let risrecInfo = await ProductInfo.findOneAndUpdate({ code: productInfo.code }, { $set: productInfo }, { new: true, upsert: true });
        if (risrecInfo) {
          product.idProductInfo = risrecInfo._id;

          recnewInfo = await ProductInfo.findOne({ code: productInfo.code }).lean();

          if (risrecInfo._id) {
            // Record existed, so it was updated
            let arrfieldchange = tools.differentObjects(productInfo, recnewInfo);
            if (arrfieldchange && arrfieldchange.length > 0) {
              // updated++;
              console.log('Changed: ', recnewInfo.name + ': ' + arrfieldchange);
            }
          }

          // Cerca il GAS
          let recGas = null;
          if (rec.gas_name) {
            // Cerca il GAS
            recGas = await Gasordine.findOne({ idapp, name: rec.gas_name }).lean();
          }

          if (!recGas && !!rec.gas_name) {
            recGas = new Gasordine({ idapp, name: rec.gas_name, active: true });
            // Non esiste questo GAS, quindi lo creo !
            ris = await recGas.save();
            recGas = await Gasordine.findOne({ idapp, name: rec.gas_name }).lean();
          }

          if (recGas) {
            if (rec.hasOwnProperty('note_ordine_gas')) {
              const note_ordine_gas = rec['note_ordine_gas'];
              await Gasordine.findOneAndUpdate({ _id: recGas._id }, { $set: { note_ordine_gas } });
            }
          }

          let recProductExist = null;
          let queryprod = { idProductInfo: product.idProductInfo };

          if (recGas) {
            queryprod = { ...queryprod, idGasordine: recGas._id };
          }

          recProductExist = await Product.findOne({ queryprod }).lean();

          if (!recProductExist) {
            isnuovo = true;
          }

          if (!options.aggiornaStockQty && esisteindb && !isnuovo) {
            delete product.stockQty;
            delete product.maxbookableGASQty;
          }

          // AGGIORNA PRODUCT
          let risrec = await Product.findOneAndUpdate(queryprod, { $set: product }, { new: true, upsert: true });

          let recnew = await Product.findOne(queryprod).lean();

          if (risrec) {
            if (risrec._id) {
              // Record existed, so it was updated
              let arrfieldchange = tools.differentObjects(product, recnew);
              if (arrfieldchange.length > 0) {
                updated++;
                console.log('Changed: ', product.idProductInfo + ': ' + arrfieldchange);
              }
            } else {
              // Record didn't exist, so it was created
              imported++;
            }
          } else {
            // risrec is null or undefined, indicating an error
            console.error('Error: ', product.productInfo.name);
            errors++;
          }

          await Product.singlerecconvert_AfterImport_AndSave(idapp, recnew, isnuovo);
        } else {
          console.error('Error ProductInfo: ', product.code);
          errors++;
        }

        ind++;
      }

      // L'opzione ordered: false gestisce gli errori senza interrompere l'inserimento
      /*return await Product.insertMany(dataObjects, { ordered: false })
        .then((ris) => {
     
          Product.convertAfterImportALLPROD(idapp, dataObjects).then((ris) => {
            return res.status(200).send(true);
          });
     
     
        })
        .catch((errors) => {
          console.error(errors);
          Product.convertAfterImportALLPROD(idapp).then((ris) => {
            return res.status(200).send(true);
          });
        });*/

      return res.status(200).send({ updated, imported, errors });

    }
  } catch (e) {
    console.error('e', e);
    return res.status(400).send();
  }

  return res.status(400).send();

});

module.exports = router;