/**
 * Flow Tracking CDN v2 — loader
 * SessionID · visita · URL params · cliques · tracker.js
 */
(async function () {
  'use strict';

  // ===========================================================================
  // CONFIG
  // ===========================================================================

  const script = document.currentScript;
  if (!script) return;

  const trackId = script.dataset.track || script.dataset.trackId;
  const apiBase =
    script.dataset.apiBase ||
    script.dataset.endpoint ||
    window.FLOW_TRACKING_API_URL ||
    'https://api.flowtrackingtool.com';
  const cdnBase =
    script.dataset.cdnBase ||
    window.FLOW_TRACKING_CDN_URL ||
    'https://flow-tracking-cdn-production.up.railway.app';
  const forceSelf = script.dataset.forceSelf !== 'false' && script.dataset.forceSelf !== '0';

  // ===========================================================================
  // LOGGING — ftLog(TAG, level, ...args)
  // Debug: data-debug="true" no <script> OU localStorage.flowtracking_debug = '1'
  // Tags: CONFIG | INIT | SESSION | ATTRIBUTION | URL | NAV | API | TRACKER | PLATFORM
  // ===========================================================================

  const K_DEBUG = 'flowtracking_debug';
  const debug =
    script.dataset.debug === 'true' ||
    script.dataset.debug === '1' ||
    (function () {
      try {
        const v = localStorage.getItem(K_DEBUG);
        return v === '1' || v === 'true';
      } catch (_) {
        return false;
      }
    })();

  function ftLog(tag, level, a, b, c) {
    if (!debug && level !== 'error') return;
    const prefix = '[FlowTracking][' + tag + ']';
    const args = [prefix, a, b, c].filter(function (x) { return x !== undefined; });
    if (level === 'warn') console.warn.apply(console, args);
    else if (level === 'error') console.error.apply(console, args);
    else console.log.apply(console, args);
  }

  if (!trackId) {
    ftLog('CONFIG', 'warn', 'track ID missing');
    return;
  }

  // ===========================================================================
  // CONSTANTS
  // ===========================================================================

  const K_CLICK = 'flow_click_data';
  const K_PARAMS = 'flowtracking_urlParams';
  const K_SID = 'flowtrk_session_id';
  const FT_PREFIX = 'ftsession_';
  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  const BOT_RE = /googlebot|adsbot|bingbot|facebookexternalhit|facebot|yandexbot|duckduckbot|baiduspider|twitterbot|linkedinbot|whatsapp|telegrambot|mj12bot|ahrefsbot/i;
  const MERGE_KEYS = [
    'gclid', 'gbraid', 'wbraid', 'gad_campaignid', 'gad_source',
    'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'utm_id',
    'network', 'device', 'ftgid',
  ];

  const platformMappings = {
    adcombo: {
      clickid: 'gclid',
      subacc: 'session_id',
      subacc2: 'session_id',
      subacc3: 'session_id',
      subacc4: 'session_id',
    },
    gurumedia: {
      sub2: 'gclid',
      sub1: 'session_id',
      sub3: 'session_id',
      sub4: 'session_id',
      sub5: 'session_id',
    },
    buygoods: {
      SUBID: 'session_id',
      SUBID2: 'gclid',
      SUBID3: 'session_id',
      SUBID4: 'session_id',
      SUBID5: 'session_id',
    },
    digistore24: {
      cid: 'gclid',
      sid1: 'session_id',
      sid3: 'session_id',
      sid4: 'session_id',
      sid2: 'session_id',
    },
    digistore: {
      cid: 'gclid',
      sid1: 'session_id',
      sid3: 'session_id',
      sid4: 'session_id',
      sid2: 'session_id',
    },
    cartpanda: {
      cid: 'gclid',
      subid1: 'session_id',
      track_id: 'session_id',
      subid5: 'session_id',
    },
    smartadv: {
      sub1: 'gclid',
      sub2: 'session_id',
      sub3: 'session_id',
      sub4: 'session_id',
      sub5: 'session_id',
    },
    maxweb: {
      subid: 'session_id',
      subid2: 'gclid',
      subid3: 'session_id',
      subid4: 'session_id',
      subid5: 'session_id',
    },
    clickbank: {
      extclid: 'session_id',
      aid: 'session_id',
      tid: 'session_id',
      aff_sub1: 'gclid',
      aff_sub2: 'session_id',
      aff_sub3: 'session_id',
      aff_sub4: 'session_id',
      aff_sub5: 'session_id',
    },
    monetizze: {
      src: 'gclid',
      utm_medium: 'session_id',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    eduzz: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    kiwify: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    perfectpay: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    braip: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    tmweb: {
      subid: 'gclid',
      subid2: 'session_id',
      subid3: 'session_id',
      subid4: 'session_id',
      subid5: 'session_id',
    },
    leadlovers: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    rd: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    activetrail: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    mailchimp: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    activecampaign: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    mautic: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    hubspot: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    getresponse: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    convertkit: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    aweber: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    maxbounty: {
      s2: 'gclid',
      s1: 'session_id',
    },
    mediascalers: {
      sub1: 'gclid',
      sub2: 'session_id',
      sub3: 'session_id',
      sub4: 'session_id',
      sub5: 'session_id',
    },
    profitpay: {
      utm_medium: 'gclid',
      utm_source: 'session_id',
      utm_campaign: 'session_id',
      utm_content: 'session_id',
      utm_term: 'session_id',
    },
    drcash: {
      sub2: 'gclid',
      sub1: 'session_id',
      sub3: 'session_id',
      sub4: 'session_id',
      sub5: 'session_id',
    },
    // Webvork ecoa via utm_* no postback (doc oficial 3.1/3.3). O template Flow entrega o eco
    // em subid2 = {utm_medium} e subid3 = {utm_term}. utm_source é o ID do stream (Webvork
    // sobrescreve), então não é usado. utm_medium = gclid: com gclid real vai o gclid; sem gclid,
    // o applyPlatformParams cai pro session_id (ftsession_...) e o backend casa por ft_sid,
    // recuperando o gclid da visita. utm_term carrega a jornada como canal redundante.
    webvork: {
      utm_medium: 'gclid',
      utm_term: 'session_id',
    },
    default: {
      subid: 'gclid',
      subid2: 'session_id',
      subid3: 'session_id',
      subid4: 'session_id',
      subid5: 'session_id',
    },
  };

  // ===========================================================================
  // STATE
  // ===========================================================================

  let canSendEvents = !BOT_RE.test(navigator.userAgent || '');
  let platformSlug = 'default';
  let sessionIdCache = null;
  let clickDataCache = null;
  let urlParamsCache = null;
  let gclidCache = null;
  let gclidCacheReady = false;

  const pageQs = new URLSearchParams(location.search);

  // ===========================================================================
  // STORAGE
  // ===========================================================================

  function ssGet(k) { try { return sessionStorage.getItem(k); } catch (_) { return null; } }
  function ssSet(k, v) { try { sessionStorage.setItem(k, v); } catch (_) {} }
  function lsGet(k) { try { return localStorage.getItem(k); } catch (_) { return null; } }
  function lsSet(k, v) { try { localStorage.setItem(k, v); } catch (_) {} }

  // ===========================================================================
  // SESSION (ID global da jornada)
  // ===========================================================================

  function uuid() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
      const r = (Math.random() * 16) | 0;
      return (c === 'x' ? r : (r & 3) | 8).toString(16);
    });
  }

  function parseWindowName(raw) {
    if (!raw) return null;
    const n = String(raw).trim();
    if (n.indexOf(FT_PREFIX) === 0) {
      const id = n.slice(FT_PREFIX.length);
      return UUID_RE.test(id) ? id : null;
    }
    const sep = '_session_';
    if (n.indexOf('track_') === 0 && n.indexOf(sep) !== -1) {
      const id = n.slice(n.indexOf(sep) + sep.length);
      return UUID_RE.test(id) ? id : null;
    }
    return null;
  }

  function syncWindowName(sid) {
    if (!sid || !UUID_RE.test(sid)) return null;
    const built = FT_PREFIX + sid;
    try { window.name = built; } catch (_) {}
    return built;
  }

  function ensureSessionId() {
    if (sessionIdCache) return sessionIdCache;
    try {
      const fromUrl = pageQs.get('ft_sid');
      if (fromUrl && UUID_RE.test(fromUrl)) {
        sessionIdCache = fromUrl;
        ssSet(K_SID, fromUrl);
        lsSet(K_SID, fromUrl);
        syncWindowName(fromUrl);
        ftLog('SESSION', 'log', 'from URL ft_sid', fromUrl);
        return fromUrl;
      }
      let sid = ssGet(K_SID) || lsGet(K_SID) || parseWindowName(window.name);
      if (!sid) {
        sid = uuid();
        ssSet(K_SID, sid);
        lsSet(K_SID, sid);
        ftLog('SESSION', 'log', 'new session', sid);
      } else {
        ftLog('SESSION', 'log', 'restored', sid);
      }
      sessionIdCache = sid;
      syncWindowName(sid);
      return sid;
    } catch (e) {
      ftLog('SESSION', 'error', 'ensureSessionId failed', e);
      return null;
    }
  }

  function sessionParam() {
    const sid = ensureSessionId();
    return sid ? FT_PREFIX + sid : null;
  }

  function publishSessionGlobals(sid) {
    if (!sid) return;
    window.FlowSessionId = sid;
    window.flowtrk_session_id = sid;
    window.FlowSessionParam = FT_PREFIX + sid;
  }

  function broadcastSessionToFrames() {
    var sid = ensureSessionId();
    var wn = syncWindowName(sid);
    if (!sid || !wn) return;
    var msg = { type: 'flow:session', ft_sid: sid, window_name: wn };
    try {
      for (var i = 0; i < window.frames.length; i++) {
        try {
          window.frames[i].postMessage(msg, '*');
        } catch (_) {}
      }
    } catch (_) {}
  }

  function replySessionPostMessage(event) {
    var data = event.data;
    if (!data || data.type !== 'flow:request-session') return;
    try {
      if (!event.source || event.source === window) return;
      var sid = ensureSessionId();
      var wn = syncWindowName(sid);
      event.source.postMessage(
        { type: 'flow:session', ft_sid: sid, window_name: wn },
        event.origin || '*'
      );
      ftLog('SESSION', 'log', 'postMessage → iframe', { origin: event.origin, ft_sid: sid, window_name: wn });
    } catch (e) {
      ftLog('SESSION', 'warn', 'postMessage reply failed', e);
    }
  }

  // ===========================================================================
  // ATTRIBUTION (primeiro toque)
  // ===========================================================================

  /** Macros do Google Ads na URL final ({gclid}, {keyword}, …) — não são click IDs reais. */
  var ADS_MACRO_RE = /^\{[^}]+\}$/;

  function isAdsMacro(value) {
    if (value == null || value === '') return false;
    return ADS_MACRO_RE.test(String(value).trim());
  }

  function sanitizeClickParam(value) {
    if (value == null || value === '') return null;
    var s = String(value).trim();
    if (!s || isAdsMacro(s)) return null;
    return s;
  }

  function extractGclidFromFtgid(raw) {
    if (!raw || typeof raw !== 'string') return null;
    const s = raw.trim();
    if (s.indexOf('ftgid_') !== 0 || s.slice(-6) !== '_ftgid') return null;
    const inner = s.slice(6, -6).trim();
    return sanitizeClickParam(inner);
  }

  function sanitizeFtgidParam(value) {
    if (value == null || value === '') return null;
    var s = String(value).trim();
    if (!s || isAdsMacro(s)) return null;
    if (s.indexOf('ftgid_') === 0 && s.slice(-6) === '_ftgid' && !extractGclidFromFtgid(s)) {
      return null;
    }
    return s;
  }

  function pickUrlParam(key) {
    return sanitizeClickParam(pageQs.get(key));
  }

  function readClickData() {
    if (clickDataCache) return clickDataCache;
    try {
      const raw = ssGet(K_CLICK) || lsGet(K_CLICK);
      clickDataCache = raw ? JSON.parse(raw) : null;
      return clickDataCache;
    } catch (_) {
      return null;
    }
  }

  function writeClickData(data) {
    clickDataCache = data;
    gclidCacheReady = false;
    const s = JSON.stringify(data);
    ssSet(K_CLICK, s);
    lsSet(K_CLICK, s);
  }

  function readUrlParamsSnapshot() {
    if (urlParamsCache) return urlParamsCache;
    try {
      const raw = ssGet(K_PARAMS) || lsGet(K_PARAMS);
      urlParamsCache = raw ? JSON.parse(raw) : {};
      return urlParamsCache;
    } catch (_) {
      urlParamsCache = {};
      return urlParamsCache;
    }
  }

  function persistUrlParams(qs) {
    if (!qs || !qs.toString()) return;
    try {
      const o = {};
      qs.forEach(function (v, k) { o[k] = v; });
      urlParamsCache = o;
      const s = JSON.stringify(o);
      ssSet(K_PARAMS, s);
      lsSet(K_PARAMS, s);
    } catch (e) {
      ftLog('ATTRIBUTION', 'warn', 'persistUrlParams failed', e);
    }
  }

  function captureFirstTouch() {
    if (pageQs.toString()) persistUrlParams(pageQs);

    const ftgidRaw = pageQs.get('ftgid');
    const ftgid = sanitizeFtgidParam(ftgidRaw);
    const gclid = extractGclidFromFtgid(ftgidRaw) || pickUrlParam('gclid');
    const gbraid = pickUrlParam('gbraid');
    const wbraid = pickUrlParam('wbraid');
    const hasAds =
      gclid || gbraid || wbraid ||
      MERGE_KEYS.some(function (k) {
        if (k === 'gclid' || k === 'gbraid' || k === 'wbraid' || k === 'ftgid') return false;
        return !!pickUrlParam(k);
      });

    if (!hasAds) return;

    const prev = readClickData() || {};
    const merged = {
      gclid: gclid || sanitizeClickParam(prev.gclid) || null,
      gbraid: gbraid || sanitizeClickParam(prev.gbraid) || null,
      wbraid: wbraid || sanitizeClickParam(prev.wbraid) || null,
      gad_campaignid: pickUrlParam('gad_campaignid') || sanitizeClickParam(prev.gad_campaignid) || null,
      gad_source: pickUrlParam('gad_source') || sanitizeClickParam(prev.gad_source) || null,
      utm_source: pickUrlParam('utm_source') || sanitizeClickParam(prev.utm_source) || null,
      utm_medium: pickUrlParam('utm_medium') || sanitizeClickParam(prev.utm_medium) || null,
      utm_campaign: pickUrlParam('utm_campaign') || sanitizeClickParam(prev.utm_campaign) || null,
      utm_term: pickUrlParam('utm_term') || sanitizeClickParam(prev.utm_term) || null,
      utm_content: pickUrlParam('utm_content') || sanitizeClickParam(prev.utm_content) || null,
      utm_id: pickUrlParam('utm_id') || sanitizeClickParam(prev.utm_id) || null,
      network: pickUrlParam('network') || sanitizeClickParam(prev.network) || null,
      device: pickUrlParam('device') || sanitizeClickParam(prev.device) || null,
      ftgid: ftgid || sanitizeFtgidParam(prev.ftgid) || null,
      first_seen_at: prev.first_seen_at || new Date().toISOString(),
    };
    writeClickData(merged);
    ftLog('ATTRIBUTION', 'log', 'first touch saved', merged);
  }

  function getGclidValue() {
    if (gclidCacheReady) return gclidCache;
    const fromFt = extractGclidFromFtgid(pageQs.get('ftgid'));
    if (fromFt) { gclidCache = fromFt; gclidCacheReady = true; return fromFt; }
    const fromUrl = pickUrlParam('gclid');
    if (fromUrl) { gclidCache = fromUrl; gclidCacheReady = true; return fromUrl; }
    const d = readClickData();
    gclidCache =
      sanitizeClickParam(d && d.gclid) ||
      sanitizeClickParam(d && d.wbraid) ||
      sanitizeClickParam(d && d.gbraid) ||
      null;
    gclidCacheReady = true;
    return gclidCache;
  }

  // ===========================================================================
  // URL ENRICHMENT
  // ===========================================================================

  function parseNavUrl(url) {
    try {
      const u = new URL(url, location.origin);
      if (u.protocol !== 'http:' && u.protocol !== 'https:') return null;
      return u;
    } catch (_) {
      return null;
    }
  }

  function ensureFtSidInUrl(urlObj) {
    if (!urlObj.searchParams.get('ft_sid')) {
      const sid = ensureSessionId();
      if (sid) urlObj.searchParams.set('ft_sid', sid);
    }
    return urlObj.toString();
  }

  function mergeSameOrigin(url) {
    const u = parseNavUrl(url);
    if (!u) return url;

    const click = readClickData();
    if (click) {
      MERGE_KEYS.forEach(function (k) {
        const v = sanitizeClickParam(click[k]);
        if (v && !u.searchParams.has(k)) u.searchParams.set(k, String(v));
      });
    }
    const snap = readUrlParamsSnapshot();
    Object.keys(snap).forEach(function (k) {
      const val = sanitizeClickParam(snap[k]);
      if (val != null && val !== '' && !u.searchParams.has(k)) {
        u.searchParams.set(k, String(val));
      }
    });
    return ensureFtSidInUrl(u);
  }

  function applyPlatformParams(url, platform) {
    const u = parseNavUrl(url);
    if (!u) return url;

    const mapping = platformMappings[platform] || platformMappings.default;
    const gclid = getGclidValue();
    const sess = sessionParam();

    ftLog('PLATFORM', 'log', 'apply', platform, mapping);

    Object.keys(mapping).forEach(function (param) {
      const source = mapping[param];
      if (source === 'gclid') {
        // Sem gclid real (macro ou ausente) → usa sessionId no slot de afiliado
        const val = gclid || sess;
        if (val) u.searchParams.set(param, val);
      } else if (source === 'session_id' && sess) {
        u.searchParams.set(param, sess);
      }
    });

    const out = ensureFtSidInUrl(u);
    ftLog('URL', 'log', 'platform enriched', out);
    return out;
  }

  function enrichUrl(url) {
    const u = parseNavUrl(url);
    if (!u) return url;
    if (u.hostname !== location.hostname) return applyPlatformParams(url, platformSlug);
    return mergeSameOrigin(url);
  }

  function resolveHref(el) {
    const raw =
      el.getAttribute('href') ||
      el.getAttribute('data-href') ||
      el.getAttribute('data-url') ||
      el.getAttribute('data-flow-url');
    if (!raw) return el.tagName === 'A' && el.href ? el.href : null;
    if (raw.indexOf('&amp;') !== -1) {
      const t = document.createElement('textarea');
      t.innerHTML = raw;
      return t.value;
    }
    return raw;
  }

  function navigate(href, target) {
    if (target === '_blank') window.open(href, '_blank');
    else location.href = href;
  }

  // ===========================================================================
  // API
  // ===========================================================================

  async function postEvent(eventType, data) {
    if (!canSendEvents) {
      ftLog('API', 'log', 'suppressed', eventType);
      return null;
    }
    const url = apiBase + '/api/tracks/' + trackId + '/events';
    const body = JSON.stringify({
      eventType: eventType,
      trackerId: trackId,
      timestamp: new Date().toISOString(),
      data: data,
    });
    try {
      ftLog('API', 'log', 'POST', eventType);
      const res = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: body,
        keepalive: true,
        credentials: 'omit',
        mode: 'cors',
      });
      if (!res.ok) {
        ftLog('API', 'warn', 'HTTP ' + res.status, eventType);
        return null;
      }
      const json = await res.json();
      ftLog('API', 'log', 'OK', eventType, json);
      return json;
    } catch (e) {
      ftLog('API', 'error', eventType, e);
      return null;
    }
  }

  async function registerVisit() {
    const sid = ensureSessionId();
    const click = readClickData() || {};
    const gclid = getGclidValue();

    return postEvent('visit_registration', {
      url: location.href,
      referrer: document.referrer || null,
      userAgent: navigator.userAgent,
      ft_sid: sid,
      session_id: sid,
      window_name: syncWindowName(sid) || undefined,
      gclid: gclid,
      gbraid: sanitizeClickParam(click.gbraid || pageQs.get('gbraid')) || null,
      wbraid: sanitizeClickParam(click.wbraid || pageQs.get('wbraid')) || null,
      gad_campaignid: sanitizeClickParam(click.gad_campaignid || pageQs.get('gad_campaignid')) || null,
      gad_source: sanitizeClickParam(click.gad_source || pageQs.get('gad_source')) || null,
      utm_source: sanitizeClickParam(click.utm_source || pageQs.get('utm_source')) || null,
      utm_medium: sanitizeClickParam(click.utm_medium || pageQs.get('utm_medium')) || null,
      utm_campaign: sanitizeClickParam(click.utm_campaign || pageQs.get('utm_campaign')) || null,
      utm_term: sanitizeClickParam(click.utm_term || pageQs.get('utm_term')) || null,
      utm_content: sanitizeClickParam(click.utm_content || pageQs.get('utm_content')) || null,
      utm_id: sanitizeClickParam(click.utm_id || pageQs.get('utm_id')) || null,
      network: sanitizeClickParam(click.network || pageQs.get('network')) || null,
      device: sanitizeClickParam(click.device || pageQs.get('device')) || null,
      ftgid: sanitizeFtgidParam(click.ftgid || pageQs.get('ftgid')) || null,
      quantidade_visita: 1,
      pixel: 'auto',
    });
  }

  async function fetchTrackInfo() {
    try {
      const res = await fetch(apiBase + '/api/tracks/' + trackId + '/info', {
        mode: 'cors',
        credentials: 'omit',
      });
      if (!res.ok) return null;
      return res.json();
    } catch (e) {
      ftLog('API', 'warn', 'fetchTrackInfo failed', e);
      return null;
    }
  }

  async function validateDomain() {
    try {
      const res = await fetch(apiBase + '/api/tracks/' + trackId + '/validate-domain', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ domain: location.hostname }),
        mode: 'cors',
        credentials: 'omit',
      });
      const data = await res.json();
      return !data.error;
    } catch (e) {
      ftLog('API', 'warn', 'validateDomain failed — fail open', e);
      return true;
    }
  }

  // ===========================================================================
  // TRACKER
  // ===========================================================================

  function loadTracker() {
    return new Promise(function (resolve, reject) {
      const el = document.createElement('script');
      el.src = cdnBase + '/v2/tracker.js?v=2.6.0';
      el.async = true;
      el.onload = function () {
        ftLog('TRACKER', 'log', 'loaded');
        resolve();
      };
      el.onerror = function () {
        ftLog('TRACKER', 'error', 'load failed');
        reject(new Error('tracker load failed'));
      };
      document.head.appendChild(el);
    });
  }

  function initTracker() {
    if (typeof window.FlowTracking !== 'object') {
      ftLog('TRACKER', 'warn', 'FlowTracking not available');
      return;
    }
    window.FlowTrackingConfig = {
      appId: trackId,
      debug: debug,
      apiBase: apiBase,
      scrollConfig: {
        milestones: [10, 25, 50, 75, 90, 100],
        debounceMs: 100,
        throttleMs: 16,
        debug: debug,
      },
    };
    try {
      window.FlowTracking.init(window.FlowTrackingConfig);
      ftLog('TRACKER', 'log', 'initialized');
    } catch (e) {
      ftLog('TRACKER', 'error', 'init failed', e);
    }
  }

  // ===========================================================================
  // PLATFORM DETECTION
  // ===========================================================================

  function detectPlatformLocal() {
    const h = location.hostname.toLowerCase();
    if (h.indexOf('buygoods') !== -1) return 'buygoods';
    if (h.indexOf('clickbank') !== -1) return 'clickbank';
    if (h.indexOf('digistore') !== -1) return 'digistore24';
    if (h.indexOf('gurumedia') !== -1) return 'gurumedia';
    if (h.indexOf('maxweb') !== -1 || h.indexOf('mwebzova') !== -1) return 'maxweb';
    if (h.indexOf('cartpanda') !== -1) return 'cartpanda';
    if (h.indexOf('smartadv') !== -1) return 'smartadv';
    if (h.indexOf('drcash') !== -1) return 'drcash';
    if (h.indexOf('monetizze') !== -1) return 'monetizze';
    if (h.indexOf('eduzz') !== -1) return 'eduzz';
    if (h.indexOf('kiwify') !== -1) return 'kiwify';
    if (h.indexOf('webvork') !== -1) return 'webvork';
    return 'default';
  }

  // ===========================================================================
  // NAVIGATION (cliques)
  // ===========================================================================

  function onClick(event) {
    if (event.defaultPrevented) return;
    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
    if (event.button !== 0) return;

    const el = event.target.closest && event.target.closest('a, button');
    if (!el || el.hasAttribute('download')) return;

    const raw = resolveHref(el);
    if (!raw || raw.charAt(0) === '#' || /^javascript:/i.test(raw)) return;
    if (/^mailto:/i.test(raw) || /^tel:/i.test(raw)) return;
    if (!parseNavUrl(raw)) return;

    const next = enrichUrl(raw);
    if (next === raw) return;

    event.preventDefault();
    event.stopPropagation();

    if (el.hasAttribute('href')) el.setAttribute('href', next);
    if (el.hasAttribute('data-href')) el.setAttribute('data-href', next);
    if (el.hasAttribute('data-url')) el.setAttribute('data-url', next);
    if (el.hasAttribute('data-flow-url')) el.setAttribute('data-flow-url', next);

    const target = forceSelf
      ? '_self'
      : (el.getAttribute('target') || el.getAttribute('data-target') || '_self');

    ftLog('NAV', 'log', raw, '→', next);
    navigate(next, target);
  }

  window.FlowTrackingNavigate = function (url, target) {
    if (!url || typeof url !== 'string') return;
    const next = enrichUrl(url);
    ftLog('NAV', 'log', 'FlowTrackingNavigate', next);
    navigate(next, target || '_self');
  };

  document.addEventListener('click', onClick, true);

  // ===========================================================================
  // PROGRAMMATIC NAVIGATION
  // Captura redirects que NÃO passam por <a href> nem por FlowTrackingNavigate:
  //   - window.location.href = '...'  (via Navigation API)
  //   - location.assign/replace       (via Navigation API)
  //   - window.open(...)              (wrap direto)
  //   - history.pushState/replaceState (wrap direto)
  //   - submit de <form>             (listener capture)
  // ===========================================================================

  let ftNavLock = false;   // evita reentrância quando re-navegamos
  let ftExitSent = false;  // exit_click é disparado no máximo 1x por página

  function isExternalUrl(u) {
    return !!(u && u.hostname && u.hostname !== location.hostname);
  }

  function fireExitClick(destUrl) {
    if (ftExitSent || !canSendEvents) return;
    const u = parseNavUrl(destUrl);
    if (!isExternalUrl(u)) return; // só registra saída quando troca de domínio
    ftExitSent = true;
    const sid = ensureSessionId();
    ftLog('NAV', 'log', 'exit_click', u.toString());
    // postEvent usa fetch keepalive — sobrevive ao unload da navegação seguinte
    postEvent('exit_click', {
      destination: u.toString(),
      from: location.href,
      ft_sid: sid,
      session_id: sid,
      gclid: getGclidValue(),
      platform: platformSlug,
    }).catch(function () {});
  }

  // --- Camada principal: Navigation API -------------------------------------
  // Intercepta SOMENTE navegações cross-host (saída do site) para não quebrar
  // roteamento same-origin / SPA. Pega `location.href = '...'`, que é
  // [LegacyUnforgeable] e não pode ser sobrescrito de outra forma.
  if (window.navigation && typeof window.navigation.addEventListener === 'function') {
    window.navigation.addEventListener('navigate', function (e) {
      try {
        if (ftNavLock) return;
        if (!e.cancelable) return;                  // traverse (voltar/avançar)
        if (e.navigationType === 'traverse') return;
        if (e.hashChange || e.downloadRequest !== null) return;
        if (e.formData) return;                     // forms tratados abaixo
        const dest = e.destination && e.destination.url;
        const u = parseNavUrl(dest);
        if (!u || !isExternalUrl(u)) return;        // só saídas cross-host

        const enriched = enrichUrl(dest);
        fireExitClick(enriched || dest);
        if (!enriched || enriched === dest) return; // já enriquecida → segue

        e.preventDefault();
        ftNavLock = true;
        ftLog('NAV', 'log', 'navigate intercept', dest, '→', enriched);
        location.href = enriched;
      } catch (err) {
        ftLog('NAV', 'warn', 'navigate handler failed — fail open', err);
      }
    });
    ftLog('NAV', 'log', 'Navigation API interception active');
  } else {
    ftLog('NAV', 'log', 'Navigation API unavailable — click fallback only');
  }

  // --- window.open (Navigation API não cobre novos contextos) ---------------
  if (typeof window.open === 'function') {
    const _ftOpen = window.open;
    window.open = function (url, name, features) {
      try {
        if (url) {
          const enriched = enrichUrl(String(url));
          fireExitClick(enriched);
          url = enriched;
        }
      } catch (_) {}
      return _ftOpen.call(window, url, name, features);
    };
  }

  // --- history.pushState / replaceState (mantém params em SPA same-origin) ---
  ['pushState', 'replaceState'].forEach(function (method) {
    const orig = history[method];
    if (typeof orig !== 'function') return;
    history[method] = function (state, title, url) {
      try {
        if (url != null) url = enrichUrl(String(url));
      } catch (_) {}
      return orig.call(history, state, title, url);
    };
  });

  // --- Submit de <form> (enriquece o action; GET/POST cross-host) -----------
  document.addEventListener('submit', function (e) {
    try {
      const form = e.target;
      if (!form || form.tagName !== 'FORM') return;
      const action = form.getAttribute('action') || location.href;
      if (!parseNavUrl(action)) return;
      const enriched = enrichUrl(action);
      if (enriched && enriched !== action) {
        form.setAttribute('action', enriched);
        fireExitClick(enriched);
        ftLog('NAV', 'log', 'form action enriched', enriched);
      }
    } catch (_) {}
  }, true);

  // ===========================================================================
  // INIT
  // ===========================================================================

  async function init() {
    ftLog('INIT', 'log', 'start', { trackId: trackId, apiBase: apiBase, cdnBase: cdnBase });

    if (!canSendEvents) ftLog('INIT', 'log', 'bot detected — events off, enrich on');

    const [domainRes, infoRes, trackerRes] = await Promise.allSettled([
      validateDomain(),
      fetchTrackInfo(),
      loadTracker(),
    ]);

    if (domainRes.status === 'fulfilled' && domainRes.value === false) {
      canSendEvents = false;
      ftLog('INIT', 'warn', 'domain not allowed — events off');
    }

    const info = infoRes.status === 'fulfilled' ? infoRes.value : null;
    if (info && info.isActive === false) {
      canSendEvents = false;
      ftLog('INIT', 'warn', 'track inactive — events off');
    }

    platformSlug = (info && info.platformSlug) || detectPlatformLocal();
    ftLog('PLATFORM', 'log', 'detected', platformSlug);

    if (trackerRes.status === 'fulfilled') initTracker();

    if (canSendEvents) {
      registerVisit().catch(function (e) { ftLog('API', 'error', 'registerVisit', e); });
    }

    ftLog('INIT', 'log', 'ready', {
      sessionId: sessionIdCache,
      platform: platformSlug,
      canSendEvents: canSendEvents,
    });
  }

  // Boot imediato: sessão + atribuição antes do DOM
  publishSessionGlobals(ensureSessionId());
  captureFirstTouch();
  broadcastSessionToFrames();

  window.addEventListener('message', replySessionPostMessage);

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', function () {
      broadcastSessionToFrames();
    });
  } else {
    setTimeout(broadcastSessionToFrames, 0);
  }

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