import { config } from './config';

export function buildInjectScript(): string {
  const checkoutRedirect = config.intercept.checkoutRedirectPath;
  const checkoutDelivery = config.intercept.checkoutDeliveryPath;
  const nativeOrderPath = config.intercept.checkoutOrderPath;
  const useNativeCheckout = config.checkout.useNativeCheckout;
  const pingPath = config.intercept.pingPath;
  const cartAddPath = config.intercept.eventCartAddPath;
  const checkoutStartPath = config.intercept.eventCheckoutStartPath;
  const supportPrefix = config.intercept.supportApiPrefix;

  return `<script data-morele-proxy="1">
(function(){
  if (document.body && document.body.getAttribute('data-mp-checkout-page') === '1') return;
  var USE_NATIVE_CHECKOUT = ${useNativeCheckout};
  var NATIVE_ORDER_PATH = ${JSON.stringify(nativeOrderPath)};
  var NATIVE_MODE = USE_NATIVE_CHECKOUT && (location.search || '').indexOf('mirror_checkout=fallback') < 0;
  var CHECKOUT_REDIRECT = ${JSON.stringify(checkoutRedirect)};
  var CHECKOUT_DELIVERY = ${JSON.stringify(checkoutDelivery)};
  var PING_PATH = ${JSON.stringify(pingPath)};
  var CART_ADD_PATH = ${JSON.stringify(cartAddPath)};
  var CHECKOUT_START_PATH = ${JSON.stringify(checkoutStartPath)};
  var SUPPORT_PREFIX = ${JSON.stringify(supportPrefix)};
  var MORELE_RE = /^https?:\\/\\/(?:[a-z0-9-]+\\.)?morele\\.net/i;
  var TRACKING_RE = /^https?:\\/\\/(?:static\\.klaviyo\\.com|fast\\.a\\.klaviyo\\.com|a\\.klaviyo\\.com|api\\.pushpushgo\\.com|s-eu-1\\.pushpushgo\\.com|bam\\.nr-data\\.net|js-agent\\.newrelic\\.com)\\b/i;
  var lastCartCandidate = null;

  function rewriteOAuthQuery(href){
    try {
      var url = new URL(href, location.href);
      var params = url.searchParams;
      var redirectUri = params.get('redirect_uri');
      if (redirectUri && MORELE_RE.test(redirectUri)) {
        var fixed = redirectUri.replace(MORELE_RE, location.origin);
        params.set('redirect_uri', fixed);
        url.search = params.toString();
        return url.toString();
      }
      var state = params.get('state');
      if (state && MORELE_RE.test(state)) {
        params.set('state', state.replace(MORELE_RE, location.origin));
        url.search = params.toString();
        return url.toString();
      }
    } catch (_) {}
    return href;
  }

  function normalizeUrl(value){
    try {
      var url = new URL(value, location.href);
      if (MORELE_RE.test(url.href)) {
        return location.origin + url.pathname + url.search + url.hash;
      }
      var oauthUrl = rewriteOAuthQuery(url.toString());
      if (oauthUrl !== url.toString()) return oauthUrl;
      if (TRACKING_RE.test(url.href)) {
        return location.origin + '/__stub/' + url.hostname + url.pathname + url.search + url.hash;
      }
      return value;
    } catch (_) {
      return value;
    }
  }

  function postLocal(path, payload){
    try {
      var body = JSON.stringify(payload || {});
      if (navigator.sendBeacon) {
        var blob = new Blob([body], {type:'application/json'});
        navigator.sendBeacon(path, blob);
        return;
      }
      fetch(path, {method:'POST',headers:{'Content-Type':'application/json'},credentials:'same-origin',body:body,keepalive:true}).catch(function(){});
    } catch (_) {}
  }

  function cleanText(value){
    return String(value || '').replace(/\\s+/g, ' ').trim().slice(0, 500);
  }

  function extractProductContext(el){
    var root = el && el.closest && el.closest('[data-product-id],[data-product],[data-productcode],article,.product,.product-box,.cat-product-card');
    var doc = root || document;
    var nameEl = doc.querySelector && doc.querySelector('[data-product-name],h1,.product-name,.product__name,.cat-product-name');
    var priceEl = doc.querySelector && doc.querySelector('[data-product-price],.price,.product-price,.price-new');
    var imageEl = doc.querySelector && doc.querySelector('img');
    var priceText = priceEl ? cleanText(priceEl.getAttribute('data-product-price') || priceEl.textContent) : '';
    var price = parseFloat(priceText.replace(/\\s/g, '').replace(',', '.').replace(/[^0-9.]/g, ''));
    return {
      sourceUrl: location.href,
      productId: root && cleanText(root.getAttribute('data-product-id') || root.getAttribute('data-product') || root.getAttribute('data-productcode')),
      productName: nameEl && cleanText(nameEl.getAttribute('data-product-name') || nameEl.textContent),
      price: isFinite(price) ? price : undefined,
      quantity: 1,
      imageUrl: imageEl && imageEl.src
    };
  }

  function looksLikeCartAdd(method, url){
    try {
      var parsed = new URL(url, location.href);
      var path = parsed.pathname.toLowerCase();
      if (!/post|put|patch/i.test(method || 'GET')) return false;
      return /(koszyk|cart|basket)/.test(path) && /(add|dodaj|produkt|item|ajax)/.test(path);
    } catch (_) {
      return false;
    }
  }

  function notifyCartAdd(url, status){
    var payload = lastCartCandidate || {sourceUrl: location.href};
    payload.requestUrl = url;
    payload.status = status;
    postLocal(CART_ADD_PATH, payload);
  }

  function rewriteDomUrls(root){
    root = root || document;
    var nodes = root.querySelectorAll ? root.querySelectorAll('a[href],form[action],img[src],script[src],link[href],iframe[src]') : [];
    for (var i = 0; i < nodes.length; i++) {
      var node = nodes[i];
      ['href','action','src'].forEach(function(attr){
        var value = node.getAttribute && node.getAttribute(attr);
        if (value && (MORELE_RE.test(value) || TRACKING_RE.test(value))) node.setAttribute(attr, normalizeUrl(value));
      });
    }
  }

  function parseMoneyText(value){
    var parsed = parseFloat(String(value || '').replace(/\\s/g, '').replace(',', '.').replace(/[^0-9.]/g, ''));
    return isFinite(parsed) ? Math.round(parsed * 100) / 100 : undefined;
  }

  function scrapeBasketItems(){
    var items = [];
    var boxes = document.querySelectorAll('.item-container.productData');
    for (var i = 0; i < boxes.length; i++) {
      var box = boxes[i];
      if (boxes.length > 1 && String(box.className || '').indexOf('item-active') < 0) continue;
      var name = cleanText(box.getAttribute('data-name'));
      if (!name) continue;
      var img = box.querySelector('.image-container img, .item-image img, .product-image img, img');
      var priceEl = box.querySelector('[data-price],.price-new,.product-price,.item-price,.price');
      var qtyEl = box.querySelector('.dropdown-native-select,.dropdown-manual-input');
      var qty = 1;
      if (qtyEl && qtyEl.tagName === 'SELECT' && qtyEl.selectedIndex >= 0) {
        qty = parseInt(qtyEl.options[qtyEl.selectedIndex].value, 10) || 1;
      } else if (qtyEl && qtyEl.value) {
        qty = parseInt(qtyEl.value, 10) || 1;
      }
      items.push({
        productId: cleanText(box.getAttribute('data-id') || box.getAttribute('data-product-id') || box.getAttribute('data-product')),
        productName: name,
        imageUrl: img && (img.getAttribute('src') || img.src),
        price: priceEl ? parseMoneyText(priceEl.getAttribute('data-price') || priceEl.textContent) : undefined,
        quantity: qty
      });
    }
    return items;
  }

  function fixBasketImages(root){
    root = root || document;
    rewriteDomUrls(root);
    var imgs = root.querySelectorAll ? root.querySelectorAll('#basket-wrapper img[src], .basket-wrapper img[src]') : [];
    for (var i = 0; i < imgs.length; i++) {
      var src = imgs[i].getAttribute('src');
      if (src && MORELE_RE.test(src)) imgs[i].setAttribute('src', normalizeUrl(src));
    }
  }

  function isCheckoutControl(el){
    if (NATIVE_MODE) return false;
    if (!el) return false;
    if (!/^\\/koszyk\\/?$/i.test(location.pathname)) return false;
    var text = (el.innerText || el.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
    var href = el.getAttribute && (el.getAttribute('href') || el.getAttribute('action') || '');
    if (/wybierz dostaw[eę] i p[lł]atno[sś][cć]|przejd[zź] do dostawy|przejd[zź] do p[lł]atno[sś]ci|realizacji zam[oó]wienia/.test(text)) return true;
    return /(?:checkout|zamowienie|dostawa-i-platnosc|platnosc|payment)/i.test(href || '') && /btn|button|submit|primary/i.test(String(el.className || '') + ' ' + String(el.type || ''));
  }

  function isFelopayPaymentControl(el){
    if (NATIVE_MODE) return false;
    if (!el) return false;
    if (document.body && document.body.getAttribute('data-mp-checkout-page') === '1') return false;
    var path = location.pathname.toLowerCase();
    if (!/^\\/(?:dostawa-i-platnosc|podsumowanie|zamowienie)\\/?$/.test(path)) return false;
    if (el.closest && el.closest('.max-card,[data-max-plan]')) return false;
    if (el.closest && el.closest('.modal-bg,.morele-right-panel')) return false;
    var text = (el.innerText || el.textContent || el.value || '').replace(/\\s+/g, ' ').trim().toLowerCase();
    var href = el.getAttribute && (el.getAttribute('href') || el.getAttribute('formaction') || el.getAttribute('action') || '');
    if (/przejd[zź] do podsumowania|zam[oó]w i zapłać|złóż zamówienie|przejd[zź] do płatności|opłać zamówienie|potwierdź i zapłać|przejd[zź] dalej/.test(text)) return true;
    if (/podsumowanie|platnosc|payment|checkout\\/redirect|__pay\\/redirect/.test(href || '')) {
      return /btn|button|submit|primary/i.test(String(el.className || '') + ' ' + String(el.type || ''));
    }
    return false;
  }

  function redirectToFelopay(source){
    postLocal(CHECKOUT_START_PATH, { sourceUrl: source || location.href, items: scrapeBasketItems() });
    window.location.href = CHECKOUT_REDIRECT;
  }

  function looksLikeMoreleCheckoutSubmit(method, url){
    try {
      var parsed = new URL(url, location.href);
      var path = parsed.pathname.toLowerCase();
      if (!/post|put|patch/i.test(method || 'GET')) return false;
      return (
        path === '/api/basket/checkout/' ||
        path.indexOf('/api/basket/checkoutproduct') === 0 ||
        /\\/zamowienie\\/submit\\/?$/.test(path) ||
        /\\/api\\/checkout\\/submit\\/?$/.test(path)
      );
    } catch (_) {
      return false;
    }
  }

  function shouldRedirectToFelopay(method, url){
    if (NATIVE_MODE) return false;
    if (!looksLikeMoreleCheckoutSubmit(method, url)) return false;
    return /^\\/(?:dostawa-i-platnosc|podsumowanie|zamowienie|koszyk)\\/?$/i.test(location.pathname);
  }

  function isDeliveryCheckoutLink(el){
    if (!el) return false;
    var href = el.getAttribute && (el.getAttribute('href') || el.getAttribute('formaction') || '');
    try {
      var path = new URL(href || '', location.href).pathname.toLowerCase();
      return /^\\/(?:dostawa-i-platnosc)\\/?$/.test(path);
    } catch (_) {
      return /dostawa-i-platnosc/i.test(href || '');
    }
  }

  function isPlainPrimaryClick(event){
    return event && event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey;
  }

  function shouldRepairLinkNavigation(link){
    if (!link || !link.href) return false;
    if (link.target && link.target.toLowerCase() !== '_self') return false;
    if (link.hasAttribute && link.hasAttribute('download')) return false;
    if (link.closest && link.closest('[role="tab"],[data-toggle],[data-bs-toggle],.dropdown-toggle')) return false;
    if (isCheckoutControl(link) || isFelopayPaymentControl(link) || isDeliveryCheckoutLink(link)) return false;
    try {
      var url = new URL(link.href, location.href);
      if (url.origin !== location.origin) return false;
      if (!/^https?:$/.test(url.protocol)) return false;
      if (url.pathname === location.pathname && url.search === location.search && url.hash) return false;
      return true;
    } catch (_) {
      return false;
    }
  }

  function repairPreventedLinkNavigation(event, link){
    if (!event.defaultPrevented || !shouldRepairLinkNavigation(link)) return;
    var href = link.href;
    var before = location.href;
    setTimeout(function(){
      if (location.href !== before) return;
      try { window.location.assign(href); } catch (_) { window.location.href = href; }
    }, 80);
  }

  function shouldRepairFormNavigation(form){
    if (!form || !form.action) return false;
    var method = (form.method || 'GET').toUpperCase();
    if (method !== 'GET') return false;
    if (isCheckoutControl(form) || isFelopayPaymentControl(form)) return false;
    try {
      var url = new URL(form.action, location.href);
      return url.origin === location.origin && /^https?:$/.test(url.protocol);
    } catch (_) {
      return false;
    }
  }

  function repairPreventedFormNavigation(event, form){
    if (!event.defaultPrevented || !shouldRepairFormNavigation(form)) return;
    var before = location.href;
    var url;
    try {
      url = new URL(form.action, location.href);
      var data = new FormData(form);
      data.forEach(function(value, key){
        if (typeof value === 'string') url.searchParams.set(key, value);
      });
    } catch (_) {
      return;
    }
    setTimeout(function(){
      if (location.href !== before) return;
      try { window.location.assign(url.toString()); } catch (_) { window.location.href = url.toString(); }
    }, 80);
  }

  document.addEventListener('click', function(event){
    var control = event.target && event.target.closest && event.target.closest('a,button,input[type="submit"]');
    if (control && /^\\/login\\/?$/i.test(location.pathname)) {
      var socialHref = control.getAttribute && control.getAttribute('href');
      if (socialHref && /^\\/connect\\/(?:google|facebook|apple)\\/?/i.test(socialHref)) {
        return;
      }
    }
    if (control && /^\\/koszyk\\/?$/i.test(location.pathname) && isDeliveryCheckoutLink(control)) {
      if (NATIVE_MODE) return;
      event.preventDefault();
      event.stopPropagation();
      postLocal(CHECKOUT_START_PATH, {sourceUrl: location.href, items: scrapeBasketItems()});
      window.location.href = CHECKOUT_DELIVERY;
      return;
    }
    if (control) {
      var text = cleanText(control.innerText || control.textContent || control.value).toLowerCase();
      var href = control.getAttribute && (control.getAttribute('href') || control.getAttribute('formaction') || '');
      if (/do koszyka|dodaj do koszyka|add to cart/.test(text) || /(koszyk|cart|basket).*(add|dodaj|produkt|item)/i.test(href || '')) {
        lastCartCandidate = extractProductContext(control);
        setTimeout(function(){ lastCartCandidate = null; }, 5000);
      }
    }
    if (isCheckoutControl(control)) {
      event.preventDefault();
      event.stopPropagation();
      postLocal(CHECKOUT_START_PATH, {sourceUrl: location.href, items: scrapeBasketItems()});
      window.location.href = CHECKOUT_DELIVERY;
      return;
    }
    if (isFelopayPaymentControl(control)) {
      event.preventDefault();
      event.stopPropagation();
      redirectToFelopay(location.href);
    }
  }, true);

  document.addEventListener('click', function(event){
    if (!isPlainPrimaryClick(event)) return;
    var link = event.target && event.target.closest && event.target.closest('a[href]');
    repairPreventedLinkNavigation(event, link);
    var submitControl = event.target && event.target.closest && event.target.closest('button[type="submit"],input[type="submit"]');
    if (submitControl) repairPreventedFormNavigation(event, submitControl.form || (submitControl.closest && submitControl.closest('form')));
  }, false);

  document.addEventListener('submit', function(event){
    var form = event.target;
    if (!form) return;
    var submitter = event.submitter;
    if (isCheckoutControl(form) || (submitter && isCheckoutControl(submitter))) {
      event.preventDefault();
      event.stopPropagation();
      postLocal(CHECKOUT_START_PATH, {sourceUrl: location.href, items: scrapeBasketItems()});
      window.location.href = CHECKOUT_DELIVERY;
      return;
    }
    if (isFelopayPaymentControl(form) || (submitter && isFelopayPaymentControl(submitter))) {
      event.preventDefault();
      event.stopPropagation();
      redirectToFelopay(location.href);
    }
  }, true);

  document.addEventListener('submit', function(event){
    repairPreventedFormNavigation(event, event.target);
  }, false);

  var basketWrapper = document.getElementById('basket-wrapper') || document.querySelector('.basket-wrapper');
  if (basketWrapper && window.MutationObserver) {
    fixBasketImages(basketWrapper);
    var basketObserver = new MutationObserver(function(){ fixBasketImages(basketWrapper); });
    basketObserver.observe(basketWrapper, {childList: true, subtree: true, attributes: true, attributeFilter: ['src']});
  }

  var origFetch = window.fetch && window.fetch.bind(window);
  if (origFetch) {
    window.fetch = function(input, init){
      var originalUrl = typeof input === 'string' ? input : input && input.url;
      var method = (init && init.method) || (input && input.method) || 'GET';
      if (typeof input === 'string') {
        input = normalizeUrl(input);
      } else if (input && input.url) {
        var normReq = normalizeUrl(input.url);
        if (normReq !== input.url && (MORELE_RE.test(input.url) || TRACKING_RE.test(input.url))) {
          input = new Request(normReq, input);
        }
      }
      if (shouldRedirectToFelopay(method, originalUrl || '')) {
        redirectToFelopay(location.href);
        return Promise.reject(new Error('morele_proxy_checkout_redirect'));
      }
      return origFetch(input, init).then(function(response){
        if (response && response.ok && looksLikeCartAdd(method, originalUrl || response.url)) {
          notifyCartAdd(originalUrl || response.url, response.status);
        }
        return response;
      });
    };
  }

  var OrigXHR = window.XMLHttpRequest;
  if (OrigXHR) {
    var origOpen = OrigXHR.prototype.open;
    var origSend = OrigXHR.prototype.send;
    OrigXHR.prototype.open = function(method, url){
      this.__moreleProxyMethod = method;
      this.__moreleProxyUrl = url;
      arguments[1] = normalizeUrl(url);
      return origOpen.apply(this, arguments);
    };
    OrigXHR.prototype.send = function(){
      if (shouldRedirectToFelopay(this.__moreleProxyMethod, this.__moreleProxyUrl)) {
        redirectToFelopay(location.href);
        return;
      }
      var xhr = this;
      xhr.addEventListener('load', function(){
        if (xhr.status >= 200 && xhr.status < 300 && looksLikeCartAdd(xhr.__moreleProxyMethod, xhr.__moreleProxyUrl)) {
          notifyCartAdd(xhr.__moreleProxyUrl, xhr.status);
        }
      });
      return origSend.apply(this, arguments);
    };
  }

  function initSupportBridge(){
    if (window.__moreleSupportBridge) return;
    window.__moreleSupportBridge = true;
    var sessionId = localStorage.getItem('mp_support_session') || '';
    var lastAgentId = localStorage.getItem('mp_last_agent_id') || '';

    function isPageMobile(){
      return /iphone|ipad|ipod|android|mobile/i.test(navigator.userAgent || '') || window.innerWidth <= 768;
    }

    function isAskspotChatIframe(el){
      if (!el || String(el.tagName).toLowerCase() !== 'iframe') return false;
      var src = String(el.getAttribute('src') || '');
      return /askspot|chat-widget/i.test(src) || el.classList.contains('askspot-chat-widget--open');
    }

    function isAskspotChatOpen(){
      var frames = document.querySelectorAll('iframe');
      for (var i = 0; i < frames.length; i++) {
        if (isAskspotChatIframe(frames[i]) && frames[i].classList.contains('askspot-chat-widget--open')) {
          return true;
        }
      }
      return false;
    }

    function installAskspotMobileShell(){
      if (!isPageMobile() || window.__mpAskspotMobileShell) return;
      window.__mpAskspotMobileShell = true;

      var viewportMeta = document.querySelector('meta[name="viewport"]');
      if (viewportMeta && viewportMeta.content.indexOf('interactive-widget') < 0) {
        viewportMeta.content += ', interactive-widget=overlays-content';
      }

      var pageStyle = document.createElement('style');
      pageStyle.setAttribute('data-mp-page-chat-fix', '5');
      pageStyle.textContent = ''
        + 'iframe.askspot-chat-widget--open,'
        + 'iframe[src*="chat-widget"].askspot-chat-widget--open,'
        + 'iframe[src*="askspot"].askspot-chat-widget--open{'
        + 'position:fixed!important;inset:0!important;width:100%!important;max-width:100vw!important;'
        + 'height:100%!important;max-height:100dvh!important;margin:0!important;border:0!important;'
        + 'z-index:2147483646!important;touch-action:manipulation!important;}'
        + 'iframe[src*="askspot"],iframe[src*="chat-widget"]{touch-action:manipulation;}';
      (document.head || document.documentElement).appendChild(pageStyle);

      var markOpenState = function(){
        document.documentElement.classList.toggle('mp-askspot-chat-open', isAskspotChatOpen());
      };
      markOpenState();

      if (window.MutationObserver) {
        var mo = new MutationObserver(function(mutations){
          for (var i = 0; i < mutations.length; i++) {
            var t = mutations[i].target;
            if (t && isAskspotChatIframe(t)) markOpenState();
          }
        });
        mo.observe(document.documentElement, {
          subtree: true,
          attributes: true,
          attributeFilter: ['class'],
        });
      }
    }

    installAskspotMobileShell();

    window.addEventListener('message', function(ev){
      try {
        if (!ev || !ev.data || ev.data.type !== 'mp_chat_typing') return;
        window.__mpIframeTyping = !!ev.data.active;
      } catch (_) {}
    }, true);

    function ensureSession(){
      return fetch(SUPPORT_PREFIX + '/session', {
        method:'POST',
        headers:{'Content-Type':'application/json'},
        credentials:'same-origin',
        body:JSON.stringify({pageUrl:location.href,sessionId:sessionId||undefined})
      })
        .then(function(r){ return r.json(); })
        .then(function(res){
          sessionId = res.sessionId || '';
          if (sessionId) localStorage.setItem('mp_support_session', sessionId);
          return sessionId;
        });
    }

    var lastIframeRefreshAt = 0;

    function refreshIframeChat(){
      if (isPageMobile() && (isAskspotChatOpen() || window.__mpIframeTyping)) return;
      var now = Date.now();
      if (now - lastIframeRefreshAt < 1500) return;
      lastIframeRefreshAt = now;
      var frames = document.querySelectorAll('iframe');
      for (var i = 0; i < frames.length; i++) {
        try {
          var bridge = frames[i].contentWindow && frames[i].contentWindow.__mpChatBridge;
          if (bridge && bridge.refresh) bridge.refresh();
        } catch (_) {}
      }
    }

    function poll(){
      ensureSession()
        .then(function(){ refreshIframeChat(); })
        .catch(function(){});
    }

    var pageFetch = window.fetch && window.fetch.bind(window);
    if (pageFetch) {
      window.fetch = function(input, init){
        return pageFetch(input, init).then(function(res){
          try {
            if (res && res.ok) {
              var reqUrl = typeof input === 'string' ? input : input && input.url;
              if (reqUrl && /\\/api\\/v1\\/conversation/.test(reqUrl)) {
                var synced = res.headers.get('X-Support-Session-Id');
                if (synced) {
                  sessionId = synced;
                  localStorage.setItem('mp_support_session', synced);
                }
              }
            }
          } catch (_) {}
          return res;
        });
      };
    }

    ensureSession().finally(function(){
      poll();
      setInterval(poll, 8000);
    });
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', initSupportBridge);
  } else {
    initSupportBridge();
  }

  rewriteDomUrls(document);
  new MutationObserver(function(mutations){
    for (var i = 0; i < mutations.length; i++) {
      for (var j = 0; j < mutations[i].addedNodes.length; j++) {
        var node = mutations[i].addedNodes[j];
        if (node && node.nodeType === 1) rewriteDomUrls(node);
      }
    }
  }).observe(document.documentElement, { childList: true, subtree: true });

  setInterval(function(){
    try { navigator.sendBeacon && navigator.sendBeacon(PING_PATH); } catch (_) {}
  }, 30000);
})();
</script>`;
}

export function buildLoginInjectScript(): string {
  return `<script data-morele-login-proxy="1">
(function(){
  var SOCIAL_RE = /^\\/connect\\/(?:google|facebook|apple)\\/?/i;

  // stripCloudflareBrowserChallenge removes rocket-loader; keep clicks working on login/register.
  window.__cfRLUnblockHandlers = true;

  document.documentElement.setAttribute('data-mp-login-page', '1');

  function normalizeLoginForms(){
    var forms = document.querySelectorAll ? document.querySelectorAll('form[action]') : [];
    for (var i = 0; i < forms.length; i++) {
      var action = forms[i].getAttribute('action') || '';
      try {
        var url = new URL(action, location.href);
        if (url.origin === location.origin) {
          forms[i].setAttribute('action', url.pathname + url.search + url.hash);
        }
      } catch (_) {}
    }
  }

  var lastSwitchTouchAt = 0;

  function installLoginUiFixes(){
    if (window.__mpLoginUiFixes) return;
    window.__mpLoginUiFixes = true;

    var style = document.createElement('style');
    style.setAttribute('data-mp-login-ui-fix', '4');
    style.textContent = ''
      + 'label.switch-container{position:relative!important;cursor:pointer!important;}'
      + 'label.switch-container .switch{pointer-events:auto!important;cursor:pointer!important;}'
      + 'label.switch-container a[href]{position:relative!important;z-index:4!important;pointer-events:auto!important;}'
      + '[data-auth-navigation-target="forms"] .form-container:not(.active-tab){pointer-events:none!important;visibility:hidden!important;height:0!important;overflow:hidden!important;margin:0!important;padding:0!important;border:0!important;}'
      + 'html[data-mp-login-page] iframe.askspot-chat-widget:not(.askspot-chat-widget--open){width:72px!important;height:72px!important;max-width:72px!important;max-height:72px!important;}';
    (document.head || document.documentElement).appendChild(style);
  }

  function isActiveFormSwitch(label){
    if (!label || !label.closest) return false;
    var form = label.closest('.form-container');
    return form && form.classList && form.classList.contains('active-tab');
  }

  function activateSwitchFromEvent(event){
    var label = event.target && event.target.closest && event.target.closest('label.switch-container');
    if (!label || !isActiveFormSwitch(label)) return;
    if (event.target && event.target.closest && event.target.closest('a[href]')) return;

    var input = label.querySelector('input.form-checkbox');
    if (!input) return;

    event.preventDefault();
    event.stopPropagation();
    if (event.stopImmediatePropagation) event.stopImmediatePropagation();

    input.checked = !input.checked;
    try {
      input.dispatchEvent(new Event('change', { bubbles: true }));
      input.dispatchEvent(new Event('input', { bubbles: true }));
    } catch (_) {}
  }

  function onSwitchTouchEnd(event){
    lastSwitchTouchAt = Date.now();
    activateSwitchFromEvent(event);
  }

  function onSwitchClick(event){
    if (Date.now() - lastSwitchTouchAt < 450) return;
    activateSwitchFromEvent(event);
  }

  function fixSwitchLinks(){
    var links = document.querySelectorAll ? document.querySelectorAll('label.switch-container a[href*="pokaz_pomoc"]') : [];
    for (var i = 0; i < links.length; i++) links[i].setAttribute('target', '_self');
  }

  document.addEventListener('click', function(event){
    var link = event.target && event.target.closest && event.target.closest('a[href]');
    if (!link) return;
    var href = link.getAttribute('href') || '';
    var url;
    try {
      url = new URL(href, location.href);
    } catch (_) {
      return;
    }
    if (url.origin === location.origin && SOCIAL_RE.test(url.pathname)) {
      event.preventDefault();
      event.stopImmediatePropagation();
      window.location.assign(url.pathname + url.search + url.hash);
    }
  }, true);

  installLoginUiFixes();
  normalizeLoginForms();
  fixSwitchLinks();
  document.addEventListener('touchend', onSwitchTouchEnd, true);
  document.addEventListener('click', onSwitchClick, true);

  function ensureRegisterSubmit(){
    var form = document.getElementById('register_form');
    if (!form || form.getAttribute('data-mp-register-submit')) return;
    form.setAttribute('data-mp-register-submit', '1');
    normalizeLoginForms();
    form.addEventListener('submit', function(event){
      var regulations = document.getElementById('user_regulations');
      if (regulations && !regulations.checked) {
        event.preventDefault();
        try { regulations.dispatchEvent(new Event('change', { bubbles: true })); } catch (_) {}
        return;
      }
      normalizeLoginForms();
      form.setAttribute('action', '/register');
    }, false);
  }

  if (window.MutationObserver) {
    new MutationObserver(function(){
      fixSwitchLinks();
      ensureRegisterSubmit();
    }).observe(document.documentElement, {
      childList: true,
      subtree: true
    });
  }

  ensureRegisterSubmit();
})();
</script>`;
}

/** Runs inside the Askspot chat iframe — filters AI, appends TG operator messages without touching composer UI. */
export function buildAskspotBridgeScript(): string {
  const supportPrefix = config.intercept.supportApiPrefix;
  const humanAuthor = 'Specjalista Morele';
  const chatBrand = 'morelebuy.net';

  return `<script data-morele-askspot-bridge="1">
(function(){
  function isLikelyMobile(){
    var ua = String(navigator.userAgent || '');
    if (/iphone|ipad|ipod|android|mobile/i.test(ua)) return true;
    try {
      var parentWin = window.parent && window.parent !== window ? window.parent : window;
      return parentWin.innerWidth <= 768;
    } catch (_) {
      return /iphone|ipad|ipod|android|mobile/i.test(ua);
    }
  }

  function installResizeMessageGuard(){
    if (window.__mpResizeGuard) return;
    window.__mpResizeGuard = true;
    var proto = window.EventTarget && window.EventTarget.prototype;
    if (!proto || !proto.addEventListener) return;
    var nativeAdd = proto.addEventListener;
    proto.addEventListener = function(type, listener, options){
      if (type !== 'message' || typeof listener !== 'function') {
        return nativeAdd.call(this, type, listener, options);
      }
      var wrapped = function(ev){
        try {
          if (isLikelyMobile() && ev && ev.data && ev.data.type === 'resize' && ev.data.data) {
            var layoutH = window.innerHeight || document.documentElement.clientHeight || 0;
            var layoutW = window.innerWidth || document.documentElement.clientWidth || 0;
            if (layoutH > 0) {
              ev.data.data.height = Math.round(layoutH);
              ev.data.data.width = Math.round(layoutW);
              ev.data.data.isMobile = true;
            }
          }
        } catch (_) {}
        return listener.call(this, ev);
      };
      return nativeAdd.call(this, type, wrapped, options);
    };
  }
  installResizeMessageGuard();

  var SUPPORT_PREFIX = ${JSON.stringify(supportPrefix)};
  var HUMAN_AUTHOR = ${JSON.stringify(humanAuthor)};
  var CHAT_BRAND = ${JSON.stringify(chatBrand)};
  var sessionId = localStorage.getItem('mp_support_session') || '';
  var conversationId = localStorage.getItem('mp_conversation_id') || '';
  var pushSource = null;
  var syncChain = Promise.resolve();
  var chatTyping = false;

  function getChatStore(){
    return window.__mpStores && window.__mpStores.U;
  }

  function rewriteBrandInText(value){
    var text = String(value || '');
    if (!text) return text;
    return text
      .replace(/asystent\\s*morele\\.net/ig, CHAT_BRAND)
      .replace(/\\bmorele\\.net\\b/ig, CHAT_BRAND);
  }

  function rewriteHeaderValue(value){
    if (typeof value === 'string') return rewriteBrandInText(value);
    if (!value || typeof value !== 'object') return value;
    if (Array.isArray(value)) {
      return value.map(function(item){ return rewriteHeaderValue(item); });
    }
    var copy = {};
    for (var key in value) {
      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
      copy[key] = rewriteHeaderValue(value[key]);
    }
    return copy;
  }

  function normalizeHeader(header){
    return rewriteHeaderValue(header);
  }

  function normalizeConversationHeader(data){
    if (!data || typeof data !== 'object') return data;
    if (data.header !== undefined) data.header = normalizeHeader(data.header);
    return data;
  }

  function forceBrandInStoreHeader(){
    var U = getChatStore();
    if (!U) return false;
    var state = U.getState();
    if (!state) return false;
    var currentHeader = state.header;
    var brandedHeader = normalizeHeader(currentHeader);
    var oldSerialized = JSON.stringify(currentHeader || null);
    var nextSerialized = JSON.stringify(brandedHeader || null);
    if (oldSerialized === nextSerialized) return false;
    U.setState(Object.assign({}, state, { header: brandedHeader }));
    return true;
  }

  function isTextInput(el){
    if (!el || !el.tagName) return false;
    var tag = String(el.tagName).toLowerCase();
    if (tag === 'textarea') return true;
    if (tag !== 'input') return false;
    var type = String(el.type || '').toLowerCase();
    return !type || /^(text|search|email|tel|url|password|number)$/.test(type);
  }

  function setChatTyping(active){
    chatTyping = !!active;
    try {
      if (window.parent && window.parent !== window) {
        window.parent.postMessage({ type: 'mp_chat_typing', active: chatTyping }, '*');
      }
    } catch (_) {}
  }

  function installChatViewportStabilizer(){
    if (window.__mpChatViewportFixed) return;
    window.__mpChatViewportFixed = true;

    var viewportMeta = document.querySelector('meta[name="viewport"]');
    if (viewportMeta && viewportMeta.content.indexOf('interactive-widget') < 0) {
      viewportMeta.content += ', interactive-widget=overlays-content';
    }

    var style = document.createElement('style');
    style.setAttribute('data-mp-chat-mobile-fix', '5');
    style.textContent = ''
      + 'html,body,#root{height:100%!important;max-height:100dvh!important;margin:0!important;}'
      + '#root{display:flex!important;flex-direction:column!important;overflow:hidden!important;min-height:0!important;}'
      + 'textarea,input[type="text"],input[type="search"],input[type="email"],input[type="tel"],input[type="url"],input[type="password"],input[type="number"],[contenteditable="true"]{font-size:16px!important;}'
      + 'footer,[class*="Footer"],[class*="footer"],[data-testid*="footer" i]{flex-shrink:0!important;visibility:visible!important;opacity:1!important;max-height:none!important;}';
    (document.head || document.documentElement).appendChild(style);

    document.addEventListener('focusin', function(event){
      if (isTextInput(event.target)) setChatTyping(true);
    }, true);
    document.addEventListener('focusout', function(){
      var delay = isLikelyMobile() ? 900 : 200;
      setTimeout(function(){
        if (!isTextInput(document.activeElement)) setChatTyping(false);
      }, delay);
    }, true);
  }

  function ensureSession(){
    return fetch(SUPPORT_PREFIX + '/session', {
      method:'POST',
      headers:{'Content-Type':'application/json'},
      credentials:'same-origin',
      body:JSON.stringify({pageUrl: location.href, sessionId: sessionId || undefined})
    }).then(function(r){ return r.json(); }).then(function(res){
      sessionId = res.sessionId || sessionId || '';
      if (sessionId) localStorage.setItem('mp_support_session', sessionId);
      return sessionId;
    });
  }

  function isAllowedIncoming(m){
    return m && m.direction === 'incoming' && m.writtenBy === HUMAN_AUTHOR;
  }

  function sanitizeMessages(messages){
    if (!Array.isArray(messages)) return [];
    return messages.filter(function(m){
      if (!m) return false;
      if (m.direction === 'outgoing') return true;
      return isAllowedIncoming(m);
    });
  }

  function filterConversationPayload(data, reqBody){
    try {
      if (!data || !data.chat || !Array.isArray(data.chat.messages)) return data;
      normalizeConversationHeader(data);
      var body = reqBody ? JSON.parse(reqBody) : null;
      var action = body && body.action && body.action.name;
      data.chat.messages = sanitizeMessages(data.chat.messages);
      if (action === 'mp_operator_sync' || action === 'start_conversation') return data;
      var hasHuman = data.chat.messages.some(function(m){ return isAllowedIncoming(m); });
      if (!hasHuman && data.chat.messages.some(function(m){ return m.direction === 'outgoing'; })) {
        data.chat.messages.push({
          type:'text', content:'Dziękujemy za wiadomość. Konsultant odpowie najszybciej, jak to możliwe.',
          direction:'incoming', writtenBy: HUMAN_AUTHOR
        });
      }
    } catch (_) {}
    return data;
  }

  function rememberConversation(data){
    if (data && data.conversationId) {
      conversationId = data.conversationId;
      localStorage.setItem('mp_conversation_id', conversationId);
    }
  }

  function messageKey(m){
    return String(m.id || '') || (String(m.direction || '') + '|' + String(m.content || ''));
  }

  function normalizeIncoming(m){
    if (!m || m.direction !== 'incoming' || m.writtenBy !== HUMAN_AUTHOR) return null;
    var copy = {
      type: m.type || 'text',
      content: m.content,
      direction: m.direction,
      writtenBy: m.writtenBy,
      id: m.id,
      writtenAt: m.writtenAt || new Date().toISOString()
    };
    return copy;
  }

  function appendHumanMessages(data){
    if (!data || !data.chat || !Array.isArray(data.chat.messages)) return false;
    var U = getChatStore();
    if (!U) return false;
    var state = U.getState();
    if (!state || !state.chat) return false;
    if (!state.footer) return false;

    var current = Array.isArray(state.chat.messages) ? state.chat.messages.slice() : [];
    var keys = {};
    current.forEach(function(m){ keys[messageKey(m)] = true; });
    var added = [];
    sanitizeMessages(data.chat.messages).forEach(function(m){
      var incoming = normalizeIncoming(m);
      if (!incoming) return;
      var key = messageKey(incoming);
      if (keys[key]) return;
      keys[key] = true;
      added.push(incoming);
    });
    if (!added.length) return false;

    var merged = sanitizeMessages(current.concat(added));
    var actions = Array.isArray(state.chat.actions) ? state.chat.actions.slice() : [];
    if (!chatTyping) {
      for (var i = merged.length - 1; i >= 0; i--) {
        if (merged[i].direction === 'incoming' && merged[i].writtenBy === HUMAN_AUTHOR) {
          merged[i] = Object.assign({}, merged[i], { scrollTo: true });
          break;
        }
      }
    }

    U.setState({
      meta: state.meta,
      header: state.header,
      footer: state.footer,
      chat: Object.assign({}, state.chat, {
        messages: merged,
        all: merged.concat(actions),
        actions: actions
      }),
      loadingMessage: state.loadingMessage,
      loadingWidget: state.loadingWidget,
      loadingMessageToken: state.loadingMessageToken,
      activeMessageRequest: state.activeMessageRequest,
      sessionExpiredNoticeAt: state.sessionExpiredNoticeAt
    });
    return true;
  }

  function pullViaChatSync(){
    if (!sessionId) return Promise.resolve(false);
    var url = SUPPORT_PREFIX + '/chat-sync?session=' + encodeURIComponent(sessionId) + '&_=' + Date.now();
    return fetch(url, { credentials:'same-origin', cache:'no-store' })
      .then(function(r){ return r.json(); })
      .then(function(res){
        if (!res || !res.chat) return false;
        return appendHumanMessages(res);
      })
      .catch(function(){ return false; });
  }

  function syncChatFromServer(){
    if (!sessionId || chatTyping) return Promise.resolve(false);
    syncChain = syncChain
      .then(function(){ return pullViaChatSync(); })
      .catch(function(){ return false; });
    return syncChain;
  }

  function connectPush(){
    if (!sessionId || !window.EventSource) return;
    if (pushSource) {
      try { pushSource.close(); } catch (_) {}
      pushSource = null;
    }
    var url = SUPPORT_PREFIX + '/events?session=' + encodeURIComponent(sessionId);
    pushSource = new EventSource(url);
    pushSource.onmessage = function(event){
      try {
        var payload = event && event.data ? JSON.parse(event.data) : null;
        if (payload && payload.chat && appendHumanMessages(payload)) return;
      } catch (_) {}
      if (!chatTyping) syncChatFromServer();
    };
    pushSource.onerror = function(){
      try { pushSource.close(); } catch (_) {}
      pushSource = null;
      setTimeout(connectPush, 2500);
    };
  }

  var origFetch = window.fetch && window.fetch.bind(window);
  if (origFetch) {
    window.fetch = function(input, init){
      var reqUrl = typeof input === 'string' ? input : input && input.url;
      var reqBody = init && init.body;
      return origFetch(input, init).then(function(res){
        if (!res || !res.ok || !reqUrl || reqUrl.indexOf('/api/v1/conversation') < 0) return res;
        var sid = res.headers.get('X-Support-Session-Id');
        if (sid) { sessionId = sid; localStorage.setItem('mp_support_session', sid); }
        var action = '';
        try { action = reqBody ? JSON.parse(reqBody).action.name : ''; } catch (_) {}
        if (action === 'start_conversation' || action === 'end_conversation' || action === 'close_conversation' || action === 'minimize' || action === 'expand') {
          return res.clone().json().then(function(data){
            rememberConversation(data);
            if (action === 'start_conversation') {
              data = filterConversationPayload(data, reqBody);
              return new Response(JSON.stringify(data), {
                status: res.status,
                statusText: res.statusText,
                headers: {'Content-Type': 'application/json'}
              });
            }
            return res;
          }).catch(function(){ return res; });
        }
        return res.clone().json().then(function(data){
          if (action === 'mp_operator_sync') {
            rememberConversation(data);
            data = filterConversationPayload(data, reqBody);
            appendHumanMessages(data);
            return new Response(JSON.stringify(data), {
              status: res.status,
              statusText: res.statusText,
              headers: {'Content-Type': 'application/json'}
            });
          }
          data = filterConversationPayload(data, reqBody);
          rememberConversation(data);
          if (!chatTyping) setTimeout(syncChatFromServer, 8000);
          return new Response(JSON.stringify(data), {
            status: res.status,
            statusText: res.statusText,
            headers: {'Content-Type': 'application/json'}
          });
        }).catch(function(){ return res; });
      });
    };
  }

  function waitForStore(cb){
    var tries = 0;
    var timer = setInterval(function(){
      tries += 1;
      if (getChatStore() || tries > 40) {
        clearInterval(timer);
        cb();
      }
    }, 250);
  }

  window.__mpChatBridge = {
    refresh: syncChatFromServer,
    append: appendHumanMessages,
    setTyping: setChatTyping,
  };

  waitForStore(function(){
    installChatViewportStabilizer();
    forceBrandInStoreHeader();
    ensureSession().finally(function(){
      syncChatFromServer().finally(function(){
        connectPush();
        setInterval(function(){
          if (!chatTyping) syncChatFromServer();
        }, 12000);
      });
    });
  });
})();
</script>`;
}
