/*
 * Replace the previous global Vimeo controller with this entire file.
 * Plain JavaScript: no <script> tags. Keep the Vimeo Player SDK loaded once.
 * For global cards, change iframe src to data-src IN THE ORIGINAL EMBED.
 * Add data-vimeo-global to those iframes. Preserve each video's URL/hash.
 * Sliders with their own controller: data-vimeo-controller="local".
 * Requires a real .image-b2b poster and a sized .image-and-video-wrap.
 */
(() => {
  "use strict";

  function init() {
    if (window.__takeoffVimeoGlobalV2) return;
    window.__takeoffVimeoGlobalV2 = true;

    const CARD = ".media-project-b2b";
    const SLIDER = ".slider-hero-wrapper";
    const FRAME = '.projects__video iframe[data-src*="player.vimeo.com"], .projects__video iframe[src*="player.vimeo.com"]';
    const states = new Map();
    const sliders = new Map();
    const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)");

    function bounded(promise, label, milliseconds = 15000) {
      return new Promise((resolve, reject) => {
        const timer = setTimeout(() => reject(new Error(label + " timed out")), milliseconds);
        Promise.resolve(promise).then(
          value => { clearTimeout(timer); resolve(value); },
          error => { clearTimeout(timer); reject(error); }
        );
      });
    }

    function localSlider(slider) {
      if (!slider) return false;
      const owner = slider.getAttribute("data-vimeo-controller");
      if (owner) return owner === "local";
      // Preserve the existing independently controlled deferred hero sliders.
      return !!slider.querySelector('iframe[data-src*="player.vimeo.com"]:not([data-vimeo-global])');
    }

    function eligible(s) {
      if (!s.card.isConnected || document.hidden || !s.inView) return false;
      const rect = s.media.getBoundingClientRect();
      if (!rect.width || !rect.height) return false;
      if (!s.slider) return true;
      const slider = sliders.get(s.slider);
      return !!slider && slider.enabled &&
        !!s.card.closest(".swiper-slide")?.classList.contains("swiper-slide-active");
    }

    function automaticAllowed(s) {
      return s.manual || !(reducedMotion.matches || navigator.connection?.saveData);
    }

    function cover(s, button = false) {
      s.frame.style.opacity = "0";
      if (s.image) {
        s.image.style.opacity = "1";
        s.image.style.visibility = "visible";
        s.image.style.pointerEvents = "none";
      }
      s.button.hidden = !button;
    }

    function reveal(s) {
      if (!s.wanted || !eligible(s) || s.failed) return;
      s.frame.style.opacity = "1";
      if (s.image) {
        s.image.style.opacity = "0";
        s.image.style.visibility = "hidden";
        s.image.style.pointerEvents = "none";
      }
      s.button.hidden = true;
    }

    function fail(s, error) {
      s.failed = true;
      clearTimeout(s.startTimer);
      cover(s, eligible(s));
      console.warn("[Takeoff Vimeo]", {
        name: error?.name || "PlayerError",
        message: error?.message || String(error),
        video: s.url
      });
    }

    function pauseExisting(s) {
      // Never create or seek a player merely to stop it.
      if (s.player && s.ready) s.player.pause().catch(() => {});
    }

    function ensurePlayer(s) {
      if (s.readyPromise) return s.readyPromise;
      if (!window.Vimeo?.Player) {
        return Promise.reject(new Error("Vimeo Player SDK is not loaded"));
      }
      if (s.player) {
        s.readyPromise = bounded(s.player.ready(), "Player initialization").then(() => {
          s.ready = true;
          return s.player;
        }).catch(error => {
          s.readyPromise = null;
          throw error;
        });
        return s.readyPromise;
      }

      const url = new URL(s.url, location.href);
      if (url.hostname !== "player.vimeo.com") {
        return Promise.reject(new Error("Invalid Vimeo embed URL"));
      }
      Object.entries({
        autoplay: "0", muted: "1", playsinline: "1", loop: "1",
        controls: "0", autopause: "0"
      }).forEach(([key, value]) => url.searchParams.set(key, value));

      // A background=1 parameter would override controlled startup.
      url.searchParams.delete("background");
      const permissions = new Set((s.frame.getAttribute("allow") || "")
        .split(";").map(value => value.trim()).filter(Boolean));
      ["autoplay", "fullscreen", "picture-in-picture", "encrypted-media"]
        .forEach(permission => permissions.add(permission));
      s.frame.setAttribute("allow", [...permissions].join("; "));
      s.frame.setAttribute("playsinline", "");
      s.frame.loading = "eager";
      if (!s.frame.title) s.frame.title = "Project video preview";
      if (s.frame.getAttribute("src") !== url.href) s.frame.src = url.href;

      s.player = new Vimeo.Player(s.frame);
      s.player.on("playing", () => {
        s.started = true;
        if (!s.wanted || !eligible(s) || s.failed) {
          pauseExisting(s);
          return;
        }
        // Wait for time progression before removing the cover.
      });
      s.player.on("timeupdate", event => {
        if (event.seconds > 0 && s.wanted && !s.failed) {
          clearTimeout(s.startTimer);
          reveal(s);
        }
      });
      s.player.on("error", error => {
        fail(s, error);
        pauseExisting(s);
      });

      s.readyPromise = bounded(s.player.ready(), "Player initialization").then(() => {
        s.ready = true;
        return s.player;
      }).catch(error => {
        s.readyPromise = null;
        throw error;
      });
      return s.readyPromise;
    }

    async function drain(s) {
      if (s.busy) return;
      s.busy = true;
      try {
        let seen;
        do {
          seen = s.version;
          try {
            if (s.wanted && !s.failed && eligible(s)) {
              if (!s.ready) await ensurePlayer(s);
              if (seen !== s.version || !s.wanted || !eligible(s) || s.failed) continue;

              clearTimeout(s.startTimer);
              s.startTimer = setTimeout(() => {
                if (s.wanted && eligible(s)) {
                  fail(s, new Error("No playback progress received"));
                  pauseExisting(s);
                }
              }, 15000);
              // When already ready, this runs directly in the button click stack.
              await bounded(s.player.play(), "Playback start");
            } else if (s.player && s.ready) {
              await bounded(s.player.pause(), "Playback pause");
              // Vimeo can START an unplayed video on setCurrentTime().
              if (s.reset && s.started && seen === s.version) {
                await bounded(s.player.setCurrentTime(0), "Playback reset");
                s.reset = false;
              }
            }
          } catch (error) {
            if (seen === s.version && s.wanted) fail(s, error);
          }
        } while (seen !== s.version);
      } finally {
        s.busy = false;
      }
    }

    function request(s, wanted, reset = true, force = false) {
      wanted = wanted && eligible(s);
      if (!force && s.wanted === wanted) return;
      s.wanted = wanted;
      s.reset = !wanted && reset;
      s.version++;
      if (!wanted) {
        clearTimeout(s.startTimer);
        cover(s);
        pauseExisting(s);
      }
      void drain(s);
    }

    function sync(s) {
      const visible = eligible(s);
      const wanted = visible && automaticAllowed(s);
      request(s, wanted);
      if (visible && (!automaticAllowed(s) || s.failed)) cover(s, true);
    }

    function syncSlider(slider) {
      states.forEach(s => { if (s.slider === slider) sync(s); });
    }

    function registerSlider(slider) {
      if (!slider || sliders.has(slider) || localSlider(slider)) return;
      const observer = new MutationObserver(() => syncSlider(slider));
      // Class changes identify active Swiper slides; animation styles are ignored.
      observer.observe(slider, {
        subtree: true, attributes: true, attributeFilter: ["class"]
      });
      sliders.set(slider, { enabled: true, observer });
    }

    const viewport = new IntersectionObserver(entries => {
      entries.forEach(entry => {
        const card = entry.target.closest(CARD);
        const s = states.get(card);
        if (!s) return;
        // Observe the MEDIA area, not a tall card including its text.
        s.inView = entry.isIntersecting && entry.intersectionRatio >= 0.01;
        sync(s);
      });
    }, { threshold: [0, 0.01, 0.1], rootMargin: "0px" });

    function bind(card) {
      if (states.has(card)) return;
      const slider = card.closest(SLIDER);
      if (localSlider(slider)) return;
      const frame = card.querySelector(FRAME);
      if (!frame) return;
      const url = frame.getAttribute("data-src") || frame.getAttribute("src");
      if (!url) return;

      registerSlider(slider);
      const media = card.querySelector(".image-and-video-wrap") || frame.parentElement;
      if (getComputedStyle(media).position === "static") media.style.position = "relative";
      frame.style.pointerEvents = "none";
      frame.style.transition = "none";
      const button = document.createElement("button");
      button.type = "button";
      button.className = "vimeo-fallback-button";
      button.textContent = "Play video";
      button.setAttribute("aria-label", "Play project video");
      button.hidden = true;
      button.style.cssText = "position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);z-index:10;min-height:44px;padding:12px 20px;border:1px solid #fff;border-radius:999px;background:#111;color:#fff;font:inherit;cursor:pointer;";
      media.appendChild(button);

      const s = {
        card, slider, frame, media, button, url,
        image: card.querySelector(".image-b2b"),
        player: null, readyPromise: null, ready: false,
        inView: false, wanted: false, busy: false, failed: false,
        started: false, manual: false, reset: false, version: 0, startTimer: null
      };
      states.set(card, s);
      cover(s);
      button.addEventListener("click", event => {
        event.preventDefault();
        event.stopPropagation();
        s.manual = true;
        s.failed = false;
        button.hidden = true;
        // No await before the playback request, preserving the user gesture.
        request(s, true, false, true);
      });
      viewport.observe(media);
    }

    function scan(scope = document) {
      if (scope.matches?.(CARD)) bind(scope);
      scope.querySelectorAll?.(CARD).forEach(bind);
      // Handle an iframe inserted into a card that was previously incomplete.
      const parentCard = scope.closest?.(CARD);
      if (parentCard) bind(parentCard);
    }

    scan();
    const additions = new MutationObserver(records => {
      records.forEach(record => record.addedNodes.forEach(node => {
        if (node instanceof Element) scan(node);
      }));
      states.forEach((s, card) => {
        if (card.isConnected) return;
        s.wanted = false;
        s.version++;
        clearTimeout(s.startTimer);
        viewport.unobserve(s.media);
        s.player?.destroy().catch(() => {});
        s.button.remove();
        states.delete(card);
      });
      sliders.forEach((state, slider) => {
        if (slider.isConnected) return;
        state.observer.disconnect();
        sliders.delete(slider);
      });
    });
    additions.observe(document.body, { childList: true, subtree: true });

    document.addEventListener("visibilitychange", () => states.forEach(sync));
    reducedMotion.addEventListener("change", () => states.forEach(sync));

    // Preserve the public hooks used by the existing slider code.
    window.syncSliderCardVideos = (scope = document) => {
      scan(scope);
      if (scope.matches?.(SLIDER)) syncSlider(scope);
      scope.querySelectorAll?.(SLIDER).forEach(syncSlider);
    };
    window.stopSingleCardVideo = (card, reset = true) => {
      const s = states.get(card);
      if (s) request(s, false, reset);
    };
    window.playSingleCardVideo = card => {
      scan(card);
      const s = states.get(card);
      if (s) sync(s);
    };
    window.setSliderVideoVisibility = (slider, visible) => {
      const state = sliders.get(slider);
      if (!state) return;
      state.enabled = !!visible;
      syncSlider(slider);
    };
  }

  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", init, { once: true });
  } else {
    init();
  }
})();