try { performance.mark('cgvTourScriptStart'); } catch (e) {}

const isIOSEmulator = navigator.appVersion.includes('iPad') || navigator.appVersion.includes('iPhone') || navigator.appVersion.includes('iPod') ? true : false;
const isIOSDevice = (/iPad|iPhone|iPod/.test(navigator.platform) || isIOSEmulator ||
  (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1)) &&
  !window.MSStream;

const campgroundName = 'Brunswick Beaches Campground (NC)';
const datePicker = document.getElementById("cgvDatesPicker");
const search = document.getElementById("cgvSearch");
const cgvCInfo = document.getElementById("cgvCampgroundInfo");
const playerDiv = document.getElementById('playerContainer');
let granted = false;

function iOSPermission() {
  if (typeof (DeviceOrientationEvent) !== "undefined" && typeof (DeviceOrientationEvent).requestPermission === "function") {
    if (granted == false) {
      DeviceOrientationEvent.requestPermission()
        .then(response => {
          if (response == "granted") {
            window.addEventListener("deviceorientation", (e) => { });
            granted = true;
          }
        }).catch(console.error)
    }
  }
}

function setupBigPlayButton(){

  player.addChild('BigPlayButton');

  // Show it explicitly rather than waiting for the pause handler below.
  //
  // `controls: false` (Plan D) makes video.js add `vjs-controls-disabled`, and its own stylesheet
  // hides `.vjs-controls-disabled .vjs-big-play-button`. Measured on the dev tier the button IS
  // still visible to a guest - but only because the startup play->pause hitch fires the handler
  // below within the first second, writing an inline `display: block` that beats that rule.
  //
  // So the tour's only start affordance currently depends on a bug we have an open item to FIX.
  // Setting it here makes the intent explicit and survives that fix.
  const bigPlay = document.querySelector('.vjs-big-play-button');
  if (bigPlay) bigPlay.style.display = 'block';

  // TODO: quick fix for vjs start-stop on load.
  player.on('pause', function () {
    if (player.currentTime() < 1) {
      document.querySelector(".vjs-big-play-button").style.display = "block";
    }
  });

  player.on('play', function () {
    document.querySelector(".vjs-big-play-button").style.display = "none";
  });
}

function setupIosFullscreen(){
  player.on('enterFullWindow', function (e) {
    var renderedCanvas = document.getElementsByTagName("canvas")[0];
    if (player.isFullscreen()) {
      var parentEl = renderedCanvas.parentElement;
      var postionInfo = parentEl.getBoundingClientRect();
      renderedCanvas.setAttribute("width", postionInfo.width.toString());
      renderedCanvas.setAttribute("height", postionInfo.height.toString());
    }
  });

  player.on('exitFullWindow', function (e) {
    var renderedCanvas = document.getElementsByTagName("canvas")[0];
    if (!player.isFullscreen()) {
      var parentEl = renderedCanvas.parentElement;
      var postionInfo = parentEl.getBoundingClientRect();
      renderedCanvas.setAttribute("width", postionInfo.width.toString());
      renderedCanvas.setAttribute("height", postionInfo.height.toString());
    }
  });
}

function setupPlayerComponents(){

  if (isIOSDevice) {
    var btnOrientation = document.createElement('button');
    btnOrientation.setAttribute('id', 'request');
    btnOrientation.setAttribute('class', 'orientation-button');
    btnOrientation.innerHTML = 'Request device orientation access';
    btnOrientation.addEventListener('click', iOSPermission);
    playerDiv.append(btnOrientation);
  }

  cgvCInfo.style.display = 'block';
  cgvCInfo.innerHTML = campgroundName;
  cgvCInfo.style.paddingInlineStart = '1rem';
  datePicker.style.height = '100%';
  datePicker.style.width = document.getElementById("playerContainer").style.width;
  
  setupBigPlayButton();
}

function setupThreeSixtyPlugin() {
  const pluginInData = {
    parentId: 4347,
    campgroundName: 'Brunswick Beaches Campground (NC)',
    // CAM-189. A Unix instant here is read back through LOCAL getters by siteInfoDlg and the
    // picker, so a UTC midnight resolved to the previous day everywhere west of UTC and the
    // default range came out a day early in every timezone but UTC itself - including for the
    // AutoCache job, which was warming a key no browser ever asked for. GetDates() has always
    // pinned these to midnight at zero offset, so .Year/.Month/.Day are the intended calendar
    // parts, and the three-argument Date constructor gives local midnight everywhere.
    startDate: new Date(2026, 9, 2),
    endDate: new Date(2026, 9, 4),
    datePicker: datePicker,
    search: search,
    resourcesCdnEndpoint: 'https://campgroundviews-assets-ctaufjdtd3hgfzhy.z01.azurefd.net',
    playerHost: 'https://360.campgroundviews.com',
    supportsAvailability: false,
    pinTimelineRangeSec: 5,
    isPhone: isIOSDevice,
    isAudioEnable: 1 === 1,
    showAds: 1 === 2,
    editMode: false,
    bookingComponentSettings: {
        enabled: false,
        campgroundIntegrationId: "",
        apiBaseUrl: "",
        componentRootId: ""
    },
    // Plan F, Task 2. Campground.BrandAccent is a nullable C# string; null means the
    // CampgroundViews default (see cgv360.ts's ICgvSettings.accent doc comment and
    // ui/theme.ts's ACCENTS). @(Model.Campground.BrandAccent) - Razor's normal HTML-encoding
    // interpolation used everywhere else on this page - would silently turn a null into an
    // EMPTY STRING (Razor writes nothing for a null value), and a naive `'...'` wrapper would
    // do the same or, worse, could be made to emit the literal text "null" as a JS STRING by a
    // careless ?? fallback. Either failure mode is silent: theme.ts falls back to the brand
    // default either way, so nothing looks broken today, but a park that later picks a real
    // accent would keep silently getting the default. JsonSerializer.Serialize<string> is the
    // one call that gets both cases right without a hand-rolled branch: null serializes to the
    // bare JS token `null`, and any of the seven accent names serializes to a properly quoted
    // JS string - and Html.Raw is required here (matching _TourSeoContent.cshtml's
    // @Html.Raw(...ToJsonString())) so Razor does not then HTML-encode those quotes into
    // &quot; and corrupt the object literal.
    accent: null
  }

  // THE SOURCE GOES FIRST, and the 360 machinery follows when the bundle has landed.
  //
  // player.src() is what fetches the HLS manifest and the first segments. It used to sit behind
  // player.threeSixty(), which cannot be called until cgv360.js has finished evaluating - about
  // two seconds of Babylon module code. Measured: manifest at 550ms via the preload link, first
  // segment not requested until ~3,065ms. Nothing was waiting on the network; it was waiting on
  // JavaScript. Swapping these two lines lets the video buffer DURING that evaluation.
  videoUrl = 'https://campgroundviews-vod-h8emgteqergqcecv.z01.azurefd.net/2bfa6c4c73da4beaa1679fc4e6575ee0/5de9c9e7-79bd-41b1-87a6-51e41119466c.m3u8';
  player.src({ src: videoUrl, type: 'application/vnd.apple.mpegurl' });
  try { performance.mark('cgvAfterSrc'); } catch (e) {}

  attachThreeSixty(pluginInData);
}

// Calls player.threeSixty() as soon as the plugin exists.
//
// This script now runs BEFORE cgv360.js (see the comment on the script tags in
// TourCampground.cshtml), so the plugin is usually not registered yet at this point. video.js
// registers plugins onto Player.prototype, so a player constructed beforehand gains the method
// the moment registerPlugin runs - there is no need to rebuild or re-src the player.
//
// The bundle's load event is the signal rather than a poll: `defer` scripts fire load AFTER they
// execute, and this script is guaranteed to have run first, so the listener cannot be attached
// too late to see it. The typeof check ahead of it covers the reverse case - a cached bundle
// that somehow evaluated first - so neither ordering silently produces a tour with no 360.
function attachThreeSixty(pluginInData) {
  if (typeof player.threeSixty === 'function') {
    player.threeSixty(pluginInData);
    return;
  }
  const bundle = document.getElementById('cgv360Bundle');
  if (bundle == null) {
    // The id is gone from the view. Fall back to polling rather than leaving the guest with a
    // video and no tour - a silent no-op here is the whole player.
    console.warn('[360] #cgv360Bundle not found; polling for the threeSixty plugin instead.');
    const started = Date.now();
    const poll = setInterval(function () {
      if (typeof player.threeSixty === 'function') { clearInterval(poll); player.threeSixty(pluginInData); }
      else if (Date.now() - started > 30000) { clearInterval(poll); console.error('[360] threeSixty plugin never registered.'); }
    }, 50);
    return;
  }
  bundle.addEventListener('load', function () {
    if (typeof player.threeSixty === 'function') player.threeSixty(pluginInData);
    else console.error('[360] cgv360.js loaded but registered no threeSixty plugin.');
  }, { once: true });
  bundle.addEventListener('error', function () {
    console.error('[360] cgv360.js failed to load; the tour will play as flat video.');
  }, { once: true });
}

const vjsOptions = {
  // PLAN D, TASK 2. video.js's own control bar is off; <cgv-control-bar> replaces it, mounted
  // into the overlay's shadow root by cgv360.ts (search that file for "PLAN D, TASK 2"). The old
  // bar had a 3px seek target, showed only the time remaining, and painted white icons straight
  // onto whatever the sky was doing.
  //
  // `controls: false` does NOT remove the ControlBar component in video.js 8.9.0 - it swaps
  // vjs-controls-enabled for vjs-controls-disabled and video-js.css hides it. Every
  // player.controlBar.* reference in this repo therefore still resolves (verified in Chromium
  // against the vendored build), which is what lets the DOM bar forward share/search/calendar to
  // the video.js Buttons that already own those behaviours instead of reimplementing them. The
  // `controlBar: {...}` block below is kept for the same reason: those children still exist, and
  // the hidden fullscreenToggle is the anchor every custom button inserts itself before.
  controls: false,
  nativeControlsForTouch: false,
  fill: true,
  playbackRates: [0.5, 0.75, 1, 1.25, 1.5, 2],
  inactivityTimeout: 0,
  controlBar: {
    pictureInPictureToggle: false,
    volumePanel: { inline: false },
    fullscreenToggle: true,
    subsCapsButton: false
  },
  techOrder: ["html5"],
  html5: {
    vhs: {
      smoothQualityChange: true,
      // Deliberately false: for 360, the player window is NOT the picture. A guest sees
      // about a twelfth of the frame, so limiting the rendition to the element's pixel
      // size would pick a rung far too low.
      limitRenditionByPlayerDimensions: false,
      blacklistDuration: 15,
      // ABR starts from this estimate rather than from the lowest rung and climbing. 6 Mbps
      // puts the first segment on 1920x960 (5.2 Mbps) instead of 960x480 (2.5 Mbps), which
      // is what made a guest's first impression a smear. If the connection cannot sustain
      // it, VHS steps down within a segment or two - the floor below stops it going too far.
      bandwidth: 6000000
    }
  },
  preferFullWindow: isIOSDevice,
  fullscreen: {
    options: { navigationUI: 'show' }
  }
};

// PRD P3. The floor below (applied on loadedmetadata) cannot govern the FIRST pick, because
// by then VHS has already chosen and fetched a playlist - measured: two 480p segments before
// it climbed. The correct hook is called for every selection including the first, so this is
// where a 360-specific floor actually belongs. This must be set before videojs(...) constructs
// the player.
//
// NOTE ON THE HOOK NAME: `videojs.Vhs.selectPlaylist` does not exist on either vendored VHS
// build and is never read by them - confirmed by reading source, and by two live measurements
// (see below). What VHS actually consults - traced through wwwroot/resources/lib/videojs/
// http-streaming/dist/videojs-http-streaming.min.js, the copy this view actually <script>-tags
// and the one that matters (a second, newer copy also lives in the repo under
// resources/js/videojs/http-stream/ but is unused on this page - do not read shape from it):
//   - `VhsHandler.src()` does
//       const defaultSelector = this.options_.experimentalBufferBasedABR
//         ? Vhs.movingAverageBandwidthSelector(0.55) : Vhs.STANDARD_PLAYLIST_SELECTOR;
//       this.masterPlaylistController_.selectPlaylist = this.selectPlaylist
//         ? this.selectPlaylist.bind(this) : defaultSelector.bind(this);
//     `this.selectPlaylist` is an instance accessor that video.js only defines AFTER this same
//     `src()` call runs, so on the very first call it is undefined and `Vhs.STANDARD_PLAYLIST_SELECTOR`
//     (aliased to the bandwidth-based default selector) is what gets bound and installed.
//   - The initial pick additionally prefers `selectInitialPlaylist` (`Vhs.INITIAL_PLAYLIST_SELECTOR`,
//     always the lowest-bitrate variant) only when `enableLowInitialPlaylist` is true, and VHS forces
//     that to false whenever a non-default `bandwidth` option is supplied - true here, since
//     vjsOptions.html5.vhs.bandwidth is set above. So the very first selection for this player goes
//     through `Vhs.STANDARD_PLAYLIST_SELECTOR`, not a "selectPlaylist" property.
//   - `Vhs` here is the exact object assigned to `videojs.Vhs` (`videojs.Vhs = Vhs;` at module load),
//     so mutating `videojs.Vhs.STANDARD_PLAYLIST_SELECTOR` before the player is constructed changes
//     what `defaultSelector` resolves to when `.src()` runs.
//   - This deployed build is VHS 2.8.2, which reads the manifest off `this.playlists.master`
//     (older naming); newer VHS reads `this.playlists.main`. A first deploy of this fix read
//     `.main` only, based on the wrong (unused) vendored copy - it shipped clean but a live
//     Playwright capture still showed 480p first, because `.main` was always undefined and the
//     override silently fell through to the default choice every time. Check both names.
// This player does not set `experimentalBufferBasedABR`, so `STANDARD_PLAYLIST_SELECTOR` is the
// selector actually exercised; movingAverageBandwidthSelector is intentionally left untouched
// (out of scope - unused here).
//
// ⚠️ GLOBAL: this replaces videojs.Vhs.STANDARD_PLAYLIST_SELECTOR for every VHS player on the page,
// not just this one. Wrap the existing default rather than reimplementing ABR, and never let this
// function return anything falsy that the default itself didn't already return - guard every
// hop, because a thrown error here fails playback hard.
try {
  if (typeof videojs !== 'undefined' && videojs.Vhs && typeof videojs.Vhs.STANDARD_PLAYLIST_SELECTOR === 'function') {
    const MIN_360_WIDTH = 1920;
    const defaultSelectPlaylist = videojs.Vhs.STANDARD_PLAYLIST_SELECTOR;

    videojs.Vhs.STANDARD_PLAYLIST_SELECTOR = function () {
      // `this` here is the VhsHandler instance - the same context the default selector runs
      // under - which exposes the parsed manifest's rendition list at this.playlists.master.playlists
      // (VHS 2.8.2, the version actually vendored here) or this.playlists.main.playlists (newer VHS).
      let choice;
      try {
        choice = defaultSelectPlaylist.call(this);
      } catch (err) {
        // Re-throw rather than returning `choice`, which is undefined here. VHS treats a falsy
        // return as fatal - blacklistCurrentPlaylist does
        //     if (!this.selectPlaylist()) { this.error = "Playback cannot continue..."; }
        // - so swallowing a transient throw converted it into a PERMANENT player error. Re-throwing
        // makes this wrapper transparent on the failure path: the caller sees exactly what it would
        // have seen if we had never wrapped the selector.
        console.warn('[360] Default VHS STANDARD_PLAYLIST_SELECTOR threw; propagating unchanged.', err);
        throw err;
      }

      try {
        const widthOf = function (playlist) {
          // A rendition with no RESOLUTION attribute is unknown, not 0-wide - treat it as
          // ineligible for the floor rather than the narrowest option.
          return playlist && playlist.attributes && playlist.attributes.RESOLUTION &&
            typeof playlist.attributes.RESOLUTION.width === 'number'
            ? playlist.attributes.RESOLUTION.width
            : undefined;
        };

        // Once the rescue has lifted the floor for this handler, stop re-imposing it. Without
        // this the wrapper immediately undoes the lift on the very next selection.
        if (this && this.__cgv360FloorLifted) {
          return choice;
        }

        // FIRST SELECTION STARTS AT THE FLOOR, not at whatever the bandwidth estimate can afford.
        //
        // Measured on the dev tier, 2 runs in 3: VHS reads ~90Mbps off the manifest fetch, picks
        // 3840x1920 at 16500kbps for the very first segment, and playback begins with ~1.9s
        // buffered. The buffer then DRAINS - 1.9s, 1.6s, 1.4s, 1.3s - because the next 16.5Mbps
        // segment cannot arrive faster than it is being consumed, and at t~1.97 the player
        // stalls and shows a spinner. That is the "plays for a second or two then buffers"
        // the owner reported, and it is the shape of a startup with no buffer runway rather
        // than of a slow connection.
        //
        // The floor rung is 5170kbps against 16500 - roughly a third of the bytes for the same
        // wall-clock of video - so it fills the buffer about three times as fast. ABR then
        // climbs on its own once there IS a buffer, which is the state its estimate is
        // meaningful in; the first estimate is derived from one manifest request and describes
        // a burst, not a sustained rate.
        //
        // Detected as "no media chosen yet" rather than by counting calls: VHS's own
        // MasterPlaylistController leaves playlists.media() undefined until the first selection
        // resolves, and the wedged-seek watchdog in cgv360.ts re-issues player.src(), which
        // builds a fresh handler that must start from the floor again exactly like a new load.
        // A counter would treat that recovery as a continuation and hand it 4K with no buffer.
        // Count every pick on THIS handler. Two jobs: it drives the runway below, and it is the
        // only evidence from outside that this wrapper is alive at all. The comments above record
        // that a previous override silently bound to a name VHS never reads and fell through to
        // the default on every selection - undetectably, because a floor that does nothing looks
        // exactly like a floor that is never needed. live-checks/startup-hitch.spec.js asserts
        // this counter is non-zero, so that failure mode cannot come back quietly.
        this.__cgv360Picks = (this.__cgv360Picks || 0) + 1;

        // THE STARTUP RUNWAY. Hold the floor rung until there is a buffer to climb from.
        //
        // VHS reads ~90Mbps off the manifest fetch and picks 3840x1920 at 16500kbps for the very
        // first segment. Playback then begins with ~1.9s buffered and DRAINS - 1.9, 1.6, 1.4,
        // 1.3 - because the next 16.5Mbps segment cannot arrive faster than it is consumed. At
        // t~1.97 it stalls and spins. Measured 2 runs in 3 on the dev tier; that is the
        // "plays a second or two then buffers" the owner reported.
        //
        // The floor rung is 5170kbps against 16500 - about a third of the bytes for the same
        // wall-clock - so it builds the buffer roughly three times as fast. ABR climbs on its
        // own once a buffer exists, which is the only state its estimate means anything in: the
        // first estimate describes one manifest request, a burst, not a sustained rate.
        //
        // Keyed on BUFFER, not on a pick index or a timer. A pick counter would have to guess how
        // many selections happen before playback is safe, and that varies with segment length and
        // connection; the buffer is the quantity actually at risk. It also self-heals: the
        // wedged-seek watchdog in cgv360.ts re-issues player.src() and builds a fresh handler,
        // which correctly gets a fresh runway rather than inheriting a stale 'we started' flag.
        const RUNWAY_SECONDS = 8;
        let inRunway = false;
        try {
          const tech = this && this.tech_;
          const buffered = tech && typeof tech.buffered === 'function' ? tech.buffered() : null;
          const now = tech && typeof tech.currentTime === 'function' ? tech.currentTime() : 0;
          let ahead = 0;
          if (buffered) {
            for (let bi = 0; bi < buffered.length; bi++) {
              if (buffered.start(bi) <= now && now <= buffered.end(bi)) { ahead = buffered.end(bi) - now; break; }
            }
          }
          inRunway = ahead < RUNWAY_SECONDS;
        } catch (e) {
          // Unknown buffer is not a licence to hand a cold player 4K. Only the first few picks
          // are treated as runway in that case, so a broken probe degrades to a small delay in
          // climbing rather than to the stall this exists to prevent.
          inRunway = this.__cgv360Picks <= 3;
        }

        const choiceWidth = widthOf(choice);
        if (!inRunway && typeof choiceWidth === 'number' && choiceWidth >= MIN_360_WIDTH) {
          return choice;
        }

        // VHS 2.8.2 (vendored here) names this "master"; newer VHS renamed it to "main".
        // Support both rather than betting on one vendor version.
        const manifest = this && this.playlists && (this.playlists.master || this.playlists.main);
        const playlists = manifest && Array.isArray(manifest.playlists) ? manifest.playlists : null;
        if (!playlists || playlists.length === 0) {
          return choice;
        }

        // ELIGIBILITY. The default selector filters on `disabled` and `excludeUntil`; an earlier
        // version of this wrapper scanned the raw list and did neither, which broke it in three
        // ways at once:
        //   1. The floor-lift rescue below re-enables rungs, and `Representation.enabled()` is
        //      bound to smoothQualityChange_ (smoothQualityChange: true), so each re-enable calls
        //      straight back into this selector. Ignoring excludeUntil handed back the rendition
        //      VHS had just excluded, which failed again, was excluded again, and left the guest
        //      on a spinner - the exact dead player the rescue exists to prevent.
        //   2. videojs-hls-quality-selector forces a quality by DISABLING every other playlist.
        //      Ignoring `disabled` overrode the guest's own choice straight back to 1920, so the
        //      quality menu was inert on every tour.
        //   3. A browser lacking the codec for the top rungs gets excludeUntil = Infinity on them;
        //      ignoring that pushed playback onto a rendition it cannot decode.
        const nowMs = Date.now();
        const isEligible = function (playlist) {
          // Mirrors VHS's own isEnabled: not user-disabled, and not currently excluded.
          // excludeUntil is undefined when never excluded and Infinity when incompatible; both
          // compare correctly against nowMs.
          return !!playlist && !playlist.disabled && !(playlist.excludeUntil > nowMs);
        };

        let best = null;
        let bestWidth = Infinity;
        for (let i = 0; i < playlists.length; i++) {
          const w = widthOf(playlists[i]);
          if (typeof w !== 'number' || w < MIN_360_WIDTH) {
            continue;
          }
          if (!isEligible(playlists[i])) {
            continue;
          }
          if (w < bestWidth) {
            best = playlists[i];
            bestWidth = w;
          }
        }

        // Lowest rendition that still meets the floor, so the guest isn't handed 4K on a
        // connection that can barely sustain 1920x960. If nothing on the ladder meets the
        // floor, degraded is better than black - fall back to the default's own choice.
        return best || choice;
      } catch (err) {
        console.warn('[360] Could not apply the 1920px start floor to VHS.STANDARD_PLAYLIST_SELECTOR; using the default choice.', err);
        return choice;
      }
    };
  }
} catch (err) {
  console.warn('[360] Could not install the 1920px start floor for VHS.STANDARD_PLAYLIST_SELECTOR.', err);
}

try { performance.mark('cgvBeforeVideojs'); } catch (e) {}
const player = videojs('player', vjsOptions, function () {

  setupThreeSixtyPlugin();

  // Rungs below 1920 wide are unusable for 360: cropped to a 90-degree viewport they resolve
  // to roughly 160 and 240 real pixels. They exist in the manifest for legacy flat video, so
  // rather than re-encode the catalogue we stop selecting them. Guard every hop - the tech
  // and its vhs object are not present on every browser/source combination.
  //
  // Deferred to 'loadedmetadata' rather than applied right here: setupThreeSixtyPlugin() ends
  // by calling player.src(...), and video.js's Player.src_ calls this.ready(fn, true), which
  // runs synchronously because the player is already ready at this point in its own ready
  // callback. That means tech.vhs exists but the master playlist request has only just been
  // issued - vhs.representations() reads masterPlaylistController_.master(), which is
  // undefined until the manifest loads, and indexing into that undefined throws. That thrown
  // error used to abort the rest of this callback (hlsQualitySelector, setupPlayerComponents,
  // setupIosFullscreen never ran). Do not move this back to run inline "for tidiness" -
  // 'loadedmetadata' is the first point VHS has a real representations() list.
  const MIN_360_WIDTH = 1920;

  // 'loadedmetadata', NOT player.one('loadedmetadata'). `one` fires once for the player's whole
  // lifetime, but cgv360.ts's wedged-seek watchdog recovers by re-issuing player.src(), which
  // builds a BRAND NEW VhsHandler. With `one`, the floor was silently never re-applied after any
  // such recovery, while the global STANDARD_PLAYLIST_SELECTOR wrapper above kept forcing 1920 -
  // and the blacklistplaylist listener below survived on the tech holding a stale vhs/reps from
  // the disposed handler, so the rescue was a no-op exactly when it was needed.
  player.on('loadedmetadata', function () {
    try {
      const tech = player.tech && player.tech({ IWillNotUseThisInPlugins: true });
      const vhs = tech && tech.vhs;
      if (!vhs || !vhs.representations) {
        return;
      }
      // 'loadedmetadata' can fire more than once for the same handler; only set up per handler.
      if (vhs.__cgv360FloorInstalled) {
        return;
      }
      vhs.__cgv360FloorInstalled = true;

      const reps = vhs.representations();
      // Rungs below 1920 wide are unusable for 360: cropped to a 90-degree viewport they resolve
      // to roughly 160 and 240 real pixels. They exist in the manifest for legacy flat video, so
      // rather than re-encode the catalogue we stop selecting them.
      //
      // A rung with no measurable width is UNKNOWN, not narrow - leave it enabled so it survives
      // as a fallback. The selector wrapper above applies the same policy (unknown is ineligible
      // for the floor, not treated as the narrowest option); the two used to disagree, and this
      // one silently deleted such a rung from the ladder.
      const meetsFloor = function (r) {
        return typeof r.width !== 'number' || r.width >= MIN_360_WIDTH;
      };

      // Only apply the floor if something survives it. A tour whose ladder tops out below 1920
      // must still play - degraded is better than black.
      if (reps.some(function (r) { return typeof r.width === 'number' && r.width >= MIN_360_WIDTH; })) {
        reps.forEach(function (r) { r.enabled(meetsFloor(r)); });
      }

      // The floor marks every lower rung `disabled`, and VHS's own last-rendition rescue does NOT
      // undo that. Traced through the vendored bundle
      // (wwwroot/resources/lib/videojs/http-streaming/dist/videojs-http-streaming.min.js,
      // MasterPlaylistController.blacklistCurrentPlaylist): when the failing playlist is the last
      // ENABLED one, VHS clears `excludeUntil` on the OTHER playlists only - it never clears
      // `disabled` - then falls through and excludes the failing one regardless, reaching
      //     var o = this.selectPlaylist();
      //     if (!o) { this.error = "Playback cannot continue. No available working or supported
      //               playlists."; this.trigger("error"); return; }
      //
      // So on any ladder whose only rung at or above 1920 is its top one - the ordinary shape for a
      // tour mastered at 1920x960 - a single segment error empties the eligible set and the guest
      // gets a dead player instead of a soft step down.
      //
      // `blacklistplaylist` is triggered synchronously AFTER the failing playlist's excludeUntil is
      // stamped and BEFORE that selectPlaylist() call, so this handler both sees the true
      // post-exclusion state and runs in time for VHS to find what it puts back.
      if (tech.on) {
        tech.on('blacklistplaylist', function () {
          try {
            // A seek recovery builds a new VhsHandler on the SAME tech, and listeners from the old
            // one survive. Anything but the current handler is stale - bail rather than mutating a
            // disposed manifest.
            if (tech.vhs !== vhs || vhs.__cgv360FloorLifted) {
              return;
            }
            const all = vhs.playlists && vhs.playlists.master && vhs.playlists.master.playlists;
            if (!all || !all.length) {
              return;
            }
            const now = Date.now();
            const anyPlayable = all.some(function (pl) { return !pl.disabled && !(pl.excludeUntil > now); });
            if (anyPlayable) {
              return;
            }
            // Set the flag first: the selector wrapper reads it to stop re-imposing the floor
            // it has just lifted.
            vhs.__cgv360FloorLifted = true;

            // Clear `disabled` on the raw playlists rather than calling Representation.enabled(true).
            //
            // enabled() is bound to smoothQualityChange_ (smoothQualityChange: true), so re-enabling
            // five rungs fired FIVE synchronous quality changes from inside this handler. Observed
            // on the dev tier: VHS fetched three lower-rung media playlists back to back and then
            // stopped requesting segments entirely - playback advanced two seconds and wedged. No
            // error, no fatal, just a stalled tour, which is the outcome this rescue exists to
            // prevent.
            //
            // These are the same objects enabled() mutates (representations() maps over
            // master.playlists and sets/deletes `disabled` on them), so this restores the ladder
            // identically - it just does not drag the segment loader through five media switches on
            // the way. VHS calls selectPlaylist() itself on the very next line of
            // blacklistCurrentPlaylist, which is what should choose the replacement rung.
            all.forEach(function (pl) { delete pl.disabled; });
            console.warn('[360] Lifted the 1920px ABR floor - every rung at or above it was excluded. Playing degraded rather than stopping.');
          } catch (err) {
            console.warn('[360] ABR floor rescue failed; VHS may stop if no rendition is eligible.', err);
          }
        });
      }
    } catch (err) {
      // Must never throw here - this callback runs independently of player setup, but a regression
      // in VHS internals should degrade to "no floor applied", not break ABR.
      console.warn('[360] Could not apply the 1920px ABR floor; playing with the full rendition ladder.', err);
    }
  });

  player.hlsQualitySelector({
    displayCurrentQuality: true,
    placementIndex: 11
  });

  setupPlayerComponents();

  if(isIOSDevice){
    setupIosFullscreen();
  }

});