window.analyzify.initGTM = (gtmObj, gtmProps) => {
  const params = {
    analyzify_source: 'advanced',
    implementation_type: 'extension'
  };
  
  // Enhanced parameters flag
  const enhanced_params = gtmProps?.enhanced_params || false;
  
  const PAGE_TYPES = {
    'index': 'homepage',
    'collection': 'category',
    'product': 'product',
    'cart': 'basket',
    'search': 'searchresults'
  };

  const pushedPage = PAGE_TYPES[window.analyzify.shopify_template] || 'other';
  
  const userData = window.analyzify?.shopify_customer?.type === 'visitor' 
    ? { type: 'visitor' }
    : {
        ...window.analyzify?.shopify_customer,
        email: window.analyzify?.shopify_customer?.email_address || null,
        phone: window.analyzify?.shopify_customer?.phone_number || null
      };

  const market = window.analyzify?.market || null;

  window.dataLayer.push({
    event: "sh_info",
    ...window.analyzify.SSAP_vals(),
    page_type: pushedPage,
    page_currency: window.analyzify?.currency,
    page_id: Date.now(),
    cart_id: window.analyzify?.cart_id || null,
    ss_event_id: window.analyzify.eventId.get('default') || null,
    market_id: market?.id?.toString() || null,
    market_handle: market?.handle?.toLowerCase() || null,
    market_language: market?.language?.toLowerCase() || null,
    market_country: market?.country?.toLowerCase() || null,
    shop_locale: window?.Shopify?.locale?.toLowerCase() || null,
    shop_country: window?.Shopify?.country?.toLowerCase() || null,
    user: userData,
    ...window.analyzify.storeObj,
    ...params,
  });

  window.analyzify.gtmViewItemList = (
    title,
    id,
    handle,
    products
  ) => {

    window.dataLayer.push({ ecommerce: null });
    const items = products.map((item, index) => {

      const firstVariant = window.analyzify.getFirstVariant(item);

      const compareAtPrice = window.analyzify.formatPrice(item?.compare_at_price);
      const actualPrice = window.analyzify.formatPrice(firstVariant?.price ?? item?.price);
      const getDiscount = (compareAtPrice > 0 && compareAtPrice !== actualPrice) ? compareAtPrice - actualPrice : 0;

      const item_id = item?.id?.toString();
      const itemSpecificProps = window.analyzify?.itemProps?.[item_id];

      const itemObj = {
          id: window.analyzify.getShopifyId(
            window.analyzify.feed_region,
            item?.id,
            firstVariant?.id,
            firstVariant?.sku
          ),
          item_id: item_id || null,
          item_name: item?.title?.trim() || null,
          item_list_name: title?.trim() || null,
          item_list_id: id?.toString() || null,
          item_list_handle: handle || null,
          index: index,
          item_barcode: firstVariant?.barcode || null,
          discount: window.analyzify.formatPrice(getDiscount) || 0,
          price: actualPrice || 0,
          item_category: item?.product_type || item?.type || null,
          item_brand: item?.vendor?.trim() || null,
          item_variant: firstVariant?.title?.trim() || null,
          item_variant_id: firstVariant?.id?.toString() || null,
          item_sku: firstVariant?.sku || null,
          quantity: 1,
          ...(enhanced_params ? {
            taxonomy_id: item?.taxonomy?.id || null,
            taxonomy_name: item?.taxonomy?.name || null,
            taxonomy_ancestors: item?.taxonomy?.ancestors || null,
            tags: item?.tags?.join(',') || null,
            options: item?.options?.join(',') || null,
            variant_ids: item?.variants?.map((v) => {
              return v?.id?.toString() || null;
            }).join(',') || null,
          } : {}),
        };

        return {
          ...itemObj,
          ...itemSpecificProps
        }

    });

    const chunkSize = gtmObj?.chunk_size;

    if(gtmProps?.multiple_view_item_list) {
      const itemsChunks = items.length > chunkSize ? 
      items.map((item, index) => ({
        ...item,
        index: index
      })).reduce((resultArray, item, index) => { 
        const chunkIndex = Math.floor(index/chunkSize);
        if(!resultArray[chunkIndex]) {
          resultArray[chunkIndex] = [];
        }
        resultArray[chunkIndex].push(item);
        return resultArray;
      }, []) : [items.map((item, index) => ({
        ...item,
        index: index
      }))];

      itemsChunks.forEach((chunk, chunkIndex) => {
        window.dataLayer.push({
          event: "ee_view_item_list",
          ss_event_id: window.analyzify.eventId.get('view_item_list') || null,
          ecommerce: {
            ...params,
            item_list_name: title || handle || null,
            item_list_id: id || null,
            items: chunk,
            cart_id: window.analyzify?.cart_id || null,
          },
        });
      });
    } else {
      window.dataLayer.push({
        event: "ee_view_item_list",
        ss_event_id: window.analyzify.eventId.get('view_item_list') || null,
        ecommerce: {
          ...params,
          item_list_name: title || handle || null,
          item_list_id: id || null,
          items: items,
          cart_id: window.analyzify?.cart_id || null,
        }
      });
    }
  };

  window.analyzify.gtmViewItem = (productObj, variantId) => {
    try {
      if (!productObj) return analyzify.log("Product object is not found", 'an_gtm', 'gtmViewItem');

      const {
        product,
        collection,
        taxonomy,
        variant
      } = productObj;

      if(!product) return analyzify.log('Product object is not found', 'an_gtm', 'gtmViewItem');

      const variantInput = variantId || variant?.id || window.analyzify?.getCurrentVariant()?.id;
      const variantDetails = window.analyzify.getVariantDetails(product?.variants, variantInput);
      const compareAtPrice = variantDetails?.compare_at_price;
      const actualPrice = window.analyzify.formatPrice(product?.price) ?? variantDetails?.price;
      const getDiscount = (compareAtPrice > 0 && compareAtPrice !== actualPrice) ? compareAtPrice - actualPrice : 0;

      window.dataLayer.push({ ecommerce: null });

      const item_id = product?.id?.toString();
      const itemSpecificProps = window.analyzify?.itemProps?.[item_id];

      window.dataLayer.push({
        event: "ee_view_item",
        ss_event_id: window.analyzify.eventId.get('view_item') || null,
        ecommerce: {
          ...params,
          currency: window.analyzify?.currency,
          value: window.analyzify.formatPrice(variantDetails?.price, false),
          cart_id: window.analyzify?.cart_id || null,
          items: [{
            id: window.analyzify.getShopifyId(
              window.analyzify.feed_region,
              product?.id,
              variantDetails?.id,
              variantDetails?.sku
            ),
            item_id: item_id || null,
            item_name: product?.title?.trim() || null,
            item_list_name: collection?.title?.trim() || null,
            item_list_id: collection?.id || null,
            item_list_handle: collection?.handle || null,
            price: window.analyzify.formatPrice(variantDetails?.price || product?.price, false),
            item_category: product?.type || null,
            item_brand: product?.vendor || null,
            item_barcode: variantDetails?.barcode || null,
            discount: window.analyzify.formatPrice(getDiscount, false) || 0,
            item_variant: variantDetails?.title || null,
            item_variant_id: variantInput?.toString() || variantDetails?.id || null,
            item_sku: variantDetails?.sku || null,
            quantity: 1,
            ...(enhanced_params ? {
              tags: product?.tags?.join(',') || null,
              options: product?.options?.join(',') || null,
              variant_ids: product?.variants?.map((v) => v?.id?.toString() || null).join(',') || null,
              taxonomy_id: taxonomy?.id || null,
              taxonomy_name: taxonomy?.name || null,
              taxonomy_ancestors: taxonomy?.ancestors || null,
            } : {}),
            ...(itemSpecificProps || {})
          }]
        },
      });

    } catch (error) {
      console.error("Error processing product view:", error);
    }
  }

  window.analyzify.gtmVariantChange = (variantData) => {
    try {

      if (!variantData) return analyzify.log('Variant data is not found', 'an_gtm', 'gtmVariantChange');

      const { product } = window.analyzify.getProductObj;
      if(!product) return analyzify.log('Product object is not found', 'an_gtm', 'gtmVariantChange');
      
      const selectedVariant = product?.variants?.find((variant) => variant.id.toString() === variantData.id.toString());
      if(!selectedVariant) return analyzify.log('Selected variant is not found', 'an_ga4_gads', 'gaVariantChange');
      
      const variantDetails = window.analyzify.getVariantDetails(product?.variants, selectedVariant?.id);
      if(!variantDetails) return analyzify.log('Variant details are not found', 'an_ga4_gads', 'gaVariantChange');

      if (selectedVariant) {
        window.dataLayer.push({
          event: "ee_variant_changed",
          ss_event_id: window.analyzify.eventId.get('variant_changed') || null,
          variant_id: variantDetails?.id?.toString() || null,
          variant_title: variantDetails?.title || null,
          product_price: window.analyzify.formatPrice(variantDetails?.price, false),
          product_sku: variantDetails?.sku || null,
          product_id: product?.id || null,
          product_title: product?.title || null,
          cart_id: window.analyzify?.cart_id || null,
          variant_availability: selectedVariant?.available || false,
        });

        if(gtmObj?.variant_changed_with_view_item) {
          window.analyzify.gtmViewItem(gtmObj.getProductObj, selectedVariant?.id);
        }

        analyzify.log('Variant changed', 'an_gtm', 'gtmVariantChange');
        analyzify.log(variantData, 'an_gtm', 'gtmVariantChange');
      }

    } catch (error) {
      console.error("Error setting up variant change tracking:", error);
    }
  }

  window.analyzify.gtmSelectItem = (productObj) => {

    if (!productObj) return analyzify.log("Product object is not found", 'an_gtm', 'gtmSelectItem');

    analyzify.log('productObj: gtmSelectItem', 'an_gtm', 'gtmSelectItem');
    analyzify.log(productObj, 'an_gtm', 'gtmSelectItem');

    const collection = window.analyzify.getCollectionObj;
    const firstVariant = window.analyzify.getFirstVariant(productObj);
    const compareAtPrice = window.analyzify.formatPrice(productObj?.compare_at_price);
    const actualPrice = window.analyzify.formatPrice(productObj?.price ?? firstVariant?.price);
    const getDiscount = (compareAtPrice > 0 && compareAtPrice !== actualPrice) ? compareAtPrice - actualPrice : 0;

    window.dataLayer.push({ ecommerce: null });

    const item_id = productObj?.id?.toString();
    const itemSpecificProps = window.analyzify?.itemProps?.[item_id];

    const itemObj = {
      event: "ee_select_item",
      ss_event_id: window.analyzify.eventId.get('select_item') || null,
      ecommerce: {
        ...params,
        currency: window.analyzify.currency,
        value: window.analyzify.formatPrice(productObj?.price, true),
        cart_id: window.analyzify?.cart_id || null,
        items: [{
          id: window.analyzify.getShopifyId(
            window.analyzify.feed_region,
            productObj?.id,
            firstVariant?.id,
            firstVariant?.sku
          ),
          item_id: item_id || null,
          item_name: productObj?.title?.trim() || null,
          item_list_name: collection?.title || null,
          item_list_id: collection?.id || null,
          item_list_handle: collection?.handle || null,
          item_barcode: firstVariant?.barcode || null,
          discount: window.analyzify.formatPrice(getDiscount, false) || 0,
          price: window.analyzify.formatPrice(firstVariant?.price || productObj?.price, true),
          item_category: productObj?.product_type || productObj?.type || null,
          item_brand: productObj?.vendor?.trim() || null,
          item_variant: firstVariant?.title?.trim() || null,
          item_variant_id: firstVariant?.id?.toString() || null,
          item_sku: firstVariant?.sku || null,
          quantity: 1,
          ...(enhanced_params ? {
            taxonomy_id: productObj?.taxonomy?.id || null,
            taxonomy_name: productObj?.taxonomy?.name || null,
            taxonomy_ancestors: productObj?.taxonomy?.ancestors || null,
            tags: productObj?.tags?.join(',') || null,
            options: productObj?.options?.join(',') || null,
            variant_ids: productObj?.variants?.map((v) => v?.id?.toString() || null).join(',') || null,
          } : {}),
          ...(itemSpecificProps || {})
        }]
      },
    };

    window.dataLayer.push(itemObj);
  };

  window.analyzify.gtmAddToCart = (productObj, currentVariant) => {
    try {

      if (!productObj) return analyzify.log("Product object is not found", 'an_gtm', 'gtmAddToCart');
      
      window.dataLayer.push({ ecommerce: null });

      let { product, variant, collection, taxonomy } = productObj;

      if(!product) product = productObj;

      const prodQty = window.analyzify.findQuantity() || 1;
      const addedItem = (() => {
        try {
          const variantDetails = window.analyzify.getVariantDetails(product?.variants, currentVariant || variant?.id);
          const compareAtPrice = variantDetails?.compare_at_price || product?.compare_at_price || 0;
          const actualPrice = variantDetails?.price || window.analyzify.formatPrice(product?.price) || 0;
          const getDiscount = (compareAtPrice > 0 && compareAtPrice !== actualPrice) ? compareAtPrice - actualPrice : 0;

          const item_id = product?.id?.toString();
          const itemSpecificProps = window.analyzify?.itemProps?.[item_id];

          return {
            id: window.analyzify.getShopifyId(
              window.analyzify.feed_region,
              product?.id,
              variantDetails?.id,
              variantDetails?.sku
              ),
            item_id: item_id || null,
            item_name: product?.title?.trim() || null,
            price: variantDetails?.price || window.analyzify.formatPrice(product?.price) || 0,
            discount: window.analyzify.formatPrice(getDiscount) || 0,
            item_barcode: variantDetails?.barcode || null,
            item_category: product?.type || null,
            item_brand: product?.vendor?.trim() || null,
            quantity: prodQty || 1,
            item_variant: variantDetails?.title || null,
            item_variant_id: (variantDetails?.id || variant?.id).toString() || null,
            item_sku: variantDetails?.sku || null,
            index: 0,
            ...(enhanced_params ? {
              taxonomy_id: taxonomy?.id || null,
              taxonomy_name: taxonomy?.name || null,
              taxonomy_ancestors: taxonomy?.ancestors || null,
              tags: product?.tags?.join(',') || null,
              options: product?.options?.join(',') || null,
              variant_ids: product?.variants?.map((v) => {
                return v?.id?.toString() || null;
              }).join(',') || null,
            } : {}),
            ...(itemSpecificProps || {})
          };

        } catch (error) {
          console.error("Error processing product add to cart:", error);
        }
      })();

      const totalVal = parseFloat(((addedItem.price || 0) * (prodQty || 1)).toFixed(2));
      
      if (collection) addedItem.item_list_id = collection?.id || null;
      if (collection?.title) addedItem.item_list_name = collection?.title || null;

      window.dataLayer.push({
        event: "ee_add_to_cart",
        ss_event_id: window.analyzify.eventId.get('add_to_cart') || null,
        ecommerce: {
          ...params,
          currency: window.analyzify?.currency,
          value: window.analyzify.formatPrice(totalVal, false),
          cart_id: window.analyzify?.cart_id || null,
          items: [addedItem],
        },
      });
      analyzify.log("Product ee_add_to_cart", 'an_gtm', 'gtmAddToCart');
        analyzify.log(window.dataLayer, 'an_gtm', 'gtmAddToCart');
    } catch (error) {
      console.error("Error processing product add to cart:", error);
    }
  };

  window.analyzify.gtmAddToWishList = (productObj, currentVariant) => {

    if (!productObj) return analyzify.log("Product object is not found", 'an_gtm', 'gtmAddToWishList');

    window.dataLayer.push({ ecommerce: null });
    const { product, variant, collection, taxonomy } = productObj;
    if(!product) product = productObj;

    const firstVariant = window.analyzify.getFirstVariant(product);
    const variantDetails = window.analyzify.getVariantDetails(product?.variants, currentVariant || variant?.id || firstVariant?.id);

    const compareAtPrice = variantDetails?.compare_at_price;
    const actualPrice = variantDetails?.price || window.analyzify.formatPrice(product?.price) || 0;
    const getDiscount = (compareAtPrice > 0 && compareAtPrice !== actualPrice) ? compareAtPrice - actualPrice : 0;

    const item_id = product?.id?.toString();
    const itemSpecificProps = window.analyzify?.itemProps?.[item_id];

    const itemObj = {
      id: window.analyzify.getShopifyId(
        window.analyzify.feed_region,
        product?.id,
        variantDetails?.id,
        variantDetails?.sku
      ),
      item_id: item_id || null,
      item_name: product?.title?.trim() || null,
      price: variantDetails?.price || window.analyzify.formatPrice(product?.price) || 0,
      item_category: product?.type || null,
      discount: window.analyzify.formatPrice(getDiscount) || 0,
      item_barcode: variantDetails?.barcode || null,
      item_brand: product?.vendor?.trim() || null,
      item_variant: variantDetails?.title?.trim() || null,
      item_variant_id: variantDetails?.id || null,
      item_sku: variantDetails?.sku || null,
      quantity: 1,
      index: 0,
      ...(enhanced_params ? {
        taxonomy_id: taxonomy?.id || null,
        taxonomy_name: taxonomy?.name || null,
        taxonomy_ancestors: taxonomy?.ancestors || null,
        tags: product?.tags?.join(',') || null,
        options: product?.options?.join(',') || null,
        variant_ids: product?.variants?.map((v) => {
          return v?.id?.toString() || null;
        }).join(',') || null,
      } : {}),
      ...(itemSpecificProps || {})
    };

    if(collection) itemObj.item_list_id = collection?.id || null;
    if(collection?.title) itemObj.item_list_name = collection?.title || null;

    if (!variantDetails) return analyzify.log("Variant details not found", 'an_gtm', 'gtmAddToWishList');

    itemObj.item_variant_id = variantDetails?.id || null;
    itemObj.price = window.analyzify.formatPrice(variantDetails?.price || 0);
    itemObj.item_sku = variantDetails?.sku || null;
    itemObj.item_variant = variantDetails?.title?.trim() || null;
    itemObj.item_name = productObj?.title?.trim() || null;

    const prodQty = analyzify.findQuantity() || 1;
    const totalVal = itemObj.price * prodQty;

    window.dataLayer.push({
      event: "ee_add_to_wishlist",
      ss_event_id: window.analyzify.eventId.get('add_to_wishlist') || null,
      ecommerce: {
        ...params,
        currency: window.analyzify.currency,
        value: window.analyzify.formatPrice(totalVal, false),
        cart_id: window.analyzify?.cart_id || null,
        items: [itemObj],
      },
    });
    analyzify.log("Product ee_add_to_wishlist", 'an_gtm', 'gtmAddToWishList');
    analyzify.log(window.dataLayer, 'an_gtm', 'gtmAddToWishList');
  };

  window.analyzify.gtmBeginCheckout = (cartObj) => {
    if (!cartObj) return analyzify.log("Cart object is not found", 'an_gtm', 'gtmBeginCheckout');

    const multipleProdsArr = cartObj?.items;
    if(!multipleProdsArr) return analyzify.log("Cart items are not found", 'an_gtm', 'gtmBeginCheckout');
    window.dataLayer.push({ ecommerce: null });

    const itemObj = {
      event: "ee_begin_checkout",
      ss_event_id: window.analyzify.eventId.get('begin_checkout') || null,
      ecommerce: {
        ...params, 
        currency: window.analyzify.currency,
        value: window.analyzify.formatPrice(cartObj?.total_price, true),
        total_quantity: Number(cartObj?.item_count) || 0,
        total_item: multipleProdsArr.length || 0,
        cart_id: cartObj?.token?.split('?')[0] || window.analyzify?.cart_id || null,
        items: multipleProdsArr.map((item, index) => {
          const item_id = item?.product_id?.toString();
          const baseItem = {
            id: window.analyzify.getShopifyId(
              window.analyzify.feed_region,
              item?.product_id,
              item?.variant_id,
              item?.sku
            ),
            item_id: item_id || null,
            item_name: item?.product_title?.trim() || item?.title?.trim() || null,
            price: window.analyzify.formatPrice(item?.price, true),
            item_category: item?.product_type || item?.type || null,
            item_brand: item?.vendor || null,
            item_barcode: null,
            discount: window.analyzify.formatPrice(item?.line_level_total_discount) || 0,
            item_handle: item?.handle || null,
            item_variant: item?.variant_title?.trim() || null,
            item_variant_id: item?.variant_id?.toString() || null,
            item_sku: item?.sku || null,
            index: index,
            quantity: item?.quantity || 1,
            ...(enhanced_params ? {
              tags: null,
              taxonomy_id: null,
              taxonomy_name: null,
              taxonomy_ancestors: null,
              options: item?.variant_options?.join(',') || null,
              variant_ids: item?.variant_id?.toString() || null,  
            } : {}),
          };

          // Get item-specific properties from itemProps
          const itemSpecificProps = window.analyzify?.itemProps?.itemProperties?.[item_id];

          // Merge base item with any specific properties
          return {
            ...baseItem,
            ...(itemSpecificProps || {})
          };
        }),
      },
    };

    window.dataLayer.push(itemObj);
    analyzify.log("Product ee_begin_checkout", 'an_gtm', 'gtmBeginCheckout');
    analyzify.log(window.dataLayer, 'an_gtm', 'gtmBeginCheckout');
  };

  window.analyzify.gtmHeroBannerClick = (hbElement) => {
    const allChildren = Array.from(hbElement.children);
    const targetChild = allChildren.find((sibling) => {
      const titleElement = analyzify.findElemInPath(
        Array.from(sibling.children).flatMap((child) =>
          Array.from(child.children),
        ),
        analyzify.hero_banner_title_attributes,
      );
      const subtitleElement = analyzify.findElemInPath(
        Array.from(sibling.children).flatMap((child) =>
          Array.from(child.children),
        ),
        analyzify.hero_banner_subtitle_attributes,
      );
      const ctaElement = analyzify.findElemInPath(
        Array.from(sibling.children).flatMap((child) =>
          Array.from(child.children),
        ),
        analyzify.hero_banner_cta_attributes,
      );
      const link = path.find(
        (element) =>
          (element.tagName === "A" || element.tagName === "BUTTON") &&
          element.href,
      );
      if ((titleElement || subtitleElement) && link) {
        window.dataLayer.push({
          event: "ee_hero_banner_click",
          ss_event_id: window.analyzify.eventId.get('hero_banner_click') || null,
          ...params,
          heading: titleElement
            ? titleElement?.textContent?.trim()?.substring(0, 100)
            : null,
          description: subtitleElement
            ? subtitleElement?.textContent?.trim()?.substring(0, 100)
            : null,
          cta_title:
            ctaElement && link
              ? ctaElement?.textContent?.trim()?.substring(0, 100)
              : null,
          cta_url: link ? link.href : null,
        });
        analyzify.log("Product ee_hero_banner_click", 'an_gtm', 'gtmHeroBannerClick');
        analyzify.log(window.dataLayer, 'an_gtm', 'gtmHeroBannerClick');
      }
      return titleElement || subtitleElement;
    });
  };

  window.analyzify.gtmProductDetailAccordion = (pdaElement) => {
    window.dataLayer.push({
      event: "ee_product_detail_accordion",
      ss_event_id: window.analyzify.eventId.get('product_detail_accordion') || null,
      ...params,
      title: pdaElement?.textContent?.replace(/\s+/g, " ")?.trim() || null,
    });
    analyzify.log("Product ee_product_detail_accordion", 'an_gtm', 'gtmProductDetailAccordion');
    analyzify.log(window.dataLayer, 'an_gtm', 'gtmProductDetailAccordion');
  };

  // @check
  window.analyzify.gtmsubmitContactForm = (formData) => {
    if (window.analyzify.properties.GA4.primary.ga4_contact_form || window.analyzify.properties.GA4.secondary.ga4_contact_form) {
      window.addEventListener("submit", (event) => {
        const formDataObj = new FormData(event.target);
        if (!formDataObj.get('contact[email]')) {
          return;
        }
        const formDataPairs = {};
        for (const [key] of formDataObj.entries()) {
          formDataPairs[key] = formDataObj.get(key);
        }

        if (formDataPairs['form_type'] == 'contact') {
          const contactObj = {
            method: 'contactForm',
            ...formDataPairs
          };
          window.dataLayer.push({
            event: "ee_contact_form",
            ss_event_id: window.analyzify.eventId.get('contact_form') || null,
            ...contactObj,
            cart_id: window.analyzify?.cart_id || null,
          });
        }
      });
    }
  };

  // @check
  window.analyzify.gtmsubmitNewsletterForm = (formData) => {
    if (window.analyzify.properties.GA4.primary.ga4_newsletter || window.analyzify.properties.GA4.secondary.ga4_newsletter) {
      window.addEventListener("submit", (event) => {
        const formDataObj = new FormData(event.target);
        if (!formDataObj.get('contact[email]')) {
          return;
        }
        const formDataPairs = {};
        for (const [key] of formDataObj.entries()) {
          formDataPairs[key] = formDataObj.get(key);
        }
        if (formDataPairs['form_type'] == 'customer') {
          const newsletterObj = {
            send_to: groups,
            eventParams: {
              "method": 'newsletter',
            },
            ...formDataPairs
          };
          window.dataLayer.push({
            event: "ee_newsletter",
            ss_event_id: window.analyzify.eventId.get('newsletter') || null,
            ...newsletterObj,
            cart_id: window.analyzify?.cart_id || null,
          });
          analyzify.log("newsletterObj", 'an_gtm', 'gtmSubmitNewsletterForm');
          analyzify.log(newsletterObj, 'an_gtm', 'gtmSubmitNewsletterForm');
        }
      })
    }
  };

  // @check
  window.analyzify.gtmDisclosureChange = (disclosureElement) => {
    window.dataLayer.push({
      event: "ee_disclosure_changed",
      ss_event_id: window.analyzify.eventId.get('disclosure_changed') || null,
      ...params,
      cart_id: window.analyzify?.cart_id || null,
      data_value: disclosureElement
        ? disclosureElement.hasAttribute("data-value")
          ? disclosureElement.getAttribute("data-value").trim()
          : null
        : null,
      selected_option: disclosureElement
        ? disclosureElement.textContent.replace(/\s+/g, " ").trim()
        : null,
      type: disclosureElement
        .closest("form")
        .classList.contains("localization-form")
        ? "localization-form"
        : null,
    });
    analyzify.log("Product ee_disclosure_changed", 'an_gtm', 'gtmDisclosureChange');
    analyzify.log(window.dataLayer, 'an_gtm', 'gtmDisclosureChange');
  };

  window.analyzify.gtmNavClick = (nav_elem, navTitle) => {
    if (!nav_elem) {
      analyzify.log("No navigation element found.", 'an_gtm', 'gtmNavClick');
      return;
    }

    const tagName = nav_elem.tagName;
    const type = window.analyzify.getTypeFromTag(tagName);
    const title = nav_elem.innerText.trim().split("\n")[0] || "";
    
    let url = null;
    
    // Step 1: Check the element itself for data attributes or href
    if (nav_elem.hasAttribute("data-url") || nav_elem.hasAttribute("data-link")) {
      url = nav_elem.getAttribute("data-url") || nav_elem.getAttribute("data-link");
    } else if (nav_elem.hasAttribute("href")) {
      url = nav_elem.getAttribute("href");
    } else {
      // Step 2: Look for various common elements that might contain URLs
      
      // Check for any summary elements with data attributes
      const summaryElements = nav_elem.querySelectorAll('summary[data-link], summary[data-url]');
      if (summaryElements.length > 0) {
        url = summaryElements[0].getAttribute("data-link") || summaryElements[0].getAttribute("data-url");
      }
      
      // If still no URL, check for anchor tags
      if (!url) {
        const anchorElements = nav_elem.querySelectorAll('a[href]');
        if (anchorElements.length > 0) {
          url = anchorElements[0].href;
        }
      }
      
      // If still no URL, check parent element
      if (!url) {
        const parent = nav_elem.parentElement;
        if (parent?.hasAttribute("href")) {
          url = parent.getAttribute("href");
        } else if (parent?.hasAttribute("data-url") || parent?.hasAttribute("data-link")) {
          url = parent.getAttribute("data-url") || parent.getAttribute("data-link");
        }
      }
      
      // If still no URL, check for closest elements with relevant attributes
      if (!url) {
        const closestAnchor = nav_elem.closest("a[href]");
        if (closestAnchor) {
          url = closestAnchor.href;
        } else {
          const closestDataLink = nav_elem.closest("[data-url], [data-link]");
          if (closestDataLink) {
            url = closestDataLink.getAttribute("data-url") || closestDataLink.getAttribute("data-link");
          }
        }
      }
    }

    window.dataLayer.push({
      event: "ee_nav_click",
      ss_event_id: window.analyzify.eventId.get('nav_click') || null,
      ...params,
      cart_id: window.analyzify?.cart_id || null,
      nav: { position: navTitle, type, title, url },
    });
    
    analyzify.log("Product ee_nav_click", 'an_gtm', 'gtmNavClick');
    analyzify.log(window.dataLayer, 'an_gtm', 'gtmNavClick');
  };

  if (window.analyzify.shopify_template == "collection") {

    const { products, title, id, handle } = gtmObj.getCollectionObj;
    window.analyzify.gtmViewItemList(title, id, handle, products);

  } else if (window.analyzify.shopify_template == "product") {
    if(!gtmObj.getProductObj) {
      return analyzify.log("Product object is not found", 'an_gtm', 'gtmViewItem');
    }
    window.analyzify.gtmViewItem(gtmObj.getProductObj);

  } else if (window.analyzify.shopify_template == "cart" || window.analyzify.isPathSegmentPresent('/a/gs/cart/')) {
    window.analyzify.gtmViewCart = (cartObj) => {
      if (!cartObj) return analyzify.log('Cart object is not found', 'an_gtm', 'gtmViewCart');
      if (cartObj?.items?.length == 0) return;

      const ecommerce = {
        currency: window.analyzify.currency,
        value: window.analyzify.formatPrice(cartObj.total_price, true),
        total_quantity: Number(cartObj.item_count),
        total_item: cartObj.items.length,
        cart_id: window.analyzify?.cart_id || null,
      };

      window.dataLayer.push({ ecommerce: null });
      window.dataLayer.push({
        event: "ee_view_cart",
        ss_event_id: window.analyzify.eventId.get('view_cart') || null,
        ecommerce: {
          ...params,
          ...ecommerce,
          items: cartObj.items.map((item, index) => {
            return {
              id: window.analyzify.getShopifyId(
                window.analyzify.feed_region,
                item?.product_id,
                item?.variant_id,
                item?.sku
              ),
              item_id: item?.product_id?.toString() || null,
              item_name: item?.product_title?.trim() || item?.title?.trim() || null,
              price: window.analyzify.formatPrice(item?.price, true),
              item_category: item?.product_type || null,
              item_brand: item?.vendor || null,
              item_handle: item?.handle || null,
              item_barcode: null,
              discount: window.analyzify.formatPrice(item?.line_level_total_discount, true) || 0,
              item_variant: item?.variant_title?.trim() || null,
              item_variant_id: item?.variant_id?.toString() || null,
              item_sku: item?.sku || null,
              index: index,
              quantity: item?.quantity || 1,
              ...(enhanced_params ? {
                tags: null,
                taxonomy_id: null,
                taxonomy_name: null,
                taxonomy_ancestors: null,
                options: item?.variant_options?.join(',') || null,
                variant_ids: item?.variant_id?.toString() || null,
              } : {}),
            };
          }),
        },
      });
    };
    window.analyzify.gtmViewCart(window.analyzify?.detectedCart);

  } else if (window.analyzify.shopify_template == "search") {

    window.analyzify.gtmSearch = (searchObj) => {
      try {
        
        if(!searchObj) return analyzify.log('Search object is not found', 'an_gtm', 'gtmSearch');
        
        const { term, products, searchPerformed } = searchObj;
        if(!searchPerformed) return analyzify.log('Search is not performed', 'an_gtm', 'gtmSearch');

        const items = products.map((item, index) => {
          try {
            const firstVariant = window.analyzify.getFirstVariant(item);
            return {
              id: window.analyzify.getShopifyId(
                window.analyzify.feed_region,
                item?.id,
                firstVariant?.id,
                firstVariant?.sku
              ),
              item_id: item?.id?.toString() || null,
              item_name: item?.product_title?.trim() || item?.title?.trim() || null,
              item_list_name: `Search Results: ${term}`,
              item_list_id: null,
              position: index,
              price: window.analyzify.formatPrice(item?.price, true),
              item_category: item?.product_type || item?.type || null,
              item_brand: item?.vendor || null,
              item_variant: firstVariant?.title?.trim() || null,
              item_variant_id: firstVariant?.id?.toString() || null,
              item_sku: firstVariant?.sku || null,
              quantity: item?.quantity || 1,
              ...(enhanced_params ? {
                tags: item?.tags?.join(',') || null,
                options: item?.options?.join(',') || null,
                taxonomy_id: item?.taxonomy?.id?.toString() || null,
                taxonomy_name: item?.taxonomy?.name || null,
                taxonomy_ancestors: item?.taxonomy?.ancestors || null,
                variant_ids: item?.variants?.map((v) => {
                  return v?.id?.toString() || null;
                }).join(',') || null,
              } : {}),
            };
          } catch (error) {
            console.error("Error processing search results:", error);
          }
        });

        window.dataLayer.push({ ecommerce: null });
        window.dataLayer.push({
          event: "ee_search",
          ss_event_id: window.analyzify.eventId.get('search') || null,
          page_type: "search",
          cart_id: window.analyzify?.cart_id || null,
          search_term: term,
          value: window.analyzify.formatPrice(items.reduce((acc, item) => acc + item.price * item.quantity, 0), false),
          currency: window.analyzify?.currency,
          ...params,
          ecommerce: {
            item_list_name: `Search Results: ${term}`,
            item_list_id: null,
            items: items,
          },
        });
        analyzify.log("Product ee_search", 'an_gtm', 'gtmSearch');
        analyzify.log(window.dataLayer, 'an_gtm', 'gtmSearch');

      } catch (error) {
        console.error("Error processing search results:", error);
      }
    };
    window.analyzify.gtmSearch(gtmObj.getSearchObj);
  }

  // @check: What function will be used for the "Begin Checkout" button in the cart drawer?
  // @todo: Implement checkout flow function for cart drawer
  // @github: Need to verify integration with existing checkout process
  window.analyzify.checkoutEventFunc = function(){
    analyzifyGtmViewCart(window.analyzify.detectedCart); // alternative
  }

  window.analyzify.gtmRemoveFromCart = (product) => {
    if (product) {

      const firstVariant = window.analyzify.getFirstVariant(product);

      window.dataLayer.push({ ecommerce: null });
      window.dataLayer.push({
        event: "ee_remove_from_cart",
        ss_event_id: window.analyzify.eventId.get('remove_from_cart') || null,
        ecommerce: {
          ...params,
          currency: window.analyzify.currency,
          cart_id: window.analyzify?.cart_id || null,
          value: window.analyzify.formatPrice(product?.price, true) * (product?.quantity || 1),
          items: [
            {
              id: window.analyzify.getShopifyId(
                window.analyzify.feed_region,
                product?.product_id,
                product?.variant_id,
                product?.sku
              ),
              item_id: (product?.product_id || product?.id)?.toString() || null,
              item_name: product?.title?.trim() || product?.product_title?.trim() || null,
              price: window.analyzify.formatPrice(product?.price || firstVariant.price, true), // Default to 0 if price is not defined
              item_category: product?.type || product?.product_type || null,
              item_brand: product?.vendor || null,
              discount: window.analyzify.formatPrice(product?.line_level_total_discount) || 0,
              item_barcode: firstVariant?.barcode || null,
              item_variant: product?.variant_title?.trim() || firstVariant?.title?.trim() || null,
              item_variant_id: product?.variant_id?.toString() || firstVariant?.id || null,
              item_sku: product?.sku || null,
              index: 0,
              quantity: product?.quantity || 1, // Default to 1 if quantity is not defined
            },
          ],
        },
      });
      analyzify.log("Product ee_remove_from_cart", 'an_gtm', 'gtmRemoveFromCart');
      analyzify.log(window.dataLayer, 'an_gtm', 'gtmRemoveFromCart');
    }
  };

  if (window.analyzify.op_cart_data_collection) {
    if(window.analyzify.checksendcartdata_status == false){
      window.analyzify_checksendcartdata();
    }
  }

};