const mongoose = require('mongoose').set('debug', false)
const Schema = mongoose.Schema;

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

const Order = require('../models/order');
var { User } = require('../models/user');

const Storehouse = require('../models/storehouse');
const Provider = require('../models/provider');
const Gasordine = require('../models/gasordine');
const Product = require('../models/product');
const ProductInfo = require('../models/productInfo');

const { Circuit } = require('../models/circuit');

const CartClass = require('../modules/Cart')
const Cart = require('../models/cart');

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


const { ObjectID } = require('mongodb');

const OrdersCartSchema = new Schema({
  idapp: {
    type: String
  },
  numorder: { type: Number },
  numord_pers: { type: Number },
  userId: { type: Schema.Types.ObjectId, ref: 'User' },
  totalQty: { type: Number, default: 0 },
  totalQtyPreordered: { type: Number, default: 0 },
  totalPrice: { type: Number, default: 0 },
  totalPriceCalc: { type: Number, default: 0 },
  department: {
    type: String, ref: 'Department'
  },
  items: [
    {
      order:
        { type: Schema.Types.ObjectId, ref: 'Order' }
    }
  ],
  status: {
    type: Number,
    Default: 0,
  },
  confermato: {  // e quindi è stato tolto dal magazzino (aggiornando il campo stockBloccatiQty)
    type: Boolean,
    default: false,
  },
  date_confermato: {
    type: Date
  },
  pagato: {
    type: Boolean,
    default: false,
  },
  date_pagato: {
    type: Date
  },
  spedito: {
    type: Boolean,
    default: false,
  },
  date_spedito: {
    type: Date
  },
  consegnato: { // e quindi è stato tolto dal magazzino (aggiornando il campo stockQty e stockBloccatiQty)
    type: Boolean,
    default: false,
  },
  date_consegnato: {
    type: Date
  },
  preparato: {
    type: Boolean,
    default: false,
  },
  date_preparato: {
    type: Date
  },
  ricevuto: {
    type: Boolean,
    default: false,
  },
  date_ricevuto: {
    type: Date
  },
  note: {
    type: String
  },
  note_per_gestore: {
    type: String
  },
  note_ordine_gas: {
    type: String
  },
  note_per_admin: {
    type: String
  },
  modify_at: {
    type: Date
  },
  created_at: {
    type: Date
  },
  deleted: {
    type: Boolean,
    default: false,
  },
});

var OrdersCart = module.exports = mongoose.model('OrdersCart', OrdersCartSchema);

function fixupdated(myrec) {
  return myrec;
  /*if (myrec) {
    if (myrec.totalPriceCalc === undefined) {
      myrec.totalPriceCalc = myrec.totalPrice;
    }
  }
  return myrec;*/
}

module.exports.findAllIdApp = async function (idapp, userId) {
  const myfind = { idapp, userId, deleted: false };

  return await await OrdersCart.find(myfind);
};

module.exports.executeQueryTable = function (idapp, params) {
  params.fieldsearch = this.getFieldsForSearch();
  return tools.executeQueryTable(this, idapp, params);
};

module.exports.getFieldsForSearch = function () {
  return [{ field: 'note', type: tools.FieldType.string }]
};


module.exports.getLastNumOrder = async function (idapp) {
  let query = { idapp, deleted: false }
  let numorder = 100;
  let numorderrec = await OrdersCart.find(query).sort({ numorder: -1 }).limit(1);

  if (numorderrec && numorderrec.length > 0)
    numorder = numorderrec[0].numorder;
  else
    numorder = 100;

  return numorder;

};

module.exports.getLastNumOrdPers = async function (uid, idapp) {
  let query = { userId: uid, idapp, deleted: false }
  let numorder = 1;
  let numorderrec = await OrdersCart.find(query).sort({ numord_pers: -1 }).limit(1);

  if (numorderrec && numorderrec.length > 0)
    numorder = numorderrec[0].numord_pers;
  else
    numorder = 0;

  return numorder;

};

module.exports.getStatusCartByUserId = async function (uid, idapp, numorder) {
  let query = { userId: uid, idapp, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT } }
  let myorderscart = null;
  if (numorder > 0) {
    query = { userId: uid, idapp, numorder, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT } }
  }

  myorderscart = await OrdersCart.findOne(query);

  if (!!myorderscart)
    return myorderscart.status;
  else
    return shared_consts.OrderStatus.NONE

}

module.exports.getRecCartByUserId = async function (uid, idapp, numorder) {
  let query = { userId: uid, idapp, status: { $lt: shared_consts.OrderStatus.CHECKOUT_SENT } }
  let myorderscart = null;
  if (numorder > 0) {
    query = { userId: uid, idapp, numorder, status: { $lt: shared_consts.OrderStatus.CHECKOUT_SENT } }
  }

  myorderscart = await OrdersCart.findOne(query).lean();

  return myorderscart
}

module.exports.getOrdersCartById = async function (id) {

  let query = { _id: ObjectID(id) };

  const arrris = await OrdersCart.getOrdersCartByQuery(query);
  let myrec = arrris && arrris.length > 0 ? arrris[0] : null;
  myrec = fixupdated(myrec);
  return myrec;

}


module.exports.getOrdersCartByQuery = async function (query) {
  try {

    let myorderscart = await OrdersCart.find(query)
      .populate('items.order')
      .populate({
        path: 'items.order',
        populate: {
          path: 'idProduct',
          model: 'Product',
          populate: {
            path: 'idProductInfo',
            model: 'ProductInfo'
          }
        }
      })
      .populate({
        path: 'items.order',
        populate: {
          path: 'idProducer',
          model: 'Producer'
        }
      })
      .populate({
        path: 'items.order',
        populate: {
          path: 'idProvider',
          model: 'Provider'
        }
      })
      .populate({
        path: 'items.order',
        populate: {
          path: 'idGasordine',
          model: 'Gasordine'
        }
      })
      .populate({
        path: 'items.order',
        populate: {
          path: 'idStorehouse',
          model: 'Storehouse'
        }
      })
      .populate({
        path: 'items.order',
        populate: {
          path: 'idScontisticas',
          model: 'Scontistica'
        }
      })
      .populate({
        path: 'userId',
        model: 'User',
        select: '_id name surname username profile email lang'
      })
      .lean();

    myorderscart = myorderscart.map(order => {
      order.user = order.userId;
      order.userId = order.user._id;
      order.items = order.items.map(item => {
        if (item.order) {
          try {
            if (item.order.idProduct) {
              item.order.idProduct.productInfo = item.order.idProduct.productInfo ? item.order.idProduct.productInfo : { ...item.order.idProduct.idProductInfo };
              item.order.idProduct.productInfo.unitstr = tools.getUnitsMeasure(item.order.idProduct.productInfo.unit, true);
              item.order.idProduct.idProductInfo = item.order.idProduct.productInfo ? item.order.idProduct.productInfo._id : '';
            }
            const myid = item.order._id;
            // console.log('ID ORD', order.numorder, myid, order.user.name);
            item.order.product = { ...item.order.idProduct };
            item.order.idProduct = item.order.product ? item.order.product._id : '';
            item.order.producer = item.order.idProducer;
            item.order.idProducer = item.order.producer ? item.order.producer._id : '';
            item.order.storehouse = item.order.idStorehouse;
            item.order.idStorehouse = item.order.storehouse ? item.order.storehouse._id : '';
            item.order.provider = item.order.idProvider;
            item.order.idProvider = item.order.provider ? item.order.provider._id : '';
            item.order.gasordine = item.order.idGasordine;
            item.order.idGasordine = item.order.gasordine ? item.order.gasordine._id : '';
            item.order.scontisticas = item.order.scontisticas;
            item.order.idScontisticas = item.order.idScontisticas ? item.order.idScontisticas._id : '';
          } catch (e) {
            console.error('Err: ', e);
          }
        }
        return item;
      });
      return order;
    });

    myorderscart = fixupdated(myorderscart);

    /*
    let myquery = [
      { $match: query }, // Match documents based on your query
      {
        $unwind: "$items"
      },
      {
        $lookup: {
          from: "orders", // Assuming the referenced collection is named "orders"
          localField: "items.order",
          foreignField: "_id",
          as: "items.order"
        }
      },
      {
        $unwind: {
          path: "$items.order",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },
      {
        $lookup: {
          from: "products",
          localField: "items.order.idProduct",
          foreignField: "_id",
          as: "items.order.product"
        }
      },
      {
        $unwind: {
          path: "$items.order.product",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },
      // Populate 'items.order.idProduct.idProductInfo' with 'ProductInfo'
      {
        $lookup: {
          from: "productinfos",
          localField: "items.order.product.idProductInfo",
          foreignField: "_id",
          as: "items.order.product.productInfo"
        }
      },
      { $unwind: "$items.order.product.productInfo" }, // Deconstruct the array

      // Populate 'items.order.idProducer' with 'Producer'
      {
        $lookup: {
          from: "producers",
          localField: "items.order.product.IdProducer",
          foreignField: "_id",
          as: "items.order.producer"
        }
      },
      {
        $unwind: {
          path: "$items.order.producer",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },

      // Populate 'items.order.idProvider' with 'Provider'
      {
        $lookup: {
          from: "providers",
          localField: "items.order.idProvider",
          foreignField: "_id",
          as: "items.order.provider"
        }
      },
      {
        $unwind: {
          path: "$items.order.provider",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },

      // Populate 'items.order.idGasordine' with 'Gasordine'
      {
        $lookup: {
          from: "gasordines",
          localField: "items.order.idGasordine",
          foreignField: "_id",
          as: "items.order.gasordine"
        }
      },
      {
        $unwind: {
          path: "$items.order.gasordine",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },

      // Populate 'items.order.idStorehouse' with 'Storehouse'
      {
        $lookup: {
          from: "storehouses",
          localField: "items.order.idStorehouse",
          foreignField: "_id",
          as: "items.order.storehouse"
        }
      },
      {
        $unwind: {
          path: "$items.order.storehouse",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },

      // Populate 'items.order.idScontisticas' with 'Scontistica'
      {
        $lookup: {
          from: "scontisticas",
          localField: "items.order.product.idScontisticas",
          foreignField: "_id",
          as: "items.order.scontisticas"
        }
      },
      {
        $unwind: {
          path: "$items.order.scontisticas",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },

      // Populate 'userId' with 'User'
      {
        $lookup: {
          from: "users",
          localField: "userId",
          foreignField: "_id",
          as: "user"
        }
      },

      {
        $unwind: {
          path: "$user",
          preserveNullAndEmptyArrays: true // Preserve items with no matching orders
        }
      },
      {
        $group: {
          _id: "$_id",
        }
      },
      {
        $project: {
          _id: 1,
          'user.name': 1,
          'user.surname': 1,
          'user.username': 1,
          'user.profile': 1,
          'user.email': 1,
          'user.lang': 1,
          'totalQty': 1,
          'totalQtyPreordered': 1,
          'totalPrice': 1,
          "totalPriceCalc": 1,
          "confermato": 1,
          "pagato": 1,
          "spedito": 1,
          "consegnato": 1,
          "preparato": 1,
          "ricevuto": 1,
          "deleted": 1,
          "idapp": 1,
          "items": 1,
          "userId": 1,
          "status": 1,
          "note": 1,
          "numorder": 1,
          "numord_pers": 1,
          "created_at": 1,
          "modify_at": 1,
        }
      }
    ];

    // Project to select specific fields from 'User'
    /*{
      $project: {
        "_id": 1,
        "name": "$userId.name",
        "surname": "$userId.surname",
        "username": "$userId.username",
        "profile": "$userId.profile",
        "email": "$userId.email",
        "lang": "$userId.lang",
        "items": 1 // Include other fields as needed
      }
    }
    let myorderscart = await OrdersCart.aggregate(myquery);
    
    */



    // Optionally use toArray() to convert cursor to array
    return myorderscart;
  } catch (e) {
    console.error('err', e);
    return [];
  }
}

module.exports.getOrdersCartByUserId = async function (uid, idapp, numorder, filterStatus) {

  try {
    let query = { idapp, deleted: false }
    let myorderscart = null;
    if (numorder > 0) {
      query.numorder = numorder;
    }

    if (uid !== 'ALL' && !!uid) {
      query.userId = uid;
    }

    if (filterStatus) {
      query.status = { $gte: shared_consts.OrderStatus.CHECKOUT_SENT };
    }

    myorderscart = await OrdersCart.getOrdersCartByQuery(query);

    /*transform: function(doc, populated) {
    // Rinomina 'idProduct' a 'product' nei risultati della popolazione
    populated.product = populated.idProduct;
    delete populated.idProduct;
    return populated;
  },*/


    return myorderscart
  } catch (e) {
    console.error('Err:', e);
  }
  // return null;
}


module.exports.updateOrdersCartById = function (id, newOrdersCart, callback) {
  let query = {
    id,
    deleted: false,
  }
  OrdersCart.find(query, function (err, c) {
    if (err) throw err

    //exist cart in databse
    if (c.length > 0) {
      return OrdersCart.findOneAndUpdate(
        { _id: id },
        {
          $set: {
            items: newOrdersCart.items,
            totalQty: newOrdersCart.totalQty,
            totalQtyPreordered: newOrdersCart.totalQtyPreordered,
            totalPrice: newOrdersCart.totalPrice,
            totalPriceCalc: newOrdersCart.totalPriceCalc ? newOrdersCart.totalPriceCalc : newOrdersCart.totalPrice,
            userId: userId,
            status: newOrdersCart.status,
            numorder: newOrdersCart.numorder,
            numord_pers: newOrdersCart.numord_pers,
            note: newOrdersCart.note,
            modify_at: new Date(),
          }
        },
        { new: true },
        callback
      )
    } else {
      //no cart in database
      return newOrdersCart.save(callback)
    }
  })
}

module.exports.setFieldInOrdersById = async function (objtoset, myOrderCart) {

  try {
    let ris2 = null;
    // Imposta su tutti i singoli prodotti ordinati (Order)
    for (const recitem of myOrderCart.items) {
      ris2 = await Order.findOneAndUpdate(
        { _id: recitem.order._id },
        {
          $set: objtoset
        },
        { new: false }
      )
      // console.log('ris', ris2);
    }

    const ris = await OrdersCart.findOneAndUpdate(
      { _id: myOrderCart._id },
      {
        $set: objtoset
      },
      { new: false }
    )

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

}

module.exports.deleteRecsInOrdersById = async function (myOrderCart) {

  try {
    let ris2 = null;
    // Imposta su tutti i singoli prodotti ordinati (Order)
    for (const recitem of myOrderCart.items) {
      ris2 = await Order.findOneAndRemove({ _id: recitem.order._id })
    }

    const ris = await OrdersCart.findOneAndRemove({ _id: myOrderCart._id })

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

}

module.exports.setConsegnatoById = async function (value, myOrderCart) {

  let objtoset = {
    consegnato: value,
    date_consegnato: new Date(),
  };

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);

}

module.exports.setPreparatoById = async function (value, myOrderCart) {

  let objtoset = {
    preparato: value,
    date_preparato: new Date(),
  };

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);

}

module.exports.setSpeditoById = async function (value, myOrderCart) {

  let objtoset = {
    spedito: value,
    date_spedito: new Date(),
  };

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);

}

module.exports.setPagatoById = async function (value, myOrderCart) {

  let objtoset = {
    pagato: value,
    date_pagato: new Date(),
  };

  if (!value) {
    objtoset.date_pagato = null;
  }

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);

}

module.exports.setConsegnatoById = async function (value, myOrderCart) {

  let objtoset = {
    consegnato: value,
    date_consegnato: new Date(),
  };

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);

}

module.exports.setConfermatoById = async function (value, myOrderCart) {

  let objtoset = {
    confermato: value,
    date_confermato: new Date(),
  };

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);

}

module.exports.setRicevutoById = async function (value, myOrderCart) {

  let objtoset = {
    ricevuto: value,
    date_ricevuto: new Date(),
  };

  return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
}

module.exports.deleteReally = async function (value, myOrderCart) {

  return await OrdersCart.deleteRecsInOrdersById(myOrderCart);
}

module.exports.createOrdersCart = async function (newOrdersCart) {
  return await newOrdersCart.save()
}


module.exports.addOrderToMovement = async function (myOrderCart, usernameStore, groupnameStore, req) {

  try {
    if (myOrderCart) {
      const mymov = await Circuit.addMovementByOrdersCart(myOrderCart, usernameStore, groupnameStore);
      return mymov;
    }

    return null;

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

module.exports.checkQtaIfIsLow_SendAlert = async function (idapp, idProduct) {
  try {
    const telegrambot = require('../telegram/telegrambot');

    const isLow = await Product.isLowQuantityInStockById(idProduct);
    const instock = await Product.getInStockById(idProduct);
    const myprod = await Product.getProductById(idProduct);
    if (isLow && myprod) {
      let msg = `Il Prodotto '${myprod.productInfo.name}' è rimasto a ${instock} quantità !`;

      await telegrambot.sendMsgTelegramToTheManagers(idapp, msg);

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

module.exports.updateMagazzinoOrdineInLavorazione = async function (idorderscart) {

  try {

    const myorderscart = await OrdersCart.findOne({ _id: idorderscart }).populate('items.order').lean();

    if (myorderscart) {
      for (const idkey in myorderscart.items) {
        let order = myorderscart.items[idkey].order;

        if (!order.confermato) { // Se ancora non è stato confermato:
          let update = {
            $inc: {
              bookedQtyOrdered: order.quantity,
            }
          };
          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });

          update = {
            $inc: {
              bookedGASQtyOrdered: order.quantitypreordered,
            }
          };
          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });

          await OrdersCart.checkQtaIfIsLow_SendAlert(myorderscart.idapp, order.idProduct)
        }

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

}


module.exports.updateStockQtaDalMagazzinoOrdineConfermato = async function (idorderscart) {

  try {

    const myorderscart = await OrdersCart.findOne({ _id: idorderscart }).populate('items.order').lean();
    if (myorderscart) {
      for (const idkey in myorderscart.items) {
        let order = myorderscart.items[idkey].order;

        if (!order.confermato) { // Se ancora non è stato confermato:
          let update = {
            $inc: {
              stockQty: -order.quantity,
              stockBloccatiQty: order.quantity,
              bookedQtyConfirmed: order.quantity,
            }
          };
          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });

          update = {
            $inc: {
              maxbookableGASQty: -order.quantitypreordered,
              bookableGASBloccatiQty: order.quantitypreordered,
              bookedGASQtyConfirmed: order.quantitypreordered,
            }
          };
          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });
        }

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

}
module.exports.updateStockBloccatiQtaDalMagazzinoOrdineConsegnato = async function (idorderscart) {

  try {

    const myorderscart = await OrdersCart.findOne({ _id: idorderscart }).populate('items.order').lean();

    if (myorderscart) {
      for (const idkey in myorderscart.items) {
        let order = myorderscart.items[idkey].order;

        if (!order.consegnato) {
          let update = {
            $inc: {
              stockBloccatiQty: -order.quantity
            }
          };
          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });
          update = {
            $inc: {
              bookableGASBloccatiQty: -order.quantitypreordered
            }
          };
          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });
        }

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

}

module.exports.updateStockQtaPerCancellazioneOrdine = async function (idorderscart) {

  try {

    const myorderscart = await OrdersCart.findOne({ _id: idorderscart }).populate('items.order').lean();

    if (myorderscart) {
      for (const idkey in myorderscart.items) {
        let order = myorderscart.items[idkey].order;
        let update = {};

        let fieldstoUpdate = {};

        if (order.consegnato) {
          // Se l'ordine era stato già Consegnato, allora non fare niente !
          return false;
        } else {

          if (order.confermato) { // Se l'ordine era stato confermato, allora rimetti le Qta in Magazzino
            fieldstoUpdate = {
              ...fieldstoUpdate,
              stockQty: order.quantity,
              stockBloccatiQty: -order.quantity,
              bookedQtyConfirmed: -order.quantity,
            }
          }

          fieldstoUpdate = {
            ...fieldstoUpdate,
            bookedQtyOrdered: -order.quantity,
          }

          update = {
            $inc: fieldstoUpdate,
          };

          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });
          // --------------

          fieldstoUpdate = {};

          if (order.confermato) { // Se l'ordine era stato confermato, allora rimetti le Qta in Magazzino
            fieldstoUpdate = {
              ...fieldstoUpdate,
              maxbookableGASQty: order.quantitypreordered,
              bookableGASBloccatiQty: -order.quantitypreordered,
              bookedGASQtyConfirmed: -order.quantitypreordered,
            }
          }

          fieldstoUpdate = {
            ...fieldstoUpdate,
            bookedGASQtyOrdered: -order.quantitypreordered,
          }

          update = {
            $inc: fieldstoUpdate,
          };

          await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });
        }
      }

    }

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

}

module.exports.getStorehouseByOrdersCart = function (ordersCart) {

  return ordersCart && ordersCart.items && ordersCart.items.length > 0 && ordersCart.items[0].order.storehouse
    ? ordersCart.items[0].order.storehouse
    : null
}

module.exports.getUsernameStorehouseActual = async function (ordersCart) {

  const storehouse = OrdersCart.getStorehouseByOrdersCart(ordersCart);
  return storehouse
    ? storehouse.username
    : null
}

module.exports.getGroupnameStorehouseActual = async function (ordersCart) {

  const storehouse = OrdersCart.getStorehouseByOrdersCart(ordersCart);
  return storehouse
    ? storehouse.groupname
    : null
}

module.exports.updateCmd = async function (ordersCart, status, value, req, options) {


  let myOrderCart = await OrdersCart.getOrdersCartById(ordersCart._id);
  // let myOrderCart = await OrdersCart.findOne({ _id: ordersCart._id })
  //   .populate('items.order').lean();

  const usernameStore = await OrdersCart.getUsernameStorehouseActual(myOrderCart);
  const groupnameStore = await OrdersCart.getGroupnameStorehouseActual(myOrderCart);

  try {
    if (!!myOrderCart) {

      const id = myOrderCart._id;
      if (status === shared_consts.OrderStatus.CHECKOUT_SENT) {

        if (value) {
          await OrdersCart.updateMagazzinoOrdineInLavorazione(id);
        }

      } else if (status === shared_consts.OrderStatus.ORDER_CONFIRMED) {

        // Aggiorna anche il Magazzino, togliendo le quantità in Stock e aggiungendole su quelle bloccate
        if (value) {
          await OrdersCart.updateStockQtaDalMagazzinoOrdineConfermato(id);
        }
        ris = await OrdersCart.setConfermatoById(value, myOrderCart);

      } else if (status === shared_consts.OrderStatus.PAYED) {

        if (value) {
          if (!myOrderCart.pagato) { // Se ancora non è stato confermato:
            await OrdersCart.addOrderToMovement(myOrderCart, usernameStore, groupnameStore, req);

            ris = await OrdersCart.setPagatoById(value, myOrderCart);
          }
        }

      } else if (status === shared_consts.OrderStatus.PREPARED) {
        ris = await OrdersCart.setPreparatoById(value, myOrderCart);

      } else if (status === shared_consts.OrderStatus.DELIVERED) {  // Consegnato
        if (value) {
          await OrdersCart.updateStockBloccatiQtaDalMagazzinoOrdineConsegnato(id);
        }
        ris = await OrdersCart.setConsegnatoById(value, myOrderCart);
      } else if (status === shared_consts.OrderStatus.SHIPPED) {

        ris = await OrdersCart.setSpeditoById(value, myOrderCart);

      } else if (status === shared_consts.OrderStatus.RECEIVED) {
        ris = await OrdersCart.setRicevutoById(value, myOrderCart);
      } else if (status === shared_consts.OrderStatus.PREPARED) {
        ris = await OrdersCart.setPreparatoById(value, myOrderCart);
      } else if (status === shared_consts.OrderStatus.CANCELED) {
        await OrdersCart.updateStockQtaPerCancellazioneOrdine(id)

      } else if (status === shared_consts.OrderStatus.DELETE_REALLY) {
        await OrdersCart.updateStockQtaPerCancellazioneOrdine(id)
        ris = await OrdersCart.deleteReally(value, myOrderCart);
      }

      if (status !== shared_consts.OrderStatus.DELETE_REALLY) {

        await OrdersCart.setFieldInOrdersById({ status }, myOrderCart);

        myOrderCart = await OrdersCart.getOrdersCartById(ordersCart._id)
      }
      // myOrderCart = await OrdersCart.findOne({ _id: idorderscart });

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

}

OrdersCartSchema.pre('save', async function (next) {

  try {
    if (this.isNew) {
      try {
        const myrec = await User.findOne({ idapp: this.idapp }).limit(1).sort({ neworder: -1 });

        if (!!myrec) {
          this.neworder = myrec._doc.neworder + 1;
        } else {
          this.neworder = 1;
        }
      } catch (e) {
        this.neworder = 2;
      }
    }

    /*
    if (user.isModified('password')) {
      bcrypt.genSalt(10, (err, salt) => {
        bcrypt.hash(user.password, salt, (err, hash) => {
          user.password = hash;
          next();
        });
      });
    } else {
      next();
    }
    */

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

module.exports.updateOrdersCartByParams = async function (idOrdersCart, paramstoupdate) {

  const ris = await OrdersCart.findOneAndUpdate({ _id: idOrdersCart }, { $set: paramstoupdate });

  let myorderscart = await OrdersCart.getOrdersCartById(idOrdersCart);

  return myorderscart;
}


module.exports.updateOrdersCartTotals = async function (idOrdersCart, update) {

  try {
    let orderscart = await OrdersCart.getOrdersCartById(idOrdersCart);
    if (orderscart) {

      let newOrdersCart = CartClass.constructByCart(orderscart);

      newOrdersCart.updatecarttotals(false);
      await newOrdersCart.updateExtraOrder();

      if (update) {
        await OrdersCart.findOneAndUpdate({ _id: idOrdersCart }, {
          $set: {
            totalPrice: newOrdersCart.totalPrice,
            totalPriceCalc: newOrdersCart.totalPriceCalc,
            totalQty: newOrdersCart.totalQty,
            note: newOrdersCart.note,
            modify_at: new Date(),
          },
        }
        )
      }

      /*
      for (const order of orderscart.items) {
        await Order.findOneAndUpdate({ _id: order.order._id }, {
          $set: {
            price: order.order.price,
            quantity: order.order.quantity,
            quantitypreordered: order.order.quantitypreordered,
            TotalPriceProduct: order.order.TotalPriceProduct,
          }
        })
      }*/

      orderscart = await OrdersCart.getOrdersCartById(idOrdersCart);

      return orderscart;
    }
  } catch (e) {
    console.error('err', e);
  }
};

module.exports.getmsgorderTelegram = async function (ordersCart) {
  try {
    const statusstr = shared_consts.getStatusStr(ordersCart.status);

    let msg = '🟢✍️ Ordine n. ' + ordersCart.numorder

    msg += '<br>Stato: ' + statusstr;

    msg += '<br>🙎🏻‍♂️ ' + tools.getNomeCognomeEUserNameByUser(ordersCart.user)
    if (ordersCart.note)
      msg += '<br>Note: ' + ordersCart.note;


    msg += '<br><br>Lista Prodotti: (🍊🥑🍋)';
    for (const ord of ordersCart.items) {
      msg += '<br>';
      let qtystr = ''
      let qtynum = 0
      if (ord.order.quantity > 0)
        qtynum += ord.order.quantity;
      if (ord.order.quantitypreordered > 0)
        qtynum += ord.order.quantitypreordered;

      if (ord.order.product.productInfo.sfuso && ord.order.product.productInfo.weight)
        qtyrisult = qtynum * ord.order.product.productInfo.weight;
      else
        qtyrisult = qtynum + ' x ' + ord.order.product.productInfo.weight;

      qtystr += qtyrisult + ' ' + tools.getUnitsMeasure(ord.order.product.productInfo.unit, true);

      if (ord.order.quantitypreordered > 0)
        qtystr += ' Pre-Ordinati';

      msg += '✅ [' + qtystr + '] ' + ord.order.product.productInfo.name + ' a ' + ord.order.price + '€ ' + (ord.order.after_price ? ord.order.after_price : '') + '<br>Totale = ' + ord.order.TotalPriceProduct.toFixed(2) + '€';
    }

    msg += '<br>';

    let totqta = ordersCart.totalQty + ordersCart.totalQtyPreordered;

    msg += '<br>Totale Prodotti: ' + totqta;
    msg += '<br>Totale Ordine: ' + ordersCart.totalPrice.toFixed(2) + ' € 💰';



    return msg;

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

module.exports.createIndexes((err) => {
  if (err) throw err;
});