import type {
  IBaseOrder,
  ICart,
  IOrder,
  IOrderCart,
  IProduct,
  IProductsState,
  IProductInfo,
  ICatProd,
  IUserShort,
  IGasordine,
  IAuthor,
  ISubCatProd,
  IText,
  IOptCatalogo,
  ICatalog,
  ICatPrTotali,
  ISingleProductOrdered,
  ISchedaSingola,
  IMyScheda,
  IElementiScheda,
  T_Web_StatiProdotto,
  T_Web_Tipologie,
  T_WEB_TipiFormato,
  IPublisher,
  ICollaneTotali,
} from 'model';

import { Api } from '@api';
import { serv_constants } from '@src/store/Modules/serv_constants';
import * as Types from '@src/store/Api/ApiTypes';
import { static_data } from '@src/db/static_data';
import { shared_consts } from '@src/common/shared_vuejs';
import { tools } from '@store/Modules/tools';
import { defineStore } from 'pinia';
import { useUserStore } from '@store/UserStore';
import { toolsext } from '@store/Modules/toolsext';
import { useGlobalStore } from './globalStore';
import { ref } from 'vue';

import objectId from '@src/js/objectId';
import { costanti } from '@costanti';

import translate from '@src/globalroutines/util';
import { useCatalogStore } from './CatalogStore';

function getRecordOrdersCartEmpty(): IOrderCart {
  return {
    numorder: 0,
    numord_pers: 0,
    userId: '',
    user: null,
    totalQty: 0,
    totalPrice: 0,
    totalPriceCalc: 0,
    status: 0,
    confermato: false,
    consegnato: false,
    pagato: false,
    spedito: false,
    ricevuto: false,
    note: '',
    note_per_gestore: '',
    note_per_admin: '',
    note_ordine_gas: '',
  };
}

function getRecordProductInfoEmpty(): IProductInfo {
  return {
    code: '',
    name: '',
    description: '',
    department: '',
    catprods: [],
    subcatprods: [],
    color: '',
    size: '',
    weight: 0,
    unit: 0,
    stars: 0,
    date: tools.getDateNow(),
    icon: '',
    imagefile: '',
  };
}

function getRecordProductEmpty(): IProduct {
  const tomorrow = tools.getDateNow();
  tomorrow.setDate(tomorrow.getDate() + 1);

  return {
    productInfo: getRecordProductInfoEmpty(),
    // _id: tools.getDateNow().toISOString(),  // Create NEW
    active: false,
    idProducer: '',
    idStorehouses: [],
    idGasordine: '',
    idScontisticas: [],
    scontisticas: [],
    idProvider: '',
    producer: {},
    gasordine: null,
    storehouses: [],
    provider: {},
    price: 0.0,
    quantityAvailable: 0,
    bookableAvailableQty: 0,
    minBuyQty: 1,
    minStepQty: 1,
    // maxBookableSinglePersQty: 0,

    stockQty: 0,
    // stockBloccatiQty: 0,
    // bookedQtyOrdered: 0,
    // bookedQtyConfirmed: 0,

    // qtyToReachForGas: 0,

    // maxbookableGASQty: 0,
    // bookedGASQtyOrdered: 0,
    // bookedGASQtyConfirmed: 0,
    // bookableGASBloccatiQty: 0,

    // canBeShipped: false,
    // QuantitaOrdinateInAttesa: 0,
    // QuantitaPrenotateInAttesa: 0,
    // canBeBuyOnline: false,
  };
}

export const useProducts = defineStore('Products', {
  state: (): IProductsState => ({
    products: [],
    cart: { items: [], totalPrice: 0, totalQty: 0, userId: '' },
    orders: [],
    catprods: [],
    catprods_gas: [],
    authors: [],
    publishers: [],
    subcatprods: [],
    productInfos: [],
    userActive: { username: '', name: '', surname: '', _id: '' },
  }),

  getters: {
    getCatProds:
      (state: IProductsState) =>
      (cosa: number): ICatProd[] => {
        if (cosa === shared_consts.PROD.GAS) return state.catprods_gas;
        else if (cosa === shared_consts.PROD.BOTTEGA) return state.catprods;
        else return [...state.catprods, ...state.catprods_gas];
      },

    getCollane: (state: IProductsState) => (): ICollana[] => {
      return state.collane;
    },

    isDisponibile:
      (state: IProductsState) =>
      (product: IProduct): boolean => {
        return product?.arrvariazioni?.[0]?.quantita > 1;
      },

    isDisponibilitaOk:
      (state: IProductsState) =>
      (product: IProduct): boolean => {
        return product?.arrvariazioni?.[0]?.quantita > 100;
      },

    isQtaLimitata:
      (state: IProductsState) =>
      (product: IProduct): boolean => {
        return product?.arrvariazioni?.[0]?.quantita > 50 && product?.arrvariazioni?.[0]?.quantita < 100;
      },

    isInEsaurendo:
      (state: IProductsState) =>
      (product: IProduct): boolean => {
        return product?.arrvariazioni?.[0]?.quantita > 0 && product.arrvariazioni?.[0]?.quantita < 50;
      },
    isEsaurito:
      (state: IProductsState) =>
      (product: IProduct): boolean => {
        return (
          product?.arrvariazioni?.[0]?.quantita <= 0 &&
          !state.isProssimaUscitaById(product.productInfo.idStatoProdotto) &&
          !state.isPrevenditaById(product.productInfo.idStatoProdotto)
        );
      },

    isPubblicatoById:
      (state: IProductsState) =>
      (idStatoProdotto: number): boolean => {
        /*
      1	In commercio
      3	Ristampa
      4	Prossima uscita/pubblicazione
      6	In promozione
      7	In fase di valutazione
      8	Titolo in esaurimento (in attesa Nuova Edizione)
      9	Titolo in esaurimento
      20	Titolo in esaurimento (in att N.E Ricopertinata)
      26	Titolo in Esaurimento (disponibile N.E.)
      33	In commercio (digitale)
      34	In prevendita
      45	Vendita sito
      46	2023 in commercio
      47	Assoluto NO Reso
      48	Titolo esaurito

      */

        switch (idStatoProdotto) {
          case 1: // In Commercio
          case 3: // Ristampa
          case 4: // Prossima uscita/pubblicazione
          case 6: // In promozione
          case 7: // In fase di valutazione
          case 8: // 8	Titolo in esaurimento (in attesa Nuova Edizione)
          case 9: // In Commercio
          case 33: // In commercio (digitale)
          case 34: // In prevendita
          case 45: // Vendita sito
          case 46: // 2023 in commercio
          case 47: // Assoluto NO Reso
          case 48: // Titolo esaurito
          case undefined:
            return true;
          default:
            return false;
        }
      },

    isProssimaUscitaById:
      (state: IProductsState) =>
      (idStatoProdotto: number): boolean => {
        // 4 - Prossima uscita
        return idStatoProdotto === 4;
      },
    isPrevenditaById:
      (state: IProductsState) =>
      (idStatoProdotto: number): boolean => {
        // 4 - Prossima uscita
        // 34 - In Prevendita
        return idStatoProdotto === 34;
      },
    isNovitaById:
      (state: IProductsState) =>
      (date_pub: Date): boolean => {
        const sixMonthsAgo = new Date();
        sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
        return new Date(date_pub).getTime() > sixMonthsAgo.getTime();
      },

    isPubblicato:
      (state: IProductsState) =>
      (productInfo: IProductInfo): boolean => {
        return state.isPubblicatoById(productInfo.idStatoProdotto);
      },

    isNovita:
      (state: IProductsState) =>
      (productInfo: IProductInfo): boolean => {
        return state.isNovitaById(productInfo.date_pub);
      },

    isNonVendibile:
      (state: IProductsState) =>
      (productInfo: IProductInfo): boolean => {
        return (
          !state.isPubblicatoById(productInfo.idStatoProdotto) &&
          !state.isProssimaUscitaById(productInfo.idStatoProdotto)
        );
      },

    isProssimaUscita:
      (state: IProductsState) =>
      (productInfo: IProductInfo): boolean => {
        return state.isProssimaUscitaById(productInfo.idStatoProdotto);
      },

    isPrevendita:
      (state: IProductsState) =>
      (productInfo: IProductInfo): boolean => {
        return state.isPrevenditaById(productInfo.idStatoProdotto);
      },

    getDescrStatiProdottoByIdStatoProdotto:
      (state: IProductsState) =>
      (idStatoProdotto: number): string => {
        const ctrec = state.stati_prodotto.find(
          (mystatus: T_Web_StatiProdotto) => mystatus.IdStatoProdotto === idStatoProdotto
        );
        return ctrec ? ctrec.Descrizione : '';
      },

    getCasaEditriceByIdPublisher:
      (state: IProductsState) =>
      (idPublisher: string): string => {
        const rectrovato: IPublisher = state.publishers.find((editore: IPublisher) => editore._id === idPublisher);
        return rectrovato ? rectrovato.name : '';
      },

    getDescrByIdTipologia:
      (state: IProductsState) =>
      (idTipologia: number): string => {
        const ctrec = state.tipologie.find((mystatus: T_Web_Tipologie) => mystatus.IdTipologia === idTipologia);
        return ctrec ? ctrec.Descrizione : '';
      },

    getDescrByIdTipoFormato:
      (state: IProductsState) =>
      (idTipoFormato: number): string => {
        const ctrec = state.tipoformato.find((mystatus: T_WEB_TipiFormato) => mystatus.IdTipoFormato === idTipoFormato);
        return ctrec ? ctrec.Descrizione : '';
      },

    getArrayidArgomentoByArridCatProds:
      (state: IProductsState) =>
      (arridCatProds: string[]): string[] => {
        const myarr: string[] = [];
        for (const idCatProd of arridCatProds) {
          const catprod = state.catprods.find((rec: ICatProd) => rec._id === idCatProd);
          if (catprod && catprod.idArgomento && !myarr.includes(catprod.idArgomento.toString())) {
            myarr.push(catprod.idArgomento.toString());
          }
        }
        return myarr;
      },

    getCatProdsByGas:
      (state: IProductsState) =>
      (idGasOrdine: string): ICatProd[] => {
        let arrcat = state.catprods_gas;

        // Ottieni le categorie solo per i "products" che hanno come idGasOrdine il valore passato
        if (idGasOrdine) {
          arrcat = state.catprods_gas.filter((rec: ICatProd) => {
            const arrprod = state.products.filter((prod: IProduct) => {
              if (prod.idGasordine === idGasOrdine && prod.productInfo.idCatProds?.includes(rec._id)) {
                return true;
              }
            });
            return arrprod.length > 0 ? true : false;
          });
        } else {
          return [];
        }

        return arrcat;
      },

    getCatProdsStrByCatProds:
      (state: IProductsState) =>
      (catProds: ICatProd[]): string => {
        let mystr = '';
        for (const catprod of catProds) {
          let myarrcat = null;
          if (tools.isObject(catprod)) {
            myarrcat = catprod;
          } else {
            myarrcat = state.catprods.find((rec: ICatProd) => rec._id === catprod);
          }
          if (myarrcat) {
            if (mystr) mystr += ' - ';
            mystr += myarrcat.name;
          }
        }
        return mystr;
      },

    getSubCatProdsStrBySubCatProds:
      (state: IProductsState) =>
      (idSubCatProds: string[]): string => {
        let mystr = '';
        if (Array.isArray(idSubCatProds) && idSubCatProds.length > 0) {
          const names = idSubCatProds
            .map((id) => {
              const subCatProd = state.subcatprods.find((rec: ISubCatProd) => rec._id === id);
              return subCatProd ? subCatProd.name : '';
            })
            .filter((name) => name !== '');

          mystr = names.join(' - ');
        }
        return mystr;
      },

    getTotaleOrdineByOrdId:
      (state: IProductsState) =>
      (
        idOrdine: string,
        idGasordine: string,
        totale: boolean,
        mostra_solo_ordini_produttore: boolean,
        status: number
      ): number => {
        let arrprod = [];

        if (totale) {
          arrprod = state.orders.filter((rec: IOrderCart) => {
            if (
              (idGasordine && !rec.items?.some((item) => item.order && item.order.idGasordine === idGasordine)) ||
              rec.status !== status
            ) {
              return false; // Skip records not matching gasordine condition
            }
            return true;
          });
        } else {
          arrprod = state.orders.filter((rec: IOrderCart) => {
            if (
              (idGasordine && !rec.items?.some((item) => item.order && item.order.idGasordine === idGasordine)) ||
              rec._id !== idOrdine
            ) {
              return false; // Skip records not matching gasordine condition
            }
            return true;
          });
        }

        let subtotalPrice = 0;

        arrprod.forEach((rec: IOrderCart) => {
          rec.items?.forEach((item) => {
            if (
              item.order &&
              ((mostra_solo_ordini_produttore && item.order.idGasordine === idGasordine) ||
                !mostra_solo_ordini_produttore)
            ) {
              const qtyparz = item.order.quantity + item.order.quantitypreordered;
              subtotalPrice += item.order.price * qtyparz;
            }
          });
        });

        return subtotalPrice;
      },

    getCatProdDescrStrByIdCatProd:
      (state: IProductsState) =>
      (idCatProd: string): string => {
        const myfirstcat = state.catprods.find((rec: ICatProd) => rec._id === idCatProd);

        if (myfirstcat) {
          return myfirstcat.descr_estesa!;
        }
        return '';
      },
    getTotaliProdottiByIdCatProd:
      (state: IProductsState) =>
      (idCatProd: string): number => {
        const myfirstcat = state.catprtotali!.find((rec: ICatPrTotali) => rec._id === idCatProd);

        if (myfirstcat) {
          return myfirstcat.quanti!;
        }
        return 0;
      },

    getTotaliProdottiByIdCollana:
      (state: IProductsState) =>
      (idCollana: string): number => {
        const myfirstcat = state.collane.find((rec: ICollaneTotali) => rec._id === idCollana);

        if (myfirstcat) {
          return myfirstcat.quanti!;
        }
        return 0;
      },

    getSubCatProdsByGas:
      (state: IProductsState) =>
      (idGasOrdine: string, idCatProd: string): ISubCatProd[] => {
        let arrcat = state.subcatprods;

        // Ottieni le categorie solo per i "products" che hanno come idGasOrdine il valore passato
        if (idGasOrdine) {
          arrcat = state.subcatprods.filter((rec: ISubCatProd) => {
            const arrprod = state.products.filter((prod: IProduct) => {
              if (
                prod.idGasordine === idGasOrdine &&
                prod.productInfo.idSubCatProds?.includes(rec._id) &&
                prod.productInfo.idCatProds?.includes(idCatProd)
              ) {
                return true;
              }
            });
            return arrprod.length > 0 ? true : false;
          });
        } else {
          return [];
        }
        return arrcat;
      },

    getAuthors: (state: IProductsState) => (): any[] => {
      // Get the list of authors, for the q-select component using state.authors array
      // [{name: xxx, value: _id }]

      // add default value for q-select
      const options = [
        {
          label: '[Tutti]',
          value: '',
        },
        ...state.authors.map((rec: IAuthor) => {
          return { label: rec.name + (rec.surname ? ' ' + rec.surname : ''), value: rec._id };
        }),
      ];
      return options;
    },

    getNumProdTot: (state: IProductsState) => (): number => {
      return state.products.length;
    },

    getProducts:
      (state: IProductsState) =>
      (cosa?: number): IProduct[] => {
        if (!!cosa) {
          return state.products.filter((rec: IProduct) => {
            const hasGasOrdines = rec.idGasordine;

            if (
              (cosa === shared_consts.PROD.GAS && hasGasOrdines) ||
              (cosa === shared_consts.PROD.BOTTEGA && !hasGasOrdines)
            ) {
              return true;
            }

            return false;
          });
        } else {
          return state.products;
        }
      },

    updateDataProduct: (state: IProductsState) => (res: any) => {
      if (res && res.data.product) {
        // Update product from server
        const indelem = state.products.findIndex((prod: IProduct) => prod._id === res.data.product._id);
        if (indelem >= 0) {
          state.products[indelem] = { ...res.data.product };

          /*if (!res.data.orders) {
            // aggiorna anche tutti i product negli ordini !
            let ordcart: IOrderCart
            for (ordcart of state.orders) {
              for (const item of ordcart.items!) {
                if (item.order.idProduct === res.data.product.idProduct)
                  item.order.product = res.data.product
              }
            }
          }*/
        }
      }
      if (res && res.data.orders) {
        state.orders = res.data.orders;
      }

      if (res && res.data.cart) {
        // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
        state.cart = res.data.cart;
      }
    },
    getProductByCode:
      (state: IProductsState) =>
      (code: string): IProduct => {
        if (!code) {
          return getRecordProductEmpty();
        }

        const prod = state.products.find((prod: IProduct) => {
          if (prod.productInfo.code === code) return prod;
          else return null;
        });
        return prod ? prod : getRecordProductEmpty();
      },

    getCart: (state: IProductsState) => (): ICart => {
      return state.cart;
    },

    getOrdersAllCart:
      (state: IProductsState) =>
      (idGasordine: string): IOrderCart[] => {
        return state.orders.filter((rec: IOrderCart) => {
          if (idGasordine && !rec.items?.some((item) => item.order && item.order.idGasordine === idGasordine)) {
            return false; // Skip records not matching gasordine condition
          }
          return true;
        });
      },

    getNumOrders: (state: IProductsState) => (): number => {
      return state.orders.length;
    },

    getOrdersCart:
      (state: IProductsState) =>
      (tipoord: number, hasGasordine: any, idGasordine: string): IOrderCart[] | undefined => {
        return state.orders.filter((rec: IOrderCart) => {
          if (idGasordine && !rec.items?.some((item) => item.order && item.order.idGasordine === idGasordine)) {
            return false; // Skip records not matching gasordine condition
          }

          if (hasGasordine && !rec.items?.some((item) => item.order && item.order.idGasordine)) {
            return false; // Skip records not matching gasordine condition
          }

          switch (tipoord) {
            case shared_consts.OrderStat.IN_CORSO.value:
              return !rec.status || rec.status <= shared_consts.OrderStatus.CHECKOUT_SENT;
            case shared_consts.OrderStat.PREPARED.value:
              return rec.status === shared_consts.OrderStatus.PREPARED;
            case shared_consts.OrderStat.CONFERMATI.value:
              return rec.status === shared_consts.OrderStatus.ORDER_CONFIRMED;
            case shared_consts.OrderStat.PAGATI.value:
              return rec.status === shared_consts.OrderStatus.PAYED;
            case shared_consts.OrderStat.DELIVERED.value:
              return rec.status === shared_consts.OrderStatus.DELIVERED;
            case shared_consts.OrderStat.SHIPPED.value:
              return rec.status === shared_consts.OrderStatus.SHIPPED;
            case shared_consts.OrderStat.RECEIVED.value:
              return rec.status === shared_consts.OrderStatus.RECEIVED;
            case shared_consts.OrderStat.COMPLETATI.value:
              return rec.status === shared_consts.OrderStatus.COMPLETED;
            case shared_consts.OrderStat.CANCELLATI.value:
              return rec.status === shared_consts.OrderStatus.CANCELED;
            default:
              return false; // Invalid tipoord
          }
        });
      },

    existProductInCart:
      (state: IProductsState) =>
      (idproduct: string): boolean => {
        // console.log('.cart.items', this.cart.items)
        if (state.cart.items) {
          const ris = state.cart.items
            .filter((item: IBaseOrder) => item.order.idProduct === idproduct)
            .reduce((sum, rec) => sum + 1, 0);
          return ris > 0;
        }
        return false;
      },
    getOrderProductInCart:
      (state: IProductsState) =>
      (idproduct: string): IOrder | null => {
        // console.log('.cart.items', this.cart.items)
        if (state.cart.items) {
          const ris = state.cart.items.find((item: IBaseOrder) =>
            item.order ? item.order.idProduct === idproduct : false
          );
          return ris ? ris.order : null;
        }
        return null;
      },

    getOrderProductInOrdersCart:
      (state: IProductsState) =>
      (idordercart: string, idproduct: string): IOrder | null => {
        // console.log('.cart.items', this.cart.items)
        if (state.orders) {
          const orderscart = state.orders.find((rec: IOrderCart) => rec._id === idordercart);
          if (orderscart) {
            const ris = orderscart.items!.find((item: IBaseOrder) => item.order.idProduct === idproduct);
            return ris ? ris.order : null;
          }
        }
        return null;
      },

    getOrdersCartById:
      (state: IProductsState) =>
      (idordercart: string): IOrderCart => {
        if (state.orders) {
          const orderscart = state.orders.find((rec: IOrderCart) => rec._id === idordercart);
          return orderscart ?? getRecordOrdersCartEmpty();
        }
        return getRecordOrdersCartEmpty();
      },

    getSumQtyPreOrderInOrdersCart:
      (state: IProductsState) =>
      (idproduct: string): number => {
        let totalQuantity = 0;

        if (state.orders) {
          const orderscart = state.orders;
          if (orderscart) {
            for (const myord of orderscart) {
              if (myord.items) {
                for (const item of myord.items) {
                  if (item.order) {
                    if (
                      item.order.idProduct === idproduct &&
                      item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT
                    ) {
                      totalQuantity += item.order.quantitypreordered || 0;
                    }
                  }
                }
              }
            }
          }
        }
        return totalQuantity;
      },

    getSumQtyOrderProductInOrdersCart:
      (state: IProductsState) =>
      (idproduct: string): number => {
        let totalQuantity = 0;

        if (state.orders) {
          const orderscart = state.orders;
          if (orderscart) {
            for (const myord of orderscart) {
              if (myord.items) {
                for (const item of myord.items) {
                  if (item.order) {
                    if (
                      item.order.idProduct === idproduct &&
                      item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT
                    ) {
                      totalQuantity += item.order.quantity || 0;
                    }
                  }
                }
              }
            }
          }
        }
        return totalQuantity;
      },

    getOrdersCartByIdProduct:
      (state: IProductsState) =>
      (idproduct: string): IOrderCart[] | [] => {
        try {
          if (state.orders) {
            const ris = state.orders.filter((orderscart: IOrderCart) => {
              return orderscart.items!.some((item) => {
                if (item.order)
                  return (
                    item.order.idProduct === idproduct && item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT
                  );
              });
            });
            // console.log('Ordini ', ris)
            return ris ? ris : [];
          }
        } catch (e) {
          console.error('Err', e);
        }
        return [];
      },

    getOrdersCartInAttesaByIdProduct:
      (state: IProductsState) =>
      (idproduct: string): IOrderCart[] | [] => {
        try {
          if (state.orders) {
            const ris = state.orders.filter((orderscart: IOrderCart) => {
              return orderscart.items!.some((item) => {
                if (item.order)
                  return (
                    item.order.idProduct === idproduct && item.order.status! <= shared_consts.OrderStatus.CHECKOUT_SENT
                  );
              });
            });
            // console.log('Ordini ', ris)
            return ris ? ris : [];
          }
        } catch (e) {
          console.error('Err', e);
        }
        return [];
      },

    getRecordEmpty: (state: IProductsState) => (): IProduct => {
      return getRecordProductEmpty();
    },
  },

  actions: {
    createOrderByProduct(product: IProduct, order: IOrder): IOrder {
      const userStore = useUserStore();
      const myorder: IOrder = {
        userId: this.userActive._id,
        idapp: import.meta.env.VITE_APP_ID,
        status: shared_consts.OrderStatus.IN_CART,
        TotalPriceProduct: 0,
        TotalPriceProductCalc: 0,
        idProduct: product._id,
        product, // Copia tutto l'oggetto Product !

        // Ordine:
        price: product.price,
        after_price: product.after_price,
        quantity: order.quantity,
        quantitypreordered: order.quantitypreordered,
        idStorehouse: order.idStorehouse,
        idGasordine: order.idGasordine,
        //++Add Fields
      };

      return myorder;
    },

    initcat() {
      // rec.userId = this.userActive._id

      return this.getRecordEmpty();
    },

    /*resetProducts() {
      const arrprod = [...this.products]
      this.products = []
      this.products = [...arrprod]
    },*/

    async getProductById(id: string, forza?: boolean): Promise<IProduct> {
      let prod = null;
      try {
        if (!id) {
          return null;
        }
        if (this.products.length === 0 || forza) {
          // Se non lo carico all'avvio, allora fai la chiamata al server
          prod = await this.loadProductById(id);
        } else {
          prod = this.products.find((prod: IProduct) => prod._id === id);
        }
      } catch (e) {
        console.error('Err', e);
      }

      return prod ? prod : getRecordProductEmpty();
    },

    async loadMyScrapingBook(isbn: string, forzacaricamento: boolean) {
      return await Api.SendReq('/myscraping', 'POST', { isbn, forzacaricamento })
      .then((res) => {
        if (res.data) {
          return res.data.myscraping
        }
      })

      return null
    },

    async loadProducts(loadonlyifempty?: boolean) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      //console.log('loadProducts')

      // if (!globalStore.site.confpages.enableEcommerce)
      //   return null

      // console.log('getProducts', 'userid=', this.userActive._id)

      // if (this.userActive._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      if (loadonlyifempty) {
        if (this.products?.length > 0) return true;
      }

      let ris = null;

      let myIdActiveSelected = userStore.my._id;
      if (tools.isSeller()) myIdActiveSelected = tools.getCookie(tools.COOK_SELCART, userStore.my._id, false);

      const trovato = userStore.usersList.find((user: IUserShort) => user._id === myIdActiveSelected);
      if (trovato) this.userActive = trovato;
      else this.userActive = userStore.my;

      console.log('userActive', this.userActive);

      ris = await Api.SendReq('/products', 'POST', { userId: this.userActive._id })
        .then((res) => {
          if (res.data.products) {
            // console.log('aggiorna prodotti')
            this.products = [];
            this.products = res.data.products;
          } else {
            this.products = [];
          }

          if (res.data.orders) {
            this.orders = [];
            this.orders = res.data.orders;
          } else {
            this.orders = [];
          }

          return res;
        })
        .catch((error) => {
          console.log('error getProducts', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris;
    },

    async updateOrderByOrder(idOrdersCart: string, idOrder: string, paramstoupdate: any) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      // console.log('loadProducts')

      if (!globalStore.site.confpages.enableEcommerce) return null;

      console.log('updateOrderByOrder', 'userid=', this.userActive._id);

      let ris = null;

      ris = await Api.SendReq('/orders/updateord', 'POST', { idOrdersCart, idOrder, paramstoupdate })
        .then((res) => {
          let myorderscart = res.data.orderscart;
          if (res) {
            myorderscart = res.data && res.data.orderscart ? res.data.orderscart : null;
            if (myorderscart) {
              const idord = this.orders.findIndex((ord: IOrderCart) => ord._id === myorderscart._id);
              if (idord >= 0) {
                console.log('aggiorna ordine');
                this.orders[idord] = { ...myorderscart };
              }
            }
          }
          return myorderscart;
        })
        .catch((error) => {
          console.log('error updateOrderByOrder', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris;
    },

    async updateOrdersCartById(idOrdersCart: string, paramstoupdate: any) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      // console.log('loadProducts')

      if (!globalStore.site.confpages.enableEcommerce) return null;

      console.log('updateOrdersCartById', 'userid=', this.userActive._id);

      let ris = null;

      ris = await Api.SendReq('/orders/update', 'POST', { idOrdersCart, paramstoupdate })
        .then((res) => {
          let myorderscart = res.data.orderscart;
          if (res) {
            if (myorderscart) {
              const idord = this.orders.findIndex((ord: IOrderCart) => ord._id === myorderscart._id);
              if (idord >= 0) {
                console.log('aggiorna orderscart');
                this.orders[idord] = myorderscart;
              }
            }
          }
          return myorderscart;
        })
        .catch((error) => {
          console.log('error updateOrderByOrder', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris;
    },

    async loadProductById(id: string, forzacaricamento?: boolean) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      let ris = null;

      let myprod = null;

      if (this.products && !forzacaricamento) {
        // cerca su this.products
        myprod = this.products.find((prod: IProduct) => prod._id === id);
        if (myprod) {
          return myprod
        }
      }

      ris = await Api.SendReq('/products/id/' + id, 'GET', null)
        .then((res) => {
          console.log('product', res.data.product);
          if (res.data.product) {
            // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.updateDataProduct(res);
            return res.data.product;
          } else {
            return null;
          }
        })
        .catch((error) => {
          console.log('error getProduct', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      return ris;
    },

    async loadOrders() {
      // console.log('loadOrders')
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      if (!globalStore.site.confpages.enableEcommerce) return null;

      if (!this.userActive._id) return null;

      // if (this.userActive._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      let ris = null;

      ris = await Api.SendReq('/cart/' + this.userActive._id, 'GET', null)
        .then((res) => {
          if (res.data && res.data.cart) {
            // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.cart = res.data.cart;
          } else {
            this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' };
          }

          this.updateDataProduct(res);

          return res;
        })
        .catch((error) => {
          console.log('error loadOrders', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      // ApiTables.aftercalling(ris, checkPending, 'categories')
      return ris;
    },

    async removeFromCart({ order }: { order: IOrder }) {
      const userStore = useUserStore();

      return Api.SendReq('/cart/' + this.userActive._id, 'DELETE', { orderId: order._id }).then((res) => {
        this.updateDataProduct(res);

        return res;
      });
    },

    async getGestoreOrdini({ idGasordine }: { idGasordine: string }) {
      const userStore = useUserStore();

      let useractive = this.userActive._id;
      if (!useractive) useractive = userStore.my._id;

      return Api.SendReq('/cart/' + useractive + '/gestord', 'POST', { idGasordine }).then((res) => {
        if (res) return res.data.arrout;
        else return [];
      });
    },

    async addToCart({ product, order, addqty }: { product: IProduct; order: IOrder; addqty: boolean }) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      if (!globalStore.site.confpages.enableEcommerce) return null;

      let neworder = null;

      // Controlla se esiste già nel carrello, allora semplicemente aggiungerò la quantità:
      if (this.existProductInCart(product._id)) {
        const ordcart = this.getOrderProductInCart(product._id);
        if (ordcart) {
          if (!addqty && ordcart.quantity + ordcart.quantitypreordered === 1) {
            // sto per rimuovere l'ultimo pezzo, quindi cancello direttamente
            const risrem = await this.removeFromCart({ order: ordcart });

            if (risrem) {
              order.quantity = 0;
              order.quantitypreordered = 0;
              return true;
            } else {
              return false;
            }
          }

          return await this.addSubQtyToItem({
            addqty,
            subqty: !addqty,
            order: ordcart,
          }).then((res: any) => {
            if (res && res.msgerr) {
              return res;
            } else if (res && res.risult) {
              order.quantity = res.myord.quantity;
              order.quantitypreordered = res.myord.quantitypreordered;
            }
            return res;
          });
        }
      } else {
        if (this.isQtyAvailableByProduct(product)) {
          order.quantity = product.minBuyQty || 1;
          order.quantitypreordered = 0;
        } else {
          if (this.isInPreorderByProduct(product)) {
            order.quantitypreordered = product.minBuyQty || 1;
            order.quantity = 0;
          }
        }

        if (!order.idStorehouse) {
          if (product.storehouses.length === 1) {
            order.idStorehouse = product.storehouses[0]._id;
          } else {
            try {
              order.idStorehouse = globalStore.storehouses?.length ? globalStore.storehouses[0]._id : '';
            } catch (e) {}
          }
        }
        if (!order.idGasordine && order.quantitypreordered > 0) {
          if (product.gasordine && product.gasordine._id) {
            order.idGasordine = product.gasordine._id;
          } else {
            order.idGasordine = globalStore.gasordines?.length ? globalStore.gasordines[0]._id : '';
          }
        }

        if (order.idStorehouse) {
          neworder = this.createOrderByProduct(product, order);
        }
      }

      // if (neworder && !neworder.idStorehouse)
      //   return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, 'Nessuno Store')

      console.log('addToCart', 'userid=', this.userActive._id, neworder);

      let ris = null;

      ris = await Api.SendReq('/cart/' + this.userActive._id, 'POST', { order: neworder })
        .then((res) => {
          if (res.data.cart) {
            // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.cart = res.data.cart;
          } else {
            this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' };
          }
          this.updateDataProduct(res);

          return { risult: !!res, myord: res.data.myord, msgerr: res.data.msgerr };
        })
        .catch((error) => {
          console.log('error addToCart', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris;
    },

    async addSubQtyToItem({ addqty, subqty, order }: { addqty: boolean; subqty: boolean; order: IOrder }) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      if (!globalStore.site.confpages.enableEcommerce) return null;

      // console.log('addSubQtyToItem', 'userid=', this.userActive._id, order)

      let ris = null;

      ris = await Api.SendReq('/cart/' + this.userActive._id, 'POST', { addqty, subqty, order })
        .then((res: any) => {
          this.updateDataProduct(res);

          return { risult: !!res, myord: res.data.myord, msgerr: res.msgerr };
        })
        .catch((error) => {
          console.log('error addSubQtyToItem', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris;
    },

    getOptions(sendmail: boolean) {
      return {
        sendmail,
      };
    },

    async CreateOrdersCart({ cart_id, status, note }: { cart_id: string; status: number; note: string }) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      if (!globalStore.site.confpages.enableEcommerce) return null;

      if (!this.userActive._id) return null;

      let ris = null;

      ris = await Api.SendReq('/cart/' + this.userActive._id + '/createorderscart', 'POST', {
        cart_id,
        status,
        note,
        options: this.getOptions(true),
      })
        .then((res) => {
          if (res.data.status === shared_consts.OrderStatus.CHECKOUT_SENT) {
            // Cancella il Carrello, ho creato l'ordine !
            this.cart = {};
          }

          this.updateDataProduct(res);

          return res.data.recOrderCart;
        })
        .catch((error) => {
          console.log('error UpdateStatusCart', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      return ris;
    },

    /*async UpdateStatusCart({ ordercart_id, status }: { ordercart_id: string, status: number }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/updatestatuscart', 'POST', { ordercart_id, status, options: this.getOptions() })
        .then((res) => {

          if (res.data.status === shared_consts.OrderStatus.CHECKOUT_SENT) {
            this.cart = {}
          }
          this.updateDataProduct(res)

          return res.data.status
        })
        .catch((error) => {
          console.log('error UpdateStatusCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },*/

    async UpdateOrderCartStatus({
      order_id,
      status,
      sendmail,
    }: {
      order_id: string;
      status: number;
      sendmail: boolean;
    }) {
      const userStore = useUserStore();
      const globalStore = useGlobalStore();

      if (!globalStore.site.confpages.enableEcommerce) return null;

      let ris = null;

      ris = await Api.SendReq('/cart/' + this.userActive._id + '/ordercartstatus', 'POST', {
        order_id,
        status,
        options: this.getOptions(sendmail),
      })
        .then((res) => {
          this.updateDataProduct(res);

          return res.data.status;
        })
        .catch((error) => {
          console.log('error UpdateOrderCartStatus', error);
          userStore.setErrorCatch(error);
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error);
        });

      return ris;
    },
    async addtoCartBase({ $q, t, id, order, addqty }: { $q: any; t: any; id: string; order: IOrder; addqty: boolean }) {
      let product = await this.getProductById(id);

      return await this.addToCart({ product, order, addqty }).then((ris) => {
        if (ris && ris.msgerr) {
          tools.showNegativeNotif($q, ris.msgerr);
        } else {
          let strprod = t('ecomm.prodotto');

          let msg = '';
          console.log('ris', ris);
          if (ris && ris.myord == null) {
            msg = t('ecomm.prodotto_tolto');
            tools.showNotif($q, msg);
            return;
          }
          if (ris === null || ris.myord == null) {
            msg = t('ecomm.error_cart');
            tools.showNegativeNotif($q, msg);
            return;
          } else {
            let qta = ris.myord.quantity + ris.myord.quantitypreordered;
            if (qta > 1 || qta === 0) strprod = t('ecomm.prodotti');

            if (qta >= 0) {
              let totalPrice = this.cart.totalPrice ? this.cart.totalPrice.toFixed(2) : 0;
              let tot = totalPrice + ' €';
              msg = t('ecomm.prod_sul_carrello', { strprod, qty: qta, tot });
            }
          }
          if (ris === null || ris.myord.quantity === 0) tools.showNotif($q, msg);
          else tools.showPositiveNotif($q, msg, undefined, 'prodotto');
        }
        //updateproduct()

        return ris;
      });
    },

    getQuantityByOrder($t: any, order: IOrder): string {
      let mystr = '';
      if (order.quantity > 0) {
        mystr += order.quantity;
      }
      if (order.quantitypreordered > 0 && order.quantity > 0) {
        mystr += ' ' + $t('ecomm.available');
        mystr += ' + ';
      }
      if (order.quantitypreordered > 0) {
        mystr += ' ' + order.quantitypreordered + ' ';
      }
      return mystr;
    },

    isQtyAvailableByProduct(product: IProduct): boolean {
      if (product) {
        return product.quantityAvailable! > 0;
      }
      return false;
    },

    isInPreorderByProduct(product: IProduct): boolean {
      if (product) {
        return product.bookableAvailableQty! > 0;
      }
      return false;
    },

    isQtyAvailableByOrder(order: IOrder): boolean {
      if (order && order.product) {
        return this.isQtyAvailableByProduct(order.product);
      }
      return false;
    },

    isInPreorderByOrder(order: IOrder): boolean {
      if (order && order.product) {
        return this.isInPreorderByProduct(order.product);
      }
      return false;
    },

    getSingleGasordine(order: IOrder, short: boolean): string {
      try {
        const mygas = order.gasordine;
        if (mygas) {
          if (short) return mygas.name!;
          else
            return (
              mygas.name +
              ' (' +
              mygas.city +
              ') ' +
              translate('gas.dataora_chiusura_ordini') +
              ': ' +
              tools.getstrDateShort(mygas.dataora_chiusura_ordini) +
              ' ' +
              translate('gas.data_arrivo_merce') +
              ': ' +
              tools.getstrDateShort(mygas.data_arrivo_merce) +
              ' ' +
              translate('gas.dataora_ritiro') +
              ': ' +
              tools.getstrDateShort(mygas.dataora_ritiro)
            );
        } else return '';
      } catch (e) {
        return '';
      }
    },

    getQtyAvailable(myproduct: IProduct): number {
      let qty = myproduct.quantityAvailable!;
      return qty;
    },

    getQtyBookableAvailable(myproduct: IProduct): number {
      let qty = myproduct.bookableAvailableQty!;
      return qty;
    },

    getQtyBloccataAvailable(myproduct: IProduct): number {
      let qty = myproduct.stockBloccatiQty;
      return qty;
    },

    getQtyBloccataBookableAvailable(myproduct: IProduct): number {
      let qty = myproduct.bookableGASBloccatiQty;
      return qty;
    },

    enableSubQty(myorder: IOrder): boolean {
      let qty = myorder.quantity + myorder.quantitypreordered;
      return qty ? qty > 0 : false;
    },

    CanDeleteIfSub(myorder: IOrder): boolean {
      let qty = myorder.quantity + myorder.quantitypreordered;

      qty = qty - this.qtaNextSub(myorder, myorder.product!);
      return qty === 0;
    },

    enableAddQty(myorder: IOrder, myproduct: IProduct): boolean {
      const globalStore = useGlobalStore();
      if (globalStore.site.ecomm && globalStore.site.ecomm.enablePreOrders) {
        return (
          (this.getQtyBookableAvailable(myproduct) > 0 &&
            (myproduct.maxBookableSinglePersQty === 0 ||
              myorder.quantitypreordered + 1 < myproduct.maxBookableSinglePersQty)) ||
          (this.getQtyAvailable(myproduct) > 0 &&
            (myproduct.maxBookableSinglePersQty === 0 || myorder.quantity + 1 < myproduct.maxBookableSinglePersQty))
        );
      } else {
        return (
          this.getQtyAvailable(myproduct) > 0 &&
          (myproduct.maxBookableSinglePersQty === 0 || myorder.quantity + 1 < myproduct.maxBookableSinglePersQty)
        );
      }
    },

    qtaNextAdd(myorder: IOrder, myproduct: IProduct): number {
      let step = myproduct.minStepQty;
      if (this.getQtyAvailable(myproduct) > 0) {
        if (myorder.quantity === 0) step = myproduct.minBuyQty;
      } else {
        if (myorder.quantitypreordered === 0) step = myproduct.minBuyQty;
      }

      if (step === 0) {
        step = 1;
      }

      return step;
    },

    qtaNextSub(myorder: IOrder, myproduct: IProduct) {
      let step = myproduct.minStepQty;
      let minqta = myproduct.minBuyQty;
      if (this.getQtyAvailable(myproduct) > 0) {
        if (myorder.quantity === minqta) step = minqta;
      } else {
        if (myorder.quantitypreordered === minqta) step = minqta;
      }

      return step;
    },

    getNumQtaGas() {
      const arrprod = this.getProducts(shared_consts.PROD.GAS);
      return arrprod.length;
    },

    getNumQtaTutti() {
      const arrprod = this.getProducts(shared_consts.PROD.TUTTI);
      return arrprod.length;
    },

    getNumQtaBottega() {
      const arrprod = this.getProducts(shared_consts.PROD.BOTTEGA);
      return arrprod.length;
    },

    changeuserActive(valuerec: any) {
      if (valuerec) {
        console.log('valuerec', valuerec);
        tools.setCookie(tools.COOK_SELCART, valuerec._id);
        this.products = [];
        this.orders = [];
        this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' };

        this.loadOrders();
        this.loadProducts();
      }
    },

    async sendMailToTheBuyer(idOrdersCart: string, templemail_id: string, test: boolean) {
      return await Api.SendReq('/orders/sendmail', 'POST', {
        templemail_id,
        idOrdersCart,
        previewonly: tools.isDebug(),
        test,
      }).then((res) => {
        console.log('res', res);
        if (res) return res.data;
        else return null;
      });
    },

    getStrInfoOrder(t: any, order: IOrder) {
      let mystr = '';
      let qtyrisult: any;

      if (order.product) {
        let qtystr = '';
        let qtynum = 0;
        if (order.quantity > 0) qtynum += order.quantity;
        if (order.quantitypreordered > 0) qtynum += order.quantitypreordered;

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

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

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

        mystr +=
          '✅ [' +
          qtystr +
          '] ' +
          order.product.productInfo.name +
          ' a ' +
          order.price +
          '€ ' +
          (order.after_price ? order.after_price : '') +
          '<br>Totale = ' +
          order.TotalPriceProduct +
          '€';
      }
      return mystr;
    },

    getGasordineNameById(idGasordine: string) {
      const globalStore = useGlobalStore();
      const rec = globalStore.gasordines.find((gasordine: IGasordine) => gasordine._id === idGasordine);
      return rec ? rec.name : '';
    },

    getGasordines() {
      const globalStore = useGlobalStore();

      const myarr: any = [
        {
          id: 0,
          label: 'Tutti',
          value: '',
        },
      ];
      let ind = 1;
      if (globalStore.gasordines) {
        globalStore.gasordines.forEach((gasordine: IGasordine) => {
          if (gasordine) {
            myarr.push({
              id: ind,
              label:
                gasordine.name +
                (gasordine.dataora_chiusura_ordini
                  ? ' - chiusura: ' + tools.getstrDateShort(gasordine.dataora_chiusura_ordini)
                  : '') +
                (gasordine.dataora_ritiro ? ' - consegna ' + tools.getstrDateShort(gasordine.dataora_ritiro) : ''),
              value: gasordine._id,
            });
            ind++;
          }
        });
      }

      return myarr;
    },

    getGasordinesActives() {
      const globalStore = useGlobalStore();

      return globalStore.gasordines.filter((rec) => rec.active);
    },

    getAutoriByArrayAuthors(authors?: IAuthor[]) {
      // Gestione degli autori
      let authorString = '';
      if (authors && Array.isArray(authors)) {
        // Crea un array di nomi completi
        const fullNames = authors.map((author) => `${author.name} ${author.surname}`.trim());

        // Formattazione degli autori
        if (fullNames.length === 1) {
          authorString = fullNames[0];
        } else if (fullNames.length === 2) {
          authorString = `${fullNames[0]} e ${fullNames[1]}`;
        } else if (fullNames.length > 2) {
          const lastAuthor = fullNames.pop();
          authorString = `${fullNames.join(', ')} e ${lastAuthor}`;
        }
      }
      return authorString;
    },

    getkeyValStr(chiave: string, valore: any) {
      try {
        return ` ${chiave} = ${valore} `;
      } catch (e) {
        return ` ${chiave}`;
      }
    },

    replaceKeyWordsByProduct(optcatalogo: IOptCatalogo, myproduct: IProduct, testo: IText, idPage?: string) {
      if (!myproduct || !testo.contenuto) {
        return testo.contenuto;
      }

      const replacements: { [key: string]: any } = {};

      if (testo.contenuto.includes('{autore}')) {
        replacements['{autore}'] = this.getAutoriByArrayAuthors(myproduct.productInfo.authors) || '';
      }

      if (testo.contenuto.includes('{collana}')) {
        replacements['{collana}'] = tools.formatCollane(myproduct.productInfo.idCollana) || '';
      }

      const maxDescriptionLength = testo.maxlength || 680;

      if (testo.contenuto.includes('{descrizione_da_fdv}')) {
        const description = myproduct.productInfo.short_descr || '';
        replacements['{descrizione_da_fdv}'] =
          description.length > maxDescriptionLength
            ? description.substring(0, description.lastIndexOf(' ', maxDescriptionLength)) + '...'
            : description;
      }

      if (testo.contenuto.includes('{descrizione_estesa_fdv}')) {
        const long_descr = myproduct.productInfo.description || '';
        replacements['{descrizione_estesa_fdv}'] =
          long_descr.length > maxDescriptionLength
            ? long_descr.substring(0, long_descr.lastIndexOf(' ', maxDescriptionLength)) + '...'
            : long_descr;
      }

      if (testo.contenuto.includes('{descrizione_estesa}')) {
        let addtesto = false;
        const long_descr_macro = myproduct.productInfo.descrizione_completa_macro || '';
        if (long_descr_macro.length > maxDescriptionLength && maxDescriptionLength > 0) {
          addtesto = true;
        }
        const addstrcontinua =
          '<span class="book-link">👉🏻 <a href="{link_macro}" target="_blank">continua a leggere</a></span>';
        let descrizione_completa_macro = addtesto
          ? long_descr_macro.substring(0, long_descr_macro.lastIndexOf(' ', maxDescriptionLength)) + '...'
          : long_descr_macro;

        if (addtesto) {
          descrizione_completa_macro += addstrcontinua;
        }
        replacements['{descrizione_estesa}'] = descrizione_completa_macro || '';
      }

      if (testo.contenuto.includes('{descrizione_breve_macro}')) {
        const short_descr = myproduct.productInfo.descrizione_breve_macro || '';
        replacements['{descrizione_breve_macro}'] =
          short_descr.length > maxDescriptionLength && maxDescriptionLength > 0
            ? short_descr.substring(0, short_descr.lastIndexOf(' ', maxDescriptionLength)) + '...'
            : short_descr;
      }

      if (
        testo.contenuto.includes('{descr_trafiletto_catalogo}') ||
        testo.contenuto.includes('{descrizione_completa_macro}')
      ) {
        const short_descr = myproduct.productInfo.descr_trafiletto_catalogo || '';
        replacements['{descr_trafiletto_catalogo}'] =
          short_descr.length > maxDescriptionLength && maxDescriptionLength > 0
            ? short_descr.substring(0, short_descr.lastIndexOf(' ', maxDescriptionLength)) + '...'
            : short_descr;
        replacements['{descrizione_completa_macro}'] = replacements['{descr_trafiletto_catalogo}'];
      }

      if (testo.contenuto.includes('{prezzo}') || testo.contenuto.includes('{prezzo_scontato}')) {
        const prezzo = tools.arrotonda2Dec(myproduct.arrvariazioni?.[0]?.price) || '';
        const prezzo_scontato = tools.arrotonda2Dec(myproduct.arrvariazioni?.[0]?.sale_price) || '';
        replacements['{prezzo}'] = prezzo;
        replacements['{prezzo_scontato}'] = prezzo_scontato;
      }

      // Additional replacements based on the content
      const keysToCheck = [
        '{titolo}',
        '{sottotitolo}',
        '{categoria}',
        '{sottocategoria}',
        '{descr_categoria}',
        '{pagine}',
        '{isbn}',
        '{misure}',
        '{edizione}',
        '{ristampa}',
        '{argomento}',
        '{date_pub}',
        '{date_updated_fromGM}',
        '{ranking_globale}',
        '{venduti}',
        '{formato}',
        '{tipologia}',
        '{stato}',
        '{scale}',
        '{descr_trafiletto_catalogo}',
        '{link_macro}',
        '{qta}',
        '{image_link}',
        '{imagefile}',
        '{casaeditrice}',
        '{debug}',
      ];

      for (const key of keysToCheck) {
        if (testo.contenuto.includes(key)) {
          switch (key) {
            case '{titolo}':
              replacements[key] = myproduct.productInfo.name || '';
              break;
            case '{sottotitolo}':
              replacements[key] = myproduct.productInfo.sottotitolo || '';
              break;
            case '{sottocategoria}':
              replacements[key] =
                myproduct.productInfo.subcatprods && myproduct.productInfo.subcatprods.length > 0
                  ? myproduct.productInfo.subcatprods[0].name!
                  : '';
              break;
            case '{descr_categoria}':
              replacements[key] =
                myproduct.productInfo.catprods && myproduct.productInfo.catprods.length > 0
                  ? this.getCatProdDescrStrByIdCatProd(myproduct.productInfo.catprods![0].name)
                  : '';
              break;
            case '{pagine}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.pagine || '';
              break;
            case '{isbn}':
              replacements[key] = myproduct.productInfo.code || '';
              break;
            case '{misure}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.misure || '';
              break;
            case '{casaeditrice}':
              replacements[key] = this.getCasaEditriceByIdPublisher(myproduct.productInfo.idPublisher);
              break;
            case '{edizione}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.edizione || '';
              break;
            case '{ristampa}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.ristampa || '';
              break;
            case '{argomento}':
              replacements[key] = this.getCatProdsStrByCatProds(myproduct.productInfo.catprods!) || '';
              break;
            case '{date_pub}':
              replacements[key] = tools.getstrDateShort(myproduct.productInfo.date_pub) || '';
              break;
            case '{date_updated_fromGM}':
              replacements[key] = tools.getstrDateShort(myproduct.productInfo.date_updated_fromGM) || '';
              break;
            case '{ranking_globale}':
              replacements[key] = myproduct.productInfo.rank3M! || '0';
              break;
            case '{venduti}':
              replacements[key] = myproduct.productInfo.totVen! || '0';
              break;
            case '{formato}':
              replacements[key] = this.getDescrByIdTipoFormato(myproduct.arrvariazioni?.[0]?.idTipoFormato || 0);
              break;
            case '{tipologia}':
              replacements[key] = this.getDescrByIdTipologia(myproduct.arrvariazioni?.[0]?.idTipologia || 0);
              break;
            case '{stato}':
              replacements[key] = this.getDescrStatiProdottoByIdStatoProdotto(
                myproduct.productInfo?.idStatoProdotto || ''
              );
              break;
            case '{scale}':
              replacements[key] = optcatalogo.printable ? optcatalogo.areadistampa?.scale : '1';
              break;
            case '{link_macro}':
              replacements[key] = myproduct.productInfo.link_macro || '';
              break;
            case '{qta}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.quantita || '';
              break;
            case '{image_link}':
              replacements[key] = myproduct.productInfo.image_link || '';
              break;
            case '{imagefile}':
              replacements[key] = myproduct.productInfo.imagefile || '';
              break;
            case '{debug}':
              const date_pub = replacements['{date_pub}'] || '';
              const fatLast6M = myproduct.productInfo.fatLast6M! || 0;
              const linkvenduti = `<a href="http://vps-88271abb.vps.ovh.net/apimacro/public/view-ordini-by-idarticolo/${myproduct.productInfo.sku}" target="_blank">${myproduct.productInfo.totVen!}</a>`;
              const vLast3M = myproduct.productInfo.vLast3M! || 0;
              const vLast6M = myproduct.productInfo.vLast6M! || 0;
              const linkfatturati = `<a href="http://vps-88271abb.vps.ovh.net/apimacro/public/view-fatturati-by-idarticolo/${myproduct.productInfo.sku}" target="_blank">${myproduct.productInfo.totFat! || 0}</a>`;
              const fatLast3M = myproduct.productInfo.fatLast3M! || 0;

              replacements[key] =
                this.getkeyValStr('Pub:', date_pub) +
                this.getkeyValStr('fat6M', fatLast6M) +
                this.getkeyValStr('Ven:', linkvenduti) +
                this.getkeyValStr('v3M', vLast3M) +
                this.getkeyValStr('v6M', vLast6M) +
                this.getkeyValStr('Fatt:', linkfatturati) +
                this.getkeyValStr('fat3M', fatLast3M);
              break;
          }
        }
      }

      // Esegue le sostituzioni
      let result = testo.contenuto;
      for (const [key, value] of Object.entries(replacements)) {
        result = result.replace(new RegExp(key, 'g'), value);
      }

      return result.trim();
    },

    getSubCatStrByProduct(myproductInfo: IProductInfo): string {
      return this.getSubCatProdsStrBySubCatProds(myproductInfo.idSubCatProds || []);
    },

    getListProductBySumQuantity(idGasordine: string): ISingleProductOrdered[] {
      const arrprod = this.orders.filter((rec: IOrderCart) => {
        if (idGasordine && !rec.items?.some((item) => item.order && item.order.idGasordine === idGasordine)) {
          return false; // Skip records not matching gasordine condition
        }
        return true;
      });

      const productMap = new Map<string, ISingleProductOrdered>();

      arrprod.forEach((rec: IOrderCart) => {
        rec.items?.forEach((item) => {
          if (item.order && item.order.idGasordine === idGasordine) {
            const productId: string = item.order.idProduct!;
            const qtyparz = item.order.quantity + item.order.quantitypreordered;
            if (productMap.has(productId)) {
              const existingProduct: ISingleProductOrdered = productMap.get(productId)!;
              existingProduct.qty += qtyparz;
              existingProduct.subtotalPrice += item.order.price * qtyparz;
              existingProduct.subtotalPrice = Number(existingProduct.subtotalPrice.toFixed(2));
            } else {
              const sottocategoria =
                item.order.product?.productInfo?.subcatprods && item.order.product?.productInfo?.subcatprods.length > 0
                  ? item.order.product?.productInfo?.subcatprods[0].name
                  : '';
              productMap.set(productId, {
                subCat: sottocategoria,
                strSubCatProds: this.getSubCatProdsStrBySubCatProds(item.order.product?.productInfo?.idSubCatProds),
                index: productMap.size + 1,
                idProduct: productId,
                code: item.order.product?.productInfo.code,
                codice_interno: item.order.product?.productInfo?.codice ?? '',
                qty: qtyparz,
                singlePrice: item.order.price,
                subtotalPrice: Number((item.order.price * qtyparz).toFixed(2)),
                productName: item.order.product?.productInfo?.name ?? '',
              });
            }
          }
        });
      });

      return Array.from(productMap.values());
    },

    getOptCatalogoTemplate() {
      // Ottieni l'array delle pagine che in cataloghi sono dimensioni_def.isTemplate

      let arr: any = [];

      const globalStore = useGlobalStore();

      arr.push({ label: '[Nessuna]', value: '' });

      for (const myelem of globalStore.myelems) {
        if (myelem.catalogo && myelem.catalogo.dimensioni_def && myelem.catalogo.dimensioni_def.isTemplate) {
          const page = globalStore.getPageById(myelem.idPage);
          let pagename = page ? page.title! : '';

          if (pagename) {
            pagename = '[Pag: ' + pagename + '] ';
          }

          const mylabel = pagename;

          arr.push({ label: mylabel, value: myelem._id });
        }
      }

      return arr;
    },
    getOptCatalogoPrintTemplate() {
      // Ottieni l'array delle pagine che in cataloghi sono dimensioni_def.isTemplate

      let arr: any = [];

      const globalStore = useGlobalStore();

      arr.push({ label: '[Nessuna]', value: '' });

      for (const myelem of globalStore.myelems) {
        if (myelem.catalogo && myelem.catalogo.print_isTemplate) {
          const page = globalStore.getPageById(myelem.idPage);
          let pagename = page ? page.title! : '';

          if (pagename) {
            pagename = '[Pag: ' + pagename + '] ';
          }

          const mylabel = pagename;

          arr.push({ label: mylabel, value: myelem._id });
        }
      }

      return arr;
    },

    getSchedeOpt(arrschede: ISchedaSingola[], tag?: string): any[] {
      let arr: any = [];

      const globalStore = useGlobalStore();

      arr.push({ label: '[Nessuna]', value: '' });

      if (arrschede) {
        arrschede.forEach((recscheda: ISchedaSingola) => {
          let pagename = '';
          if (recscheda.scheda) {
            if (recscheda.idPageOrig) {
              const page = globalStore.getPageById(recscheda.idPageOrig);
              // const page = this.mypage?.find((page) => (`${page._id}`) === recscheda.idPageOrig)
              pagename = page ? page.title! : '';
            }
            if (pagename) pagename = '[Pag: ' + pagename + '] ';

            const mylabel = pagename + (recscheda.scheda ? recscheda.scheda!.name : '');
            if (!tag || mylabel.startsWith(tag)) {
              arr.push({ label: mylabel, value: recscheda.scheda!._id });
            }
          }
        });
      }

      return arr;
    },

    addNewScheda(catalogo: IOptCatalogo) {
      let maxorder = 0;
      catalogo!.arrSchede?.forEach((scheda) => {
        if (scheda?.order > maxorder) {
          maxorder = scheda.order;
        }
      });

      let testodef: IText = {};
      testodef = tools.resetIText(testodef);

      const defaultDimensioniPag = tools.resetRecIDimensioni(null);
      defaultDimensioniPag.size = {
        width: '800px',
        height: '600px',
      };
      defaultDimensioniPag.margini = {
        top: '12px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      };
      defaultDimensioniPag.padding = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      };

      const defaultDimensioniRiga = tools.resetRecIDimensioni(null);

      defaultDimensioniRiga.size = {
        width: '800px',
        height: '300px',
      };
      defaultDimensioniRiga.margini = {
        top: '40px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      };
      defaultDimensioniRiga.padding = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      };

      const defaultSchedaProdotto = tools.resetRecIDimensioni(null);

      defaultSchedaProdotto.size = {
        width: '360px',
        height: '230px',
      };

      defaultSchedaProdotto.margini = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      };

      defaultSchedaProdotto.padding = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      };

      const dimensioni: IElementiScheda = {
        pagina: { dimensioni: defaultDimensioniPag, testo_down: testodef, testo_up: testodef, testo_title: testodef },
        riga: defaultDimensioniRiga,
        scheda_prodotto: defaultSchedaProdotto,
        immagine_prodotto: {
          size: {
            width: '150px',
            height: '235px',
          },
          margini: {
            top: '0px',
            bottom: '0px',
            left: '0px',
            right: '0px',
          },
          padding: {
            top: '0px',
            bottom: '0px',
            left: '0px',
            right: '0px',
          },
        },
      };

      const newscheda: IMyScheda = {
        _id: objectId(),
        idapp: tools.appid()!,
        isTemplate: false,
        isPagIntro: false,
        show_separatore: true,
        name: 'Scheda Nuova',
        dimensioni,
        numschede_perRiga: 2,
        numschede_perCol: 2,
        testo_right_attaccato: {
          contenuto: '',
          maxlength: 0,
          font: {
            posiz_text: costanti.POSIZ_TESTO.A_DESTRA,
          },
        },
        testo_right: {
          contenuto: '',
          maxlength: 0,
          font: {
            posiz_text: costanti.POSIZ_TESTO.A_DESTRA,
          },
        },
        testo_bottom: {
          contenuto: '',
          maxlength: 0,
          font: {
            posiz_text: costanti.POSIZ_TESTO.IN_BASSO,
          },
        },
        barcode: {
          show: false,
          format: '',
          size: {
            width: '2',
            height: '100',
          },
          font: {
            name: 'monospace',
            size: '16px',
          },
        },
        productTypes: [],
        excludeproductTypes: [],
        idTipologie: [],
        editore: [],
        argomenti: [],
        author: '',
        sort_field: '',
        sort_dir: 0,
        arrProdottiSpeciali: [],
        etichette: {
          novita: {
            show: false,
            months: 6,
          },
          bestseller: {
            show: false,
            quantiFattRaggiunti: 50,
          },
        },
      };

      if (!catalogo!.arrSchede) catalogo!.arrSchede = [];

      catalogo!.arrSchede.push({
        _id: objectId(),
        scheda: newscheda,
        order: maxorder + 10,
        numPagineMax: 0,
      });
    },

    updateProductsByArray: (state: IProductsState) => (arrrec: IProduct[]) => {
      if (arrrec && arrrec.length > 0) {
        // update products array from this array
        const myarr = state.products.filter((rec) => !arrrec.find((newrec) => newrec._id === rec._id));
        state.products = myarr.concat(arrrec);
      }
    },

    getPathByPage(idpag: string) {
      let linkpage = '';

      const globalStore = useGlobalStore();

      if (idpag) {
        const mypage = globalStore.getPageById(idpag);
        if (mypage) linkpage = mypage.path!;
      }

      return linkpage;
    },
  },
});