// version 01/12
var rootlinkPinterestPixel =
  "https://apps3.omegatheme.com/pinterest-multi-pixels";
// var rootlinkPinterestPixel = "https://dev.twoowls.io/pinterest-multi-pixels";
var shop = Shopify.shop;
var pageURL = window.location.href;
var currency = Shopify.currency.active;
var cart_url = "//" + window.location.hostname + "/cart.json";
var user_agent = window.navigator.userAgent;
var itemInCart;
window.ot_email = null;
localStorage.setItem("ot_pin_shop", Shopify.shop);

var otElementButtonAddToCart =
  "#addToCart,#teeAtcButton,#new-form-atc,.ProductForm__AddToCart,.single_add_to_cart_button,#AddToCartForm button,.product__form button.add-to-cart, #addtocart-product-template,.product-form__cart-submit,[name^='add']";
var otElementButtonCheckout =
  'form[action^="/checkout"] :submit[name^="checkout"],form[action^="/checkout"] .checkout-button,.checkout_btn,.OTCheckout,[name^="checkout"],form[action^="/cart"] :submit[name^="checkout"],form[action^="/cart"] .checkout-button,#cart .action_button.right, .upcart-checkout-button';

const genExternalSHA = async (externalId) => {
  const externalSHA = await sha256(externalId);
  return externalSHA;
}

async function getHashedExternalId() {
  if (localStorage.getItem("PIN_EXTERNAL_ID") === null) {
    let externalId = generateExternalID(36);
    const hashedExternalId = await genExternalSHA(externalId);
    localStorage.setItem("PIN_EXTERNAL_ID", hashedExternalId);
  }
}
getHashedExternalId();

async function otGetIP() {
  return await fetch("https://www.cloudflare.com/cdn-cgi/trace").then((res) =>
    res.text()
  );
}

!(function (e) {
  if (typeof window.otAddOmegaPinterest == "undefined") {
    window.otAddOmegaPinterest = false;
    window.pintrk = function () {
      window.pintrk.queue.push(Array.prototype.slice.call(arguments));
    };
    var n = window.pintrk;
    (n.queue = []), (n.version = "3.0");
    var t = document.createElement("script");
    (t.async = !0), (t.src = e);
    var r = document.getElementsByTagName("script")[0];
    r.parentNode.insertBefore(t, r);
    window.pintrk.checkOmegaPinterest = function () {
      if (arguments.length > 0) {
        var oh, nh, ih;
        "string" == typeof arguments[0] && (oh = arguments[0]),
          "string" == typeof arguments[1] && (nh = arguments[1]),
          "object" == typeof arguments[2] && (ih = arguments[2]);
        if (
          "string" == typeof oh &&
          "" != oh.replace(/\s+/gi, "") &&
          "string" == typeof nh &&
          nh.replace(/\s+/gi, "")
        ) {
          switch (nh) {
            case "init":
              {
                pintrk("load", oh, {
                  em: localStorage.getItem("ot_email"),
                });
                pintrk("page");
              }
              break;
            case "pagevisit":
            case "search":
            case "addtocart":
            case "checkout":
              pintrk("load", oh, {
                em: localStorage.getItem("ot_email"),
              });
              pintrk("page");
              pintrk("track", nh, ih);
              break;
            default:
              return;
          }
        }
      }
    };
  }
})("https://s.pinimg.com/ct/core.js", window, document, window.pintrk);

if (typeof $ == "undefined") {
  javascript: (function (e, s) {
    e.src = s;
    e.onload = function () {
      $ = jQuery.noConflict();
      if (typeof window.otCheckExistFilePinterest === "undefined") {
        otPinterestPixelInit();
        window.otCheckExistFilePinterest = false;
      }
    };
    document.head.appendChild(e);
  })(
    document.createElement("script"),
    "https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"
  );
} else {
  if (typeof window.otCheckExistFilePinterest === "undefined") {
    otPinterestPixelInit();
    window.otCheckExistFilePinterest = false;
  }
}

async function otPinterestPixelInit() {
  let setting = omegaPinterestSettings
    ? omegaPinterestSettings
    : JSON.parse(localStorage.getItem("ot_pin_setting"));
  let email =
    typeof customerEmail !== "undefined"
      ? await sha256(customerEmail)
      : await sha256(setting.email);
  window.ot_email = email;
  localStorage.setItem("ot_email", email);
  if (setting.enable == "1") {
    otMultiPinterestPixel(setting);
  }
}
async function otMultiPinterestPixel(checkExpireApp) {
  if (
    (typeof arrayPinterestPixelTrack != "undefined") || (typeof arrayPinterestConversionApiTrack != "undefined")
  ) {
    let arrayPinterestConversionApiTrackEvent = typeof arrayPinterestConversionApiTrack != "undefined" ? arrayPinterestConversionApiTrack : [];
    let arrayPinterestPixelTrackEvent = typeof arrayPinterestPixelTrack != "undefined" ? arrayPinterestPixelTrack : [];
    
    arrayPinterestPixelTrackEvent && localStorage.setItem('pin_list_pintag',arrayPinterestPixelTrackEvent)
    arrayPinterestConversionApiTrackEvent && localStorage.setItem('pin_list_capi',arrayPinterestConversionApiTrackEvent)
    generaFunSearch(arrayPinterestPixelTrackEvent, arrayPinterestConversionApiTrackEvent);
    generalFunPageVisit(arrayPinterestPixelTrackEvent, arrayPinterestConversionApiTrackEvent);
    generaFunCart(arrayPinterestPixelTrackEvent, arrayPinterestConversionApiTrackEvent);
    if(checkExpireApp?.enable_webpixel_ATC == 0){
      generaFunAddToCart(arrayPinterestPixelTrackEvent, arrayPinterestConversionApiTrackEvent);
    }
  }

  if(typeof checkExpireApp.is_enable_web_pixel == "undefined" || checkExpireApp.is_enable_web_pixel != "1") {
    generalCheckoutThankyouPage();
  }
}

async function generalCheckoutThankyouPage() {
  if (Shopify.Checkout && Shopify.Checkout.page.indexOf("thank_you") > -1) {
    var productIds = [];
    var productNames = [];
    var lineItems = [];
    var quantity = 0;
    var order_id = Shopify.checkout.order_id;
    Shopify.checkout.line_items.forEach(function (item, index) {
      quantity = quantity + item.quantity;
      if (item.variant_title != "") {
        var prod_name = item.title + " - " + item.variant_title;
      } else {
        var prod_name = item.title;
      }
      productNames.push(prod_name);
      productIds.push(`${item.product_id}`);
      lineItems.push({
        product_id: `${item.product_id}`,
        product_price: item.price,
        product_quantity: item.quantity
      })
    });
    addEventPurchaseInThankYouPage_Pinterest($, productIds, quantity, order_id, lineItems);
  }
}

async function generalFunPageVisit(arrayTrackPixel, arrayTrackConversion) {
  let eventId = omega_pinterest_uuid().slice(0, 10);
  if (pageURL.indexOf("/products/") > -1) {
    if (pageURL.indexOf("?") > -1) {
      var product_url = pageURL.split("?");
      product_url = product_url[0] + ".json";
    } else {
      var product_url = pageURL + ".json";
    }
    var product = await otGetInfoProductByLink(product_url);

    if (product.title.indexOf("'") > -1) {
      product.title = product.title.replace(/'/g, "");
    }

    arrayTrackPixel.forEach(function (element, index) {
      setTimeout(() => {
        window.pintrk.checkOmegaPinterest(`${element}`, "pagevisit", {
          line_items: [
            {
              product_name: product.title,
              product_id: `${product.id}`,
              product_category: product.product_type,
            },
          ],
          value: product.variants[0].price,
          currency: Shopify.currency.active,
          event_id: eventId,
        });
      }, 500);
    });

    // add conversion API event page_visit
    let conversionData = {
      event_name: "page_visit",
      event_id: eventId,
      currency: Shopify.currency.active,
      content_ids: [`${product.id}`],
      account_ids: arrayTrackConversion,
    };

    saveConversionApi(conversionData);
  } else {
    arrayTrackPixel.forEach(function (element, index) {
      window.pintrk.checkOmegaPinterest(`${element}`, "init");
    });
  }
}

async function generaFunSearch(arrayTrackPixel, arrayTrackConversion) {
  if (pageURL.indexOf("/search") > -1) {
    if (pageURL.indexOf("?") > -1) {
      var url = new URL(pageURL);
      var valueSearch = url.searchParams.get("q");
      var event_id_custom = omega_pinterest_uuid().slice(0, 10);

      arrayTrackPixel.forEach(function (element, index) {
        //pinterest
        setTimeout(() => {
          window.pintrk.checkOmegaPinterest(`${element}`, "search", {
            search_query: `${valueSearch}`,
            event_id: event_id_custom,
          });
        }, 500);
      });
    }

    // add conversion API event search page
    const dataSearch = {
      event_name: "search",
      event_id: event_id_custom,
      search_string: valueSearch,
      account_ids: arrayTrackConversion,
    };
    saveConversionApi(dataSearch);
  }
}

async function generaFunCart(arrayTrackPixel, arrayTrackConversion) {
  if (pageURL.indexOf("/cart") > -1) {
    getItemOnCartPage(function (cart) {
      itemInCart = cart;
      let items = cart.items;
      let lastItem = items[0];
      let totalItemCart = localStorage.getItem("OTPX_pinterest");
      let checkAddedOnProductPage = localStorage.getItem("OTPXADDED_pinterest");
      let eventId = omega_pinterest_uuid().slice(0, 10);
      if (
        (totalItemCart != cart.item_count || totalItemCart == null) &&
        checkAddedOnProductPage != 1
      ) {
        localStorage.setItem("OTPXADDED_pinterest", 0);
        localStorage.setItem("OTPX_pinterest", cart.item_count);

        arrayTrackPixel.forEach(function (element, index) {
          setTimeout(() => {
            window.pintrk.checkOmegaPinterest(`${element}`, "addtocart", {
              line_items: [
                {
                  product_id: `${lastItem["product_id"]}`,
                  product_name: `${lastItem["product_title"]}`,
                  product_category: `${lastItem["product_type"]}`,
                },
              ],
              product_id: `${lastItem["product_id"]}`,
              value: parseInt(lastItem["price"]) / 100,
              product_name: `${lastItem["product_title"]}`,
              currency: `${currency}`,
              event_id: eventId,
            });
          }, 500);
        });

        // add conversion API event add_to_cart

        let conversionData = {
          event_name: "add_to_cart",
          event_id: eventId,
          value: String(parseInt(lastItem["price"]) / 100),
          currency: `${currency}`,
          content_ids: [`${lastItem["product_id"]}`],
          account_ids: arrayTrackConversion,
        };
        saveConversionApi(conversionData);
      }
    });
  }
}

async function generaFunAddToCart(arrayTrackPixel, arrayTrackConversion) {
  document.querySelectorAll(otElementButtonAddToCart).forEach((button) => {
    button.addEventListener("click", async () => {
      setTimeout(async () => {
        try {
          const response = await fetch("/cart.js", { method: "GET" });
          if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
          }

          const cart = await response.json();
          localStorage.setItem("OTPXADDED_pinterest", 1);
          let eventId = omega_pinterest_uuid().slice(0, 10);

          if (cart.items.length > 0) {
            const lastItem = cart.items[0];

            arrayTrackPixel.forEach((element, index) => {
              setTimeout(() => {
                window.pintrk.checkOmegaPinterest(`${element}`, "addtocart", {
                  line_items: [
                    {
                      product_id: lastItem.product_id,
                      product_name: lastItem.product_title,
                      product_category: lastItem.product_type,
                    },
                  ],
                  product_id: lastItem.product_id,
                  value: parseInt(lastItem.price) / 100,
                  product_name: lastItem.product_title,
                  currency: currency,
                  event_id: eventId,
                });
              }, 500);
            });

            // Add conversion API event add_to_cart
            const conversionData = {
              event_name: "add_to_cart",
              event_id: eventId,
              value: String(parseInt(lastItem.price) / 100),
              currency: currency,
              content_ids: [`${lastItem["product_id"]}`],
              account_ids: arrayTrackConversion,
            };
            saveConversionApi(conversionData);
          } else {
            if (
              typeof __st.rid !== "undefined" &&
              typeof meta.product.variants[0].id !== "undefined"
            ) {
              arrayTrackPixel.forEach((element, index) => {
                setTimeout(() => {
                  window.pintrk.checkOmegaPinterest(`${element}`, "addtocart", {
                    line_items: [
                      {
                        product_id: __st.rid,
                        product_name: meta.product.variants[0].name,
                        product_category: meta.product.type,
                      },
                    ],
                    product_id: __st.rid,
                    value: parseInt(meta.product.variants[0].price) / 100,
                    product_name: meta.product.variants[0].name,
                    currency: currency,
                    event_id: eventId,
                  });
                }, 500);
              });

              // Add conversion API event add_to_cart
              const conversionData = {
                event_name: "add_to_cart",
                event_id: eventId,
                value: String(parseInt(meta.product.variants[0].price) / 100),
                currency: currency,
                content_ids: [__st.rid],
                account_ids: arrayTrackConversion,
              };
              saveConversionApi(conversionData);
            }
          }
        } catch (error) {
          console.error("Error fetching cart data:", error);
        }
      }, 1000);
    });
  });
}


function omega_pinterest_uuid() {
  var temp_url = URL.createObjectURL(new Blob());
  var omega_pinterest_uuid = temp_url.toString();
  URL.revokeObjectURL(temp_url);
  return omega_pinterest_uuid.substr(omega_pinterest_uuid.lastIndexOf("/") + 1); // remove prefix (e.g. blob:null/, blob:www.test.com/, ...)
}

async function saveConversionApi(conversionData) {
  if (conversionData.account_ids.length > 0) {
    try {
      const data = await otGetIP();
      const ip = data.split("ip=")[1].split("\n")[0];

      const dataCallApiConversion = {
        ...conversionData,
        shop: shop,
        external_id: localStorage.getItem("PIN_EXTERNAL_ID") ?? "",
        action: "saveConversionApi",
        client_ip_address: ip,
        client_user_agent: user_agent,
      };

      const response = await fetch(`${rootlinkPinterestPixel}/client/pinterest-conversion.php`, {
        method: "POST",
        // headers: {
        //   "Content-Type": "application/json",
        // },
        body: JSON.stringify(dataCallApiConversion),
      });
      const result = await response.json();
    } catch (error) {
      console.error("Error in saveConversionApi:", error);
    }
  }
}

async function getItemOnCartPage(callback) {
  try {
    const response = await fetch("/cart.js", { method: "GET" });

    const cart = await response.json();
    if (typeof callback === "function") {
      callback(cart);
    }
  } catch (error) {
    console.error("Error fetching cart data:", error);
  }
}

async function isUSePixelFromShopify() {
  if (typeof trekkie.integrations[2].options.pixelIds !== "undefined") {
    try {
      const response = await fetch(`${rootlinkPinterestPixel}/client/pinterest-pixel.php`, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ action: "checkUsePixelFromShopify", shop: shop }),
      });

      const result = await response.json();
    } catch (error) {
      console.error("Error checking pixel usage:", error);
    }
  }
}

function otPinterestPixelCheckExpireApp(
  rootlinkPinterestPixel_params,
  shop_params
) {
  "use strict";
  return new Promise(async (resolve) => {
    try {
      const response = await fetch(`${rootlinkPinterestPixel_params}/client/pinterest-pixel.php?action=checkExpire&shop=${shop_params}`);

      if (!response.ok) {
        throw new Error(`HTTP error! Status: ${response.status}`);
      }

      let result = await response.json();

      if (typeof result === "string") {
        result = JSON.parse(result);
      }

      resolve(result);

      window.ot_email = result.email;
      let email = typeof customerEmail !== "undefined" ? (await sha256(customerEmail)) : result.email;
      localStorage.setItem("ot_email", email);
    } catch (error) {
      console.error("Omega error fetching data:", error);
      resolve(null);
    }
  });
}


async function addEventPurchaseInThankYouPage_Pinterest(
  $,
  productIds,
  quantity,
  order_id,
  lineItems
) {
  let event_id_random = omega_pinterest_uuid().slice(0, 10);

  var pixels = await getAllPinterestPixelInThankYouPage(productIds);
  if (pixels.length > 0) {
    pixels.forEach(function (element) {
      setTimeout(() => {
        window.pintrk.checkOmegaPinterest(`${element}`, "checkout", {
          line_items: lineItems,
          currency: `${currency}`,
          value: Shopify.checkout.subtotal_price,
          product_id: `${productIds}`,
          order_quantity: quantity,
          order_id: order_id,
          event_id: event_id_random,
        });
      }, 500);
    });
  }

  checkConversionApiThankyouPage(
    $,
    productIds,
    quantity,
    order_id,
    event_id_random
  );
}

async function checkConversionApiThankyouPage(
  $,
  productIds,
  quantity,
  order_id,
  event_id_random
) {
  const dataProductCheckout = Shopify.checkout.line_items;
  let content_ids = [];
  let contents = [];

  dataProductCheckout?.length > 0 &&
    dataProductCheckout?.forEach((product) => {
      let productId = product.product_id;
      let productQuantity = product.quantity;
      let productPrice = product.price;
      if (productId != null && productId != undefined) {
        content_ids.push(`${productId}`);
      }
      if (productQuantity != null && productPrice != null) {
        contents.push({
          quantity: productQuantity,
          item_price: productPrice,
        });
      }
    });

  var conversions = await getAllPinterestConversionInThankYouPage(productIds);
  if (conversions.length > 0) {
    const dataThankYouPage = {
      event_name: "checkout",
      event_id: event_id_random,
      currency: `${currency}`,
      value: Shopify.checkout.total_price,
      order_id: `${order_id}`,
      content_ids: content_ids,
      contents: contents,
      num_items: quantity,
      account_ids: conversions,
    };

    saveConversionApi(dataThankYouPage);
  }
}

function getAllPinterestPixelInThankYouPage(productIDs) {
  return new Promise((resolve) => {
    var xhttp = new XMLHttpRequest();
    xhttp.onreadystatechange = function () {
      if (this.readyState == 4 && this.status == 200) {
        resolve(JSON.parse(xhttp.responseText));
      }
    };
    xhttp.open(
      "GET",
      `${rootlinkPinterestPixel}/client/pinterest-pixel.php?shop=${shop}&action=getAllPinterestPixelInThankYouPage&productIDs=${productIDs}`,
      true
    );
    xhttp.send();
  });
}
function getAllPinterestConversionInThankYouPage(productIDs) {
  return new Promise((resolve) => {
    var xhttp = new XMLHttpRequest();
    xhttp.onreadystatechange = function () {
      if (this.readyState == 4 && this.status == 200) {
        resolve(JSON.parse(xhttp.responseText));
      }
    };
    xhttp.open(
      "GET",
      `${rootlinkPinterestPixel}/client/pinterest-conversion.php?shop=${shop}&action=getAllPinterestConversionInThankYouPage&product_ids=${productIDs}`,
      true
    );

    xhttp.send();
  });
}
function otGetAllPixel($) {
  return new Promise((resolve) => {
    var xhttp = new XMLHttpRequest();
    xhttp.onreadystatechange = function () {
      if (this.readyState == 4 && this.status == 200) {
        resolve(JSON.parse(xhttp.responseText));
      }
    };
    xhttp.open(
      "GET",
      `${rootlinkPinterestPixel}/client/pinterest-pixel.php?shop=${shop}&action=getAllPixel`,
      true
    );
    xhttp.send();
  });
}
function otGetInfoProductByLink(URL) {
  return fetch(URL)
    .then((response) => {
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      return response.json();
    })
    .then((data) => {
      if (typeof data === "string") {
        data = JSON.parse(data);
      }
      return data?.product;
    })
    .catch((error) => {
      console.error("Error fetching product data:", error);
      throw error;
    });
}

Shopify.formatMoney = function (cents, format) {
  if (typeof cents === "string") {
    cents = cents.replace(".", "");
  }
  var value = "";
  var placeholderRegex = /\{\{\s*(\w+)\s*\}\}/;
  var formatString = format || this.money_format;

  function defaultOption(opt, def) {
    return typeof opt == "undefined" ? def : opt;
  }

  function formatWithDelimiters(number, precision, thousands, decimal) {
    precision = defaultOption(precision, 2);
    thousands = defaultOption(thousands, ",");
    decimal = defaultOption(decimal, ".");

    if (isNaN(number) || number == null) {
      return 0;
    }

    number = (number / 100.0).toFixed(precision);

    var parts = number.split("."),
      dollars = parts[0].replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + thousands),
      cents = parts[1] ? decimal + parts[1] : "";

    return dollars + cents;
  }
  switch (formatString.match(placeholderRegex)[1]) {
    case "amount":
      value = formatWithDelimiters(cents, 2);
      break;
    case "amount_no_decimals":
      value = formatWithDelimiters(cents, 0);
      break;
    case "amount_with_comma_separator":
      value = formatWithDelimiters(cents, 2, ".", ",");
      break;
    case "amount_no_decimals_with_comma_separator":
      value = formatWithDelimiters(cents, 0, ".", ",");
      break;
  }
  return formatString.replace(placeholderRegex, value);
};

async function sha256(message) {
  const msgBuffer = new TextEncoder().encode(message);
  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  const hashHex = hashArray
      .map((b) => b.toString(16).padStart(2, "0"))
      .join("");
  return hashHex;
}

function generateExternalID(length) {
  var a = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'.split('');
  var b = [];
  for (var i = 0; i < length; i++) {
    var j = (Math.random() * (a.length - 1)).toFixed(0);
    b[i] = a[j];
  }   
  return b.join('');
}