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

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

import { shared_consts } from '@/common/shared_vuejs'
import { CProductCard } from '@src/components/CProductCard'
import { CMySelect } from '@src/components/CMySelect'
import { CContainerCatalogoCard } from '@src/components/CContainerCatalogoCard'
import { CSelectUserActive } from '@src/components/CSelectUserActive'
import { ICatalogo, IProduct, ISearchList } from 'model'

import html2canvas from 'html2canvas'
// import { VueHtmlToPaper } from 'vue-html-to-paper'
import html2pdf from 'html2pdf.js'

import { fieldsTable } from '@store/Modules/fieldsTable'

export default defineComponent({
  name: 'Catalogo',
  components: { CContainerCatalogoCard, CProductCard, CSelectUserActive, CMySelect },
  props: {
    optcatalogo: {
      type: Object as PropType<ICatalogo>,
      required: false,
      default: () => ({
        //++AddCATALOGO_FIELDS
        productTypes: [0],
        excludeproductTypes: [],
        formato: [],
        Categoria: [],
        Editore: [],
        pdf: false,
      }),
    },
  },
  setup(props) {
    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 filter = ref(<any>{
      author: '',
      sort: 1,
      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 tabvisu = ref('categorie')

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

    const arrProducts = ref<any>([])

    const numRecLoaded = ref(0)

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

    const isFixed = ref(false);

    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 []
      }
    })

    // 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 (cat.value) {
        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, (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()
      }
    })

    function resetSearch() {
      const mialista = getSearchList()
      if (mialista && mialista.value && mialista.value.hasOwnProperty('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 && lista.value.hasOwnProperty('name') ? lista.value.name : ''
    }

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

      const searchtext = getSearchText()

      refreshpage.value = true
      let arrprod = productStore.getProducts(cosa.value) || [];
      let filtroAuthor = filter.value.author || '';


      //++AddCATALOGO_FIELDS

      let filtroProductTypes = props.optcatalogo.productTypes || [0]
      let filtroExcludeProductTypes = props.optcatalogo.excludeproductTypes || [0]
      let boolfiltroVuotoProductTypes = (filtroProductTypes.length === 0 || (filtroProductTypes.length === 1 && (filtroProductTypes[0] === 0)))
      let boolfiltroVuotoExcludeProductTypes = filtroExcludeProductTypes.length === 0

      let filtroPublishers = props.optcatalogo.Editore || []
      let boolfiltroVuotoEditore = (filtroPublishers.length === 0)

      //console.log('filtroVersione', filtroProductTypes)

      let catstr = cat.value || ''

      let gasselstr = ''
      if (cosa.value === shared_consts.PROD.GAS) {
        gasselstr = idGasSel.value || '';
      }
      let lowerSearchText = (searchtext || '').toLowerCase().trim();
      lowerSearchText = lowerSearchText.replace(/[-@:=]/g, '');
      if ((!lowerSearchText || (lowerSearchText && lowerSearchText.length < 2)) && !catstr && boolfiltroVuotoProductTypes && boolfiltroVuotoExcludeProductTypes && boolfiltroVuotoEditore && !filtroAuthor && (!gasselstr && (cosa.value !== shared_consts.PROD.GAS))) {

      } else {

        arrprod = arrprod.filter((product: IProduct) => {
          if (product && product.productInfo) {
            let lowerName = (product.productInfo.name || '').toLowerCase();
            let hasCategoria = !catstr || (catstr && (product.productInfo.idCatProds || []).includes(catstr));
            let hasAuthor = !filtroAuthor || (filtroAuthor && (product.productInfo.idAuthors || []).includes(filtroAuthor));

            let hasProductTypes = true
            let hasPublished = true
            let hasExcludeProductTypes = false

            //++AddCATALOGO_FIELDS

            if (props.optcatalogo && !boolfiltroVuotoProductTypes) {
              // check if productInfo.productTypes array includes some item in props.optcatalogo.ProductTypes array
              hasProductTypes = !props.optcatalogo.productTypes || (props.optcatalogo.productTypes && (product.productInfo.productTypes || []).some((item: any) => props.optcatalogo.productTypes.includes(item)))
            }
            if (props.optcatalogo && !boolfiltroVuotoEditore) {
              hasPublished = !props.optcatalogo.Editore || (props.optcatalogo.Editore && props.optcatalogo.Editore.includes(product.productInfo.idPublisher!))
            }

            if (props.optcatalogo && !boolfiltroVuotoExcludeProductTypes) {
              // check if productInfo.productTypes array exclude some item in props.optcatalogo.ProductTypes array
              hasExcludeProductTypes = !props.optcatalogo.excludeproductTypes || (props.optcatalogo.excludeproductTypes && (product.productInfo.productTypes || []).every((item: any) => props.optcatalogo.excludeproductTypes.includes(item)))
            }

            let productgassel = true
            if (gasselstr || (cosa.value === shared_consts.PROD.GAS)) {
              productgassel = (product.idGasordine === gasselstr)
            }

            // Use a regular expression to match whole words
            let codeMatch = new RegExp(`\\b${lowerSearchText}\\b`, 'i');
            // let nameMatch = new RegExp(`\\b(?=.*\\b${lowerSearchText.split(/\s+/).map(word => `(${word})\\b`).join('.*\\b')}\\b)`, 'i');

            // Check if all words in lowerSearchText are present in lowerName
            let allWordsPresent = lowerSearchText.split(/\s+/).every(word => new RegExp(`\\b${word}\\b`, 'i').test(lowerName));

            return (codeMatch.test(product.productInfo.code || '') || allWordsPresent) && hasCategoria && hasAuthor && productgassel && hasProductTypes && hasPublished && !hasExcludeProductTypes;
          } else {
            console.error('product or product.productInfo is null');
            return false;
          }
        });
      }

      console.log('filter.value.sort', filter.value.sort)
      // sort using filter.value.sort :
      if (filter.value.sort === costanti.SORT_PUBDATE) {

        arrprod = arrprod.sort((a: IProduct, b: IProduct) => {
          return b.productInfo.date_publishing_ts - a.productInfo.date_publishing_ts
        })

      } else if (filter.value.sort === costanti.SORT_ALPHA) {

      }

      arrProducts.value = arrprod
      loaddata()
      refreshpage.value = false
    }


    /*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() {
      loadpage.value = false
      await productStore.loadProducts()

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

      searchList.value = [
        {
          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() {
      let arrcat = productStore.getCatProds(cosa.value)
      let 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) => {
      // console.log('valoriopt', item.table)
      return globalStore.getTableJoinByName(item.table, addall, addnone, item.filter)
    })

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

    const generatePDF = async () => {
      $q.loading.show({
        message: 'Caricamento immagini e generazione PDF in corso...'
      })

      try {

        const element = document.getElementById('pdf-content')
        const opt = {
          margin: 1,
          filename: 'catalogo_libri.pdf',
          image: { type: 'jpeg', quality: 0.98 },
          html2canvas: { scale: 2, useCORS: true },
          jsPDF: { unit: 'in', format: 'a4', orientation: 'portrait' }
        }

        await html2pdf().from(element).set(opt).save()

        $q.loading.hide()
        $q.notify({
          color: 'positive',
          message: 'PDF generato con successo!',
          icon: 'check'
        })
      } catch (error) {
        $q.loading.hide()
        $q.notify({
          color: 'negative',
          message: 'Errore nella generazione del PDF',
          icon: 'error'
        })
        console.error('Errore nella generazione del PDF:', error)
      }
    }

    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,
      generatePDF,
      pdfContent,
    }
  }
})