myprojplanet_vite/src/views/ecommerce/catalogo/catalogo.ts

import type { PropType } from 'vue';
import { defineComponent, onMounted, ref, watch, computed, onBeforeUnmount, nextTick } from 'vue'
import { tools } from '@tools'
import { useUserStore } from '@store/UserStore'
import { useRouter } from 'vue-router'
import { useGlobalStore } from '@store/globalStore'
import { useProducts } from '@store/Products'
import { useI18n } from 'vue-i18n'
import { toolsext } from '@store/Modules/toolsext'
import { useQuasar } from 'quasar'
import { costanti } from '@costanti'

import { shared_consts } from '@src/common/shared_vuejs'
import { CProductCard } from '@src/components/CProductCard'

import { CMySelect } from '@src/components/CMySelect'
import { CProductTable } from '@src/components/CProductTable'
import { CContainerCatalogoCard } from '@src/components/CContainerCatalogoCard'
import { CSelectUserActive } from '@src/components/CSelectUserActive'
import type {
  IOptCatalogo, IDimensioni, IFilterCatalogo,
  IMyScheda, IProdView, IProduct, ISchedaSingola, ISearchList, ICatalog, IImg,
  IText
} from 'model';
import {
  IMyPage,

} from 'model'


import { fieldsTable } from '@store/Modules/fieldsTable'
import { useCatalogStore } from '@src/store/CatalogStore'
import { Catalogo } from '.';

export default defineComponent({
  name: 'Catalogo',
  components: { CContainerCatalogoCard, CProductCard, CSelectUserActive, CMySelect, CProductTable },
  emits: ['update:modelValue', 'updateCatalogo'],
  props: {
    modelValue: {
      type: Object as PropType<IOptCatalogo>,
      required: true,
    },
    idPage: {
      type: String,
      required: false,
      default: '',
    },
  },
  setup(props, { emit }) {
    const userStore = useUserStore()
    const globalStore = useGlobalStore()
    const productStore = useProducts()
    const router = useRouter()
    const $q = useQuasar()
    const { t } = useI18n()

    const search = ref('')
    const optauthors = ref(<any>[])

    const pdfContent = ref(null);

    const optcatalogo = ref(<IOptCatalogo>{ ...props.modelValue });

    function updateCatalogoPadre() {
      console.log('catalogo.ts PADRE')
      emit('update:modelValue', optcatalogo.value);
      //emit('updateCatalogo', optcatalogo.value);
    }

    // Metodo per aggiornare optcatalogo
    const updateOptCatalogo = <K extends keyof IOptCatalogo>(key: K, value: IOptCatalogo[K]) => {
      optcatalogo.value[key] = value;
      updateCatalogoPadre()
    }
    // Utile anche per sincronizzare con le modifiche ricevute da props
    watch(() => props.modelValue, (newVal) => {
      optcatalogo.value = { ...newVal };
    }, { deep: false });

    /*watch(optcatalogo, (newValue) => {
      emit('update:modelValue', newValue);
    }, { deep: true });*/

    const filter = ref(<IFilterCatalogo>{
      author: '',
      publisher: '',
      type: '',
      ageGroup: ''
    })

    const cosa = ref(0)
    const cat = ref('')
    const idGasSel = ref('')
    const loadpage = ref(false)
    const refreshpage = ref(false)
    const show_hide = ref(false)

    const mycolumns = ref([])

    const catalogStore = useCatalogStore()

    const tabvisu = ref('categorie')
    const tabcatalogo = ref()

    const searchList = ref([] as ISearchList[])

    const arrProducts = ref<IProduct[]>([])
    const arrProdToView = ref<IProdView[]>([])

    const numRecLoaded = ref(0)

    // Create a ref for the component to fix
    const componentToFixRef = ref(<any>null);

    const isFixed = ref(false);

    watch(() => tabcatalogo.value, () => {
      tools.setCookie('TAB_CAT', tabcatalogo.value)
    })

    const labelcombo = computed(() => (item: any) => {
      let lab = item.label
      if (item.showcount)
        lab += ' (' + valoriopt.value(item, false, false).length + ')'
      return lab
    })

    const arrLoaded = computed(() => {
      if (arrProducts.value && numRecLoaded.value)
        return arrProducts.value.slice(0, numRecLoaded.value)
      else {
        return []
      }
    })

    const getTestoIntroduttivo = computed(() => (recscheda: ISchedaSingola) => {

      let testo = recscheda.scheda!.dimensioni.pagina?.testo_up?.contenuto

      if (recscheda.scheda!.isPagIntro) {

        const catalogStore = useCatalogStore()
        const catalog = getCatalogoByMyPage.value
        if (catalog && catalog.descr_introduttiva) {
          // Cerca se la descrizione introduttiva è stata impostata
          testo = catalog.descr_introduttiva
          let clcol = ''
          if (catalog.pagina_introduttiva_sfondo_nero) {
            clcol = `text-white`
          }
          testo = `<span class="book-text-up ${clcol}">` + testo + `</span>`
        }
      }

      return testo

    })

    function getTextSostituito(testo: IText) {
      const replacements = {
        '{titolo_catalogo}': getTitoloCatalogo() || '',
      };

      // 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
    }

    const getTitoloPagina = computed(() => (product: IProduct, recscheda: ISchedaSingola) => {

      let testo = getTextSostituito(recscheda.scheda!.dimensioni.pagina?.testo_title)

      return testo

    })

    const getCatalogoByMyPage = computed(() => {
      return catalogStore.catalogs?.find((catalog: ICatalog) => catalog.idPageAssigned === props.idPage)
    })

    const lista_prodotti = computed(() => {
      const arr = catalogStore.catalogs?.find((catalog: ICatalog) => catalog.idPageAssigned === props.idPage)
      return arr?.lista_prodotti
    })

    const ispageCatalogata = computed(() => {
      return !!getCatalogoByMyPage.value
    })

    // Register the scroll event on component mount
    const handleScroll = () => {
      const scrollTop = window.scrollY || document.documentElement.scrollTop;

      // Set a threshold value based on how much scroll is needed to fix the components
      const threshold = 300

      // Update the isFixed ref based on the scroll position
      isFixed.value = scrollTop > threshold;
    };

    watch(() => cat.value, (newval, oldval) => {

      if (loadpage.value)
        tools.setCookie(tools.COOK_CATEGORIA, cat.value.toString())
      filter.value.author = '' // disattivo il filtro autore
      resetSearch()

      calcArrProducts()
    })

    watch(() => idGasSel.value, (newval, oldval) => {
      calcArrProducts()
    })

    watch(() => getSearchText(), (newval, oldval) => {
      calcArrProducts()
      if (tools.scrollTop() > 300) {
        tools.scrollToTopValue(300)
      }
    })
    watch(() => filter.value.author, (newval, oldval) => {

      // Se filtroAuthor attivato, allora evito il filtro per Categoria
      if (filter.value.author) {
        cat.value = '' // disattivo il filtro categoria
        if (loadpage.value)
          tools.setCookie(tools.COOK_CATEGORIA, '')
        resetSearch()
      }

      calcArrProducts()
      if (tools.scrollTop() > 300) {
        tools.scrollToTopValue(300)
      }
    })

    watch(() => filter.value.sort_field, (newval, oldval) => {

      calcArrProducts()
      if (tools.scrollTop() > 300) {
        tools.scrollToTopValue(300)
      }
    })
    watch(() => filter.value.sort_dir, (newval, oldval) => {

      calcArrProducts()
      if (tools.scrollTop() > 300) {
        tools.scrollToTopValue(300)
      }
    })

    watch(() => cosa.value, (newval, oldval) => {
      if (oldval !== 0) {
        tools.setCookie(tools.COOK_COSA_PRODOTTI, cosa.value.toString())
        if (cosa.value !== shared_consts.PROD.TUTTI) {
          cat.value = ''
          if (loadpage.value)
            tools.setCookie(tools.COOK_CATEGORIA, '')
        }
        calcArrProducts()
      }
    })

    watch(() => optcatalogo.value.aggiorna, (newval, oldval) => {
      console.log('Aggiorna array...')
      generatearrProdToViewSorted()
    })

    function resetSearch() {
      const mialista = getSearchList()
      if (mialista && mialista.value && tools.existProp(mialista.value, 'name')) {
        mialista.value = null
      }
      search.value = ''
    }

    function getSearchList() {
      const mylist = searchList.value.find((rec: any) => rec.table === 'products' && rec.key === 'titolo')

      return mylist
    }

    function getSearchText(): string {
      const lista = getSearchList()
      return lista && lista.value && tools.existProp(lista.value, 'name') ? lista.value.name : ''
    }

    function getTitoloCatalogo(): string {
      const trovatocatalogo = getCatalogoByMyPage.value

      return trovatocatalogo ? trovatocatalogo.title : 'Catalogo'
    }

    function getImgIntroCatalogo(scheda: IMyScheda): IImg {
      const trovatocatalogo = getCatalogoByMyPage.value

      let imagefile = ''
      let fit = 'contain'

      if (trovatocatalogo && scheda.isPagIntro) {
        const recimg = trovatocatalogo.img_intro
        if (recimg) {
          imagefile = recimg.imagefile!
          fit = recimg.fit! || 'contain'
          imagefile = imagefile ? `url(${tools.getDirUpload() + shared_consts.getDirectoryByTable(shared_consts.TABLES_CATALOG) + '/' + trovatocatalogo._id + '/' + imagefile})` : ''
        }
      }

      return { imagefile, fit }
    }

    function getSfondoImgCatalogo(scheda?: IMyScheda | null, mypage?: IDimensioni): IImg {
      const trovatocatalogo = getCatalogoByMyPage.value

      let imagefile = ''
      let fit = 'contain'

      if (trovatocatalogo) {
        // Cerca prima se c'è un Immagine Introduttiva
        const recimgintro = getImgIntroCatalogo(scheda)
        if (recimgintro.imagefile) {
          imagefile = recimgintro.imagefile!
          fit = recimgintro.fit! || 'contain'
        }

        // Poi cerca se c'è l'immagine di sfondo
        const recimg = trovatocatalogo.img_bordata!
        if (!imagefile && recimg) {
          imagefile = recimg.imagefile!
          fit = recimg.fit! || 'contain'
          imagefile = imagefile ? `url(${tools.getDirUpload() + shared_consts.getDirectoryByTable(shared_consts.TABLES_CATALOG) + '/' + trovatocatalogo._id + '/' + imagefile})` : ''
        }

      }
      if (!imagefile) {
        let myimg = costanti.CATALOGHI.PAG_SFONDO_DEFAULT
        if (scheda.isPagIntro) {
          myimg = costanti.CATALOGHI.PAG_INTRO_DEFAULT
        }
        // Se non c'è un immagine di sfondo, allora prende quella di default
        imagefile = `url(${tools.getDirUpload() + shared_consts.getDirectoryByTable(shared_consts.TABLES_CATALOG) + '/' + myimg})`
      }

      if (!imagefile && scheda) {
        imagefile = scheda.dimensioni?.pagina?.dimensioni?.imgsfondo!.imagefile
        imagefile = imagefile ? `url(${tools.getDirUpload() + costanti.DIR_SCHEDA + imagefile})` : ''
        fit = scheda.dimensioni?.pagina?.dimensioni?.imgsfondo!.fit
      }
      if (!imagefile && mypage) {
        imagefile = mypage.imgsfondo!.imagefile!
        imagefile = imagefile ? `url(${tools.getDirUpload() + costanti.DIR_CATALOGO + imagefile})` : ''
        fit = mypage.imgsfondo!.fit!
      }

      return { imagefile, fit }
    }

    function getIdCollaneDaFiltrare(def_idCollane?: number[]) {
      let idCollane: number[] = []

      // Cerca se nella lista cataloghi c'è la Collana di questa Pagina !
      const trovatocatalogo = getCatalogoByMyPage.value

      if (trovatocatalogo) {
        idCollane = trovatocatalogo.idCollane! || []
      } else {
        idCollane = def_idCollane || []
      }

      return idCollane
    }

    function getArgomentiDaFiltrare(def_argomenti?: string[]) {
      let argomenti: string[] = []

      // Cerca se nella lista cataloghi c'è la Collana di questa Pagina !
      const trovatocatalogo = getCatalogoByMyPage.value

      if (trovatocatalogo) {
        argomenti = trovatocatalogo.argomenti! || []
      } else {
        if (def_argomenti && def_argomenti.length > 0) {
          argomenti = def_argomenti
        } else {
          argomenti = []
        }
      }

      return argomenti
    }

    function getEditoreDaFiltrare(def_editori?: string[]) {
      let editore: string[] = []

      // Cerca se nella lista cataloghi c'è la Collana di questa Pagina !
      const trovatocatalogo = getCatalogoByMyPage.value

      if (trovatocatalogo) {
        editore = trovatocatalogo.editore! || []
      } else {
        editore = def_editori || []
      }

      return editore
    }


    function sovrascriviSchedaFromTemplate(idTemplate: string, origScheda: ISchedaSingola) {
      if (!optcatalogo.value)
        return

      const arrschede: ISchedaSingola[] = globalStore.getMySchede()
      const myfindscheda = arrschede.find((recscheda: ISchedaSingola) => recscheda.scheda?._id === idTemplate)

      const mynewscheda = tools.jsonCopy(origScheda)

      const linkIdTemplate = origScheda.scheda?.linkIdTemplate
      const precname = origScheda.scheda?.name

      if (myfindscheda) {
        const myschedatocopy = tools.jsonCopy(myfindscheda)

        if (myschedatocopy) {
          myschedatocopy.scheda._id = origScheda.scheda?._id
          myschedatocopy.scheda.isTemplate = false
          myschedatocopy.scheda.name = precname
          myschedatocopy.scheda.linkIdTemplate = linkIdTemplate

          return myschedatocopy.scheda
        }
      }

      return null
    }

    function populateDataWithlinkIdTemplate() {
      // console.log('populateDataWithlinkIdTemplate')

      if (optcatalogo.value) {

        for (const recscheda of optcatalogo.value.arrSchede!) {
          if (recscheda.scheda?.linkIdTemplate) {
            // ricopia da Template:
            const myscheda = sovrascriviSchedaFromTemplate(recscheda.scheda?.linkIdTemplate, recscheda)
            if (myscheda) {
              recscheda.scheda = myscheda
            }

          }
        }
      }

      // console.log('   FINE - populateDataWithlinkIdTemplate')
    }


    function filterProducts(
      products: IProduct[],
      searchtext: string | string[],
      filtroAuthor: string,
      filtroProductTypes: number[],
      filtroExcludeProductTypes: number[],
      editore: string[],
      idCollane: number[],
      arrargomstr: any[],
      catstr: string,
      gasselstr: string,
      cosaValue: any,
      sortField?: string,
      sortDir?: number
    ): IProduct[] {
      const lowerSearchTexts = Array.isArray(searchtext)
        ? searchtext.map((text: string) => text.toLowerCase().trim().replace(/[-@:=]/g, ''))
        : [searchtext.toLowerCase().trim().replace(/[-@:=]/g, '')];

      const boolfiltroVuotoProductTypes =
        filtroProductTypes.length === 0 || (filtroProductTypes.length === 1 && filtroProductTypes[0] === 0);
      const boolfiltroVuotoExcludeProductTypes = filtroExcludeProductTypes.length === 0;
      const boolfiltroVuotoEditore = editore.length === 0;
      const boolfiltroVuotoCollane = idCollane.length === 0;
      // const boolfiltroVuotoArgomenti = arrargomstr.length === 0;

      const arrris = products
        .filter((product: IProduct) => {
          if (!product || !product.productInfo) {
            console.error('product or product.productInfo is null');
            return false;
          }

          const lowerName = (product.productInfo.name || '').toLowerCase();
          const lowerCode = (product.productInfo.code || '').toLowerCase();

          // Filtri per argomenti e categorie
          let hasCategoria = false;
          let hasArgomentiCat = true;
          if (arrargomstr && arrargomstr.length > 0) {
            hasArgomentiCat = (product.productInfo.idCatProds || []).some((idCat: any) => arrargomstr.includes(idCat));
            hasCategoria = true;
          } else {
            hasCategoria = !catstr || (catstr && (product.productInfo.idCatProds || []).includes(catstr));
          }

          // Filtri per autore
          const hasAuthor = !filtroAuthor || (product.productInfo.idAuthors || []).includes(filtroAuthor);

          // Filtri per tipi di prodotto
          const hasProductTypes = boolfiltroVuotoProductTypes
            ? true
            : (product.productInfo.productTypes || []).some((item: any) => filtroProductTypes.includes(item));

          // Filtri per esclusione di tipi di prodotto
          const hasExcludeProductTypes = boolfiltroVuotoExcludeProductTypes
            ? false
            : (product.productInfo.productTypes || []).every((item: any) => filtroExcludeProductTypes.includes(item));

          // Filtri per editore
          const hasPublished = boolfiltroVuotoEditore
            ? true
            : editore.includes(product.productInfo.idPublisher);

          // Filtri per collana
          const hasCollana = boolfiltroVuotoCollane
            ? true
            : idCollane.includes(product.productInfo.idCollana);

          // Filtri per GAS
          const productgassel = !gasselstr || (cosaValue === shared_consts.PROD.GAS && product.idGasordine === gasselstr);

          // Filtri per testo di ricerca
          const searchMatch = lowerSearchTexts.length === 0 || lowerSearchTexts.some((searchTerm: string) => {
            const codeMatch = new RegExp(`\\b${searchTerm}\\b`, 'i').test(lowerCode);
            const allWordsPresent = searchTerm.split(/\s+/).every((word: string) =>
              new RegExp(`\\b${word}\\b`, 'i').test(lowerName)
            );
            return codeMatch || allWordsPresent;
          });

          return (
            searchMatch &&
            hasAuthor &&
            productgassel &&
            hasProductTypes &&
            (
              hasPublished &&
              hasCollana &&
              hasCategoria &&
              hasArgomentiCat
            )
            &&
            !hasExcludeProductTypes
          );
        })
        .sort((a, b) => getProductsSorted([a, b], sortField, sortDir)[0] === a ? -1 : 1);

      console.log('   Filtro=' + arrargomstr)
      console.log('   idCollane=' + idCollane)
      console.log('PRODOTTI FILTRATI:', arrris.length)

      return arrris
    }

    function calcArrProducts(generalista?: boolean) {
      console.log('calcArrProducts (generalista=' + generalista + ')')

      const searchtext = getSearchText();
      let arrprod = [];
      const filtroAuthor = filter.value.author || '';
      const filtroProductTypes = optcatalogo.value.productTypes || [0];
      const filtroExcludeProductTypes = optcatalogo.value.excludeproductTypes || [0];
      const editore = getEditoreDaFiltrare(optcatalogo.value.editore);
      const filtroPublishers = editore || [];
      const idCollane = getIdCollaneDaFiltrare(optcatalogo.value.idCollane);
      const filtroCollane = idCollane || [];
      const arrargomstr = optcatalogo.value.argomenti && optcatalogo.value.argomenti.length > 0
        ? getArgomentiDaFiltrare(optcatalogo.value.argomenti)
        : getArgomentiDaFiltrare(cat.value ? [cat.value] : []);
      const catstr = cat.value || '';
      const gasselstr = cosa.value === shared_consts.PROD.GAS ? idGasSel.value || '' : '';

      let salva = false
      // Se nel catalogo è stato già generato, allora gli passo quello.
      const trovatocatalogo = getCatalogoByMyPage.value

      if (trovatocatalogo.lista_prodotti.length === 0) {
        generalista = true
      }

      if (!generalista && (trovatocatalogo.lista_prodotti.length > 0)) {
        arrprod = trovatocatalogo.lista_prodotti
      } else {
        arrprod = productStore.getProducts(cosa.value)
        arrprod = filterProducts(
          arrprod,
          searchtext,
          filtroAuthor,
          filtroProductTypes,
          filtroExcludeProductTypes,
          filtroPublishers,
          filtroCollane,
          arrargomstr,
          catstr,
          gasselstr,
          cosa.value,
          filter.value.sort_field,
          filter.value.sort_dir
        );

        salva = true
      }

      arrProducts.value = arrprod;

      console.log('arrprod', arrprod)

      populateDataWithlinkIdTemplate();
      generatearrProdToViewSorted(!generalista, salva);
      loaddata();

      refreshpage.value = false;
    }

    function generaListaLibri() {
      calcArrProducts(true)
    }

    function getProductsFilteredByScheda(scheda: IMyScheda): IProduct[] {
      let arrprod = productStore.getProducts(cosa.value) || [];
      const filtroAuthor = filter.value.author || '';
      const filtroProductTypes = scheda.productTypes || [0];
      const filtroExcludeProductTypes = scheda.excludeproductTypes || [0];
      const editore = getEditoreDaFiltrare(scheda.editore);
      const filtroPublishers = editore || [];
      const idCollane = getIdCollaneDaFiltrare(scheda.idCollane);
      const filtroCollane = idCollane || [];
      const arrargomstr = optcatalogo.value.argomenti && optcatalogo.value.argomenti.length > 0
        ? getArgomentiDaFiltrare(optcatalogo.value.argomenti)
        : [];
      const catstr = cat.value || '';
      const gasselstr = cosa.value === shared_consts.PROD.GAS ? idGasSel.value || '' : '';

      const trovatocatalogo = getCatalogoByMyPage.value
      if (trovatocatalogo.lista_prodotti.length > 0) {
        arrprod = trovatocatalogo.lista_prodotti
      } else {

        arrprod = filterProducts(
          arrprod,
          scheda.arrProdottiSpeciali || [],
          filtroAuthor,
          filtroProductTypes,
          filtroExcludeProductTypes,
          filtroPublishers,
          filtroCollane,
          arrargomstr,
          catstr,
          gasselstr,
          cosa.value,
          scheda?.sort_field,
          scheda?.sort_dir
        );
      }

      return arrprod;
    }

    function getProductsSorted(arrprod: IProduct[], sort_field: string, sort_dir: number): IProduct[] {
      if (sort_field) {
        // Crea una copia dell'array per non modificare l'originale
        const sortedArr = [...arrprod].sort((a: IProduct, b: IProduct) => {
          const valA = a.productInfo?.[sort_field];
          const valB = b.productInfo?.[sort_field];

          if (valA === undefined || valB === undefined) {
            return 0; // Gestisce il caso in cui il campo non esiste
          }

          if (typeof valA === 'number' && typeof valB === 'number') {
            return sort_dir === 1 ? valA - valB : valB - valA;
          } else {
            // Per stringhe o altri tipi
            const compA = valA.toString().toLowerCase();
            const compB = valB.toString().toLowerCase();
            return sort_dir === 1
              ? compA.localeCompare(compB)
              : compB.localeCompare(compA);
          }
        });

        return sortedArr.map((product, index) => ({
          ...product,
          indiceRanking: index + 1
        }));
      }

      return arrprod;
    }

    function addNextProductToTheView(arrproductfiltrati: IProduct[], indprod: number) {
      try {

        let rectrovato = null;
        while (true) {
          if (indprod >= arrproductfiltrati.length) {
            return { end: true }
          }

          rectrovato = arrProdToView.value.find(
            (prodview: IProdView) => prodview.id === arrproductfiltrati[indprod]._id
          );

          if (rectrovato) {
            indprod++
            continue; // Era stato già aggiunto, quindi prova col prossimo
          } else {
            // Non è stato ancora aggiunto, quindi prendo questo e lo aggiungo alla lista !

            const myrec = arrproductfiltrati[indprod]

            arrProdToView.value.push({ id: myrec._id, showed: false });
            return { myrec, added: true, indprod }
          }

        }


      } catch (e) {
        console.error(e);
        return { rec: null, indprod }; // Assicurati di gestire correttamente l'errore
      }
    }

    function getProdBySchedaRigaCol(recscheda: ISchedaSingola, pagina: number, riga: number, col: number) {
      try {
        return recscheda.arrProdToShow![pagina][riga][col]
      } catch (e) {
        return null
      }
    }

    function generatearrProdToViewSorted(usaprodottiSalvati?: boolean, salva?: boolean) {
      console.log('generatearrProdToViewSorted... usaprodottiSalvati=', usaprodottiSalvati, ' salva=', salva)

      try {

        // Svuota
        arrProdToView.value = []

        const trovatocatalogo = getCatalogoByMyPage.value

        let arrGeneraleProdotti = []

        if (usaprodottiSalvati) {

        } else {
          arrGeneraleProdotti = arrProducts.value;
        }

        let indprod = 0
        const indprodGenerale = 0

        let indtotale = 0

        let arrprod = []

        for (const recscheda of optcatalogo.value.arrSchede!) {
          if (recscheda && recscheda.scheda) {
            const schedePerRiga = recscheda.scheda.numschede_perRiga || 1
            const schedePerCol = recscheda.scheda.numschede_perCol || 1
            const schedePerPagina = schedePerRiga * schedePerCol

            let arrProdFiltrati: IProduct[] = []

            if (usaprodottiSalvati && trovatocatalogo.lista_prodotti.length > 0) {
              arrProdFiltrati = trovatocatalogo.lista_prodotti
            } else {
              if (recscheda.scheda.productTypes!.length > 0) {
                // Filtra i prodotti in base ai filtri impostati !
                arrProdFiltrati = getProductsFilteredByScheda(recscheda.scheda)
                indprod = 0
              } else {
                if (recscheda.scheda.sort_field!) {
                  arrProdFiltrati = getProductsSorted(arrGeneraleProdotti, recscheda.scheda.sort_field, recscheda.scheda.sort_dir);
                  indprod = 0
                } else {
                  indprod = indprodGenerale
                  arrProdFiltrati = arrGeneraleProdotti
                }
              }
            }

            let indadded = 0
            recscheda.arrProdToShow = []

            for (let pagina = 0; pagina < 60; pagina++) {
              indadded = 0
              if (!recscheda.arrProdToShow[pagina]) {
                recscheda.arrProdToShow[pagina] = [];
              }

              for (let giro = 0; giro < schedePerPagina; giro++) {
                // Aggiunge il prossimo prodotto che non è stato ancora inserito
                const result = addNextProductToTheView(arrProdFiltrati, indprod);
                if (result.end) {
                  break; // Esci dal ciclo se non ci sono più prodotti disponibili
                } else {
                  if (result.indprod)
                    indprod = result.indprod // Aggiorna indprod per il prossimo giro
                  if (result.myrec) {

                    const riga = Math.floor(indadded / schedePerCol)
                    const col = indadded % schedePerCol

                    if (!recscheda.arrProdToShow[pagina][riga]) {
                      recscheda.arrProdToShow[pagina][riga] = [];
                    }

                    // console.log('RANKING: ', result.myrec.indiceRanking!)

                    arrprod.push(result.myrec)

                    recscheda.arrProdToShow[pagina][riga][col] = result.myrec

                    indadded++
                    indtotale++
                    // console.log('indadded', indadded)
                    if (optcatalogo.value.maxnumlibri! > 0) {
                      if (indtotale > optcatalogo.value.maxnumlibri!)
                        return

                    } else {
                      if (indtotale > 200)
                        return
                    }

                  }
                }
              }


              if (recscheda.numPagineMax! > 0) {
                if (pagina + 1 >= recscheda.numPagineMax!)
                  break; // fine pagine
              }


            }

            // console.log('*** arrProdToShow', recscheda.arrProdToShow)
          }

          // console.log('Fine Generazione')
        }

        // console.log('   FINE - generatearrProdToViewSorted !')


        if (!usaprodottiSalvati && salva) {
          trovatocatalogo.lista_prodotti = arrprod

          salvaListaProdotti(false)
        }

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

      // console.log('Fine...')
    }

    function salvaListaProdotti(ricarica: boolean) {
      // Estrai solo gli ID dei prodotti filtrati
      const myarr = [...getCatalogoByMyPage.value.lista_prodotti]
      const productIds = myarr.map(product => product._id);

      let mydata = {
        lista_prodotti: productIds
      }

      // Salva gli ID dei prodotti nel catalogo
      tools.saveFieldToServer($q, 'catalogs', getCatalogoByMyPage.value._id, mydata, true, false)


      if (ricarica) {
        generatearrProdToViewSorted(true, false);
      }
    }

    function getNextProd() {
      const nextRecord = arrProdToView.value.find((rec: any) => !rec.showed)

      // Se un tale record esiste, impostalo su mostrato
      if (nextRecord) {
        nextRecord.showed = true
        return arrProducts.value.find((recprod: IProduct) => recprod._id === nextRecord.id)
      }

      return null
    }


    /*function getProducts() {
      let arrprod = productStore.getProducts(cosa.value)
      if (!search.value) {
        return arrprod
      }

      let lowerSearchText = search.value.toLowerCase();
      let catstr = cat.value;

      return arrprod.filter((product: IProduct) => {
        let lowerName = product.productInfo.name!.toLowerCase();
        const hasCategoria = !catstr || (catstr && product.productInfo.idCatProds?.includes(catstr));
        return (product.productInfo.code!.includes(search.value) || lowerName.includes(lowerSearchText)) && hasCategoria
      });
    }*/

    async function mounted() {
      // console.log('mounted Catalogo')

      tabcatalogo.value = tools.getCookie('TAB_CAT', 'visu')

      loadpage.value = false
      await productStore.loadProducts()

      mycolumns.value = fieldsTable.getArrColsByTable('products')

      searchList.value = [
        {
          visible: true,
          label: 'Ricerca',
          table: 'products',
          key: 'titolo',
          type: costanti.FieldType.select_by_server,
          value: '',
          // addall: true,
          arrvalue: [],
          useinput: true,
          filter: null,
          tablesel: 'products',
        },
      ]

      optauthors.value = productStore.getAuthors()

      //++Todo: Per ora visualizzo solo il "Negozio" e non i GAS...
      cosa.value = shared_consts.PROD.BOTTEGA

      cat.value = tools.getCookie(tools.COOK_CATEGORIA, '')

      //cosa.value = tools.getCookie(tools.COOK_COSA_PRODOTTI, shared_consts.PROD.GAS, true)
      //if (cosa.value === shared_consts.PROD.TUTTI)


      // Inizializza
      loadpage.value = true
      window.addEventListener('scroll', handleScroll);

      calcArrProducts()

      loaddata()
    }

    function loaddata() {
      numRecLoaded.value = 20
    }

    // Remove the event listener on component destroy
    onBeforeUnmount(() => {
      window.removeEventListener('scroll', handleScroll);
    });

    function getCatProds() {
      const arrcat = productStore.getCatProds(cosa.value)
      const riscat: any = [{ label: 'Tutti', value: '', icon: undefined, color: undefined }]
      for (const rec of arrcat) {
        riscat.push({ label: rec.name, value: rec._id, icon: rec.icon, color: rec.color })
      }

      return riscat
    }


    function onLoadScroll(index: number, done: any) {
      if (index >= 1) {
        if (numRecLoaded.value < arrProducts.value.length) {

          const step = 10
          let mynrec = numRecLoaded.value + step

          if (mynrec > arrProducts.value.length)
            mynrec = arrProducts.value.length

          numRecLoaded.value = mynrec

        }
        done()
      } else {
        done(true)
      }
    }

    function filterFn(val: any, update: any, abort: any) {
      update(() => {
        const needle = val.toLowerCase();
        optauthors.value = productStore.getAuthors().filter(v => {
          const authorName = v.label.toLowerCase();
          const wordsToSearch = needle.split(' ');
          return wordsToSearch.every((word: any) => {
            if (word.length > 1) {
              return authorName.includes(word);
            } else {
              return authorName.split(' ').some((namePart: any) => namePart.startsWith(word));
            }
          });
        });
      });
    }

    function selauthor(id: string, value: string) {
      filter.value.author = id
    }

    /*function searchval(newval: any, table: any, tablesel: any) {
      console.log('REFRR searchval', newval, table, 'tablesel', tablesel)
      if (newval) {
        if (newval.hasOwnProperty('name')) {
          search.value = newval.name
        }
      } else {
        resetSearch()
      }
    }*/

    const valoriopt = computed(() => (item: any, addall: boolean, addnone: boolean = false) => {
      // console.log('valoriopt', item.table)
      return globalStore.getTableJoinByName(item.table, addall, addnone, item.filter)
    })

    const loadImage = (src: any) => {
      return new Promise((resolve, reject) => {
        const img = new Image()
        img.onload = () => resolve(img)
        img.onerror = reject
        img.src = src
      })
    }



    function groupedPages(recscheda: ISchedaSingola) {
      return recscheda.arrProdToShow
    }
    function generateStyleCatalogo(optcatalogo: IOptCatalogo) {

      return {

      }
    }

    function generateStylePageScheda(optcatalogo: IOptCatalogo, scheda: IMyScheda) {
      const marginTop = scheda.dimensioni?.pagina?.dimensioni?.margini?.top ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.margini?.top) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.top) || '')
      const marginBottom = scheda.dimensioni?.pagina?.dimensioni?.margini?.bottom ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.margini?.bottom) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.bottom) || '')
      const marginLeft = scheda.dimensioni?.pagina?.dimensioni?.margini?.left ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.margini?.left) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.left) || '')
      const marginRight = scheda.dimensioni?.pagina?.dimensioni?.margini?.right ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.margini?.right) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.right) || '')

      const paddingTop = scheda.dimensioni?.pagina?.dimensioni?.padding?.top ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.padding?.top) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.top) || '')
      const paddingBottom = scheda.dimensioni?.pagina?.dimensioni?.padding?.bottom ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.padding?.bottom) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.bottom) || '')
      const paddingLeft = scheda.dimensioni?.pagina?.dimensioni?.padding?.left ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.padding?.left) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.left) || '')
      const paddingRight = scheda.dimensioni?.pagina?.dimensioni?.padding?.right ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.padding?.right) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.right) || '')


      // Esiste un immagine di sfondo specifica della singola pagina ?
      const recimg = getSfondoImgCatalogo(scheda)
      const backgroundImage = recimg.imagefile! ?? ''
      const backgroundSize = recimg.fit

      const width = scheda.dimensioni?.pagina?.dimensioni?.size?.width ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.size?.width) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.size?.width) ?? '')
      const height = scheda.dimensioni?.pagina?.dimensioni?.size?.height ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.size?.height) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.size?.height) ?? '')

      return {
        marginBottom,
        marginTop,
        marginLeft,
        marginRight,
        paddingBottom,
        paddingTop,
        paddingLeft,
        paddingRight,
        backgroundImage,
        backgroundSize,
        '--width': width,
        '--height': height,
        ...((width && width !== '0px') ? { width: `${width} !important` } : {}),
        ...((height && height !== '0px') ? { height: `${height} !important` } : {}) // Aggiungi l'altezza solo se è valorizzata
      };
    }

    function generateStyleByPageDim(optcatalogo: IOptCatalogo, mypage: IDimensioni) {
      const marginTop = mypage.margini?.top ? tools.adjustSize(optcatalogo, mypage.margini?.top) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.top) || '')
      const marginBottom = mypage.margini?.bottom ? tools.adjustSize(optcatalogo, mypage.margini?.bottom) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.bottom) || '')
      const marginLeft = mypage.margini?.left ? tools.adjustSize(optcatalogo, mypage.margini?.left) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.left) || '')
      const marginRight = mypage.margini?.right ? tools.adjustSize(optcatalogo, mypage.margini?.right) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.margini?.right) || '')

      const paddingTop = mypage.padding?.top ? tools.adjustSize(optcatalogo, mypage.padding?.top) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.top) || '')
      const paddingBottom = mypage.padding?.bottom ? tools.adjustSize(optcatalogo, mypage.padding?.bottom) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.bottom) ?? '')
      const paddingLeft = mypage.padding?.left ? tools.adjustSize(optcatalogo, mypage.padding?.left) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.left) ?? '')
      const paddingRight = mypage.padding?.right ? tools.adjustSize(optcatalogo, mypage.padding?.right) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.padding?.right) ?? '')

      // Esiste un immagine di sfondo specifica della singola pagina ?
      const recimg = getSfondoImgCatalogo(null, mypage)
      let fileimg = recimg.imagefile! ?? ''
      let backgroundSize = recimg.fit

      if (!fileimg) {
        // Esiste un immagine di sfondo uguali per tutte le pagine ?
        fileimg = optcatalogo.dimensioni_def?.pagina.imgsfondo?.imagefile
        backgroundSize = optcatalogo.dimensioni_def?.pagina.imgsfondo?.fit
        fileimg = fileimg ? `url(${tools.getDirUpload() + costanti.DIR_CATALOGO + fileimg})` : ''
      }

      const backgroundImage = fileimg ?? ''

      const width = mypage.size?.width ? tools.adjustSize(optcatalogo, mypage.size?.width) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.size?.width) ?? '')
      const height = mypage.size?.height ? tools.adjustSize(optcatalogo, mypage.size?.height) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.size?.height) ?? '')

      return {
        marginBottom,
        marginTop,
        marginLeft,
        marginRight,
        paddingBottom,
        paddingTop,
        paddingLeft,
        paddingRight,
        backgroundImage,
        backgroundSize,
        '--width': width,
        '--height': height,
        ...((width && width !== '0px') ? { width: `${width} !important` } : {}),
        ...((height && height !== '0px') ? { height: `${height} !important` } : {}) // Aggiungi l'altezza solo se è valorizzata
      };
    }

    function getWidthPagina(optcatalogo: IOptCatalogo, scheda: IMyScheda) {
      return scheda.dimensioni?.pagina?.dimensioni?.size?.width ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.size?.width) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.size?.width) ?? '')
    }
    function getHeightPagina(optcatalogo: IOptCatalogo, scheda: IMyScheda) {
      return scheda.dimensioni?.pagina?.dimensioni?.size?.height ? tools.adjustSize(optcatalogo, scheda.dimensioni?.pagina?.dimensioni?.size?.height) : (tools.adjustSize(optcatalogo, optcatalogo.dimensioni_def?.pagina?.size?.height) ?? '')
    }

    function getStyleRowSeparator(recscheda: ISchedaSingola) {
      const paddingLeft = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.padding?.left) ?? '0px';
      const paddingRight = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.padding?.right) ?? '0px';

      return {
        paddingLeft: `${paddingLeft}`,
        paddingRight: `${paddingRight}`,
      };
    }

    function getStyleRow(recscheda: ISchedaSingola) {
      const placeContent = 'center';

      const width = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.size?.width) ?? '';
      const height = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.size?.height) ?? '';

      const marginTop = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.margini?.top) || '0';
      const marginBottom = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.margini?.bottom) || '0';
      const marginLeft = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.margini?.left) || '0';
      const marginRight = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.margini?.right) || '0';

      const paddingTop = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.padding?.top) || '0';
      const paddingBottom = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.padding?.bottom) || '0';
      const paddingLeft = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.padding?.left) || '0';
      const paddingRight = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.riga?.padding?.right) || '0';

      const out: any = {
        placeContent,
        flex: `0 1 ${width} !important`,
        margin: `${marginTop} ${marginRight} ${marginBottom} ${marginLeft}`,
        padding: `${paddingTop} ${paddingRight} ${paddingBottom} ${paddingLeft}`,
        ...((width && width !== '0px') ? { width: `${width} !important` } : {}),
        ...((height && height !== '0px') ? { height: `${height} !important` } : {})
      }

      /*if (width) {
        out.width = `${width} !important`
      }
      if (height) {
        out.height = `${height} !important`
      }*/

      return out

    }

    function getStyleSchedaProdotto(recscheda: ISchedaSingola) {
      const placeContent = 'center';

      const width = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.size?.width) ?? '100px';
      const height = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.size?.height);

      const marginTop = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.margini?.top) || '0px';
      const marginBottom = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.margini?.bottom) || '0px';
      const marginLeft = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.margini?.left) || '0px';
      const marginRight = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.margini?.right) || '0px';

      const paddingTop = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.padding?.top) || '0px';
      const paddingBottom = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.padding?.bottom) || '0px';
      const paddingLeft = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.padding?.left) || '0px';
      const paddingRight = tools.adjustSize(optcatalogo.value, recscheda.scheda?.dimensioni?.scheda_prodotto?.padding?.right) || '0px';

      return {
        placeContent,
        alignSelf: 'flex-start',
        flex: `0 1 ${width} !important`,
        margin: `${marginTop} ${marginRight} ${marginBottom} ${marginLeft}`,
        padding: `${paddingTop} ${paddingRight} ${paddingBottom} ${paddingLeft}`,
        ...((height && height !== '0px') ? { height: `${height} !important` } : {}) // Aggiungi l'altezza solo se è valorizzata
      };
    }

    function containsProducts(page: IProduct[][]) {
      return page && page.length > 0 && page[0] && page[0].length > 0
    }

    function naviga(path: string) {
      router.push(path)
    }

    function updateProducts(arr: any) {
      getCatalogoByMyPage.value.lista_prodotti = [...arr]

      salvaListaProdotti(true)
    }

    onMounted(mounted)

    return {
      userStore,
      costanti,
      tools,
      toolsext,
      search,
      cosa,
      shared_consts,
      getCatProds,
      cat,
      idGasSel,
      productStore,
      t,
      loadpage,
      refreshpage,
      componentToFixRef,
      isFixed,
      arrProducts,
      show_hide,
      onLoadScroll,
      numRecLoaded,
      arrLoaded,
      filter,
      optauthors,
      filterFn,
      selauthor,
      searchList,
      fieldsTable,
      valoriopt,
      labelcombo,
      mycolumns,
      tabvisu,
      getSearchText,
      pdfContent,
      tabcatalogo,
      groupedPages,
      getNextProd,
      getProdBySchedaRigaCol,
      generateStylePageScheda,
      generateStyleCatalogo,
      getStyleRow,
      getStyleSchedaProdotto,
      getWidthPagina,
      getHeightPagina,
      getStyleRowSeparator,
      generateStyleByPageDim,
      containsProducts,
      updateOptCatalogo,
      optcatalogo,
      getTestoIntroduttivo,
      ispageCatalogata,
      naviga,
      getTitoloCatalogo,
      getTitoloPagina,
      generaListaLibri,
      lista_prodotti,
      updateProducts,
    }
  }
})