// ONOGolf — Swing vs Swing public components
// Requires svs-data.jsx. Exposes components on window.

const { useState: useSt, useEffect: useEf, useRef: useRf, useCallback: useCb } = React;

/* ============ YouTube IFrame API loader ============ */
let _ytReady = null;
function ensureYT() {
  if (_ytReady) return _ytReady;
  _ytReady = new Promise((resolve) => {
    if (window.YT && window.YT.Player) { resolve(window.YT); return; }
    const prev = window.onYouTubeIframeAPIReady;
    window.onYouTubeIframeAPIReady = () => { if (prev) try { prev(); } catch(e){} resolve(window.YT); };
    if (!document.getElementById("yt-iframe-api")) {
      const s = document.createElement("script");
      s.id = "yt-iframe-api"; s.src = "https://www.youtube.com/iframe_api";
      document.head.appendChild(s);
    }
  });
  return _ytReady;
}

/* ============ Big circular avatar ============ */
function SvsAvatar({ player, className }) {
  return (
    <div className={className} style={{ background: player.color }}>
      {player.photo ? <img src={player.photo} alt={player.name}/> : player.initials}
    </div>
  );
}

/* ============ Player carousel (auto-scroll + scrub) ============ */
function PlayerRail({ position, players, selectedId, onSelect }) {
  const railRef = useRf(null);
  const trackRef = useRf(null);
  const [playing, setPlaying] = useSt(true);
  const offset = useRf(0);                 // px the track is translated left
  const tween = useRf(null);               // {from,to,t0,dur} for the ‹ › nudge
  const drag = useRf({ active: false, startX: 0, startOffset: 0, moved: 0 });
  const hovering = useRf(false);

  // continuous auto-scroll via GPU transform (sub-pixel, compositor — no scrollLeft
  // integer-rounding jank). Time-based so it's framerate-independent.
  useEf(() => {
    let raf, last = performance.now();
    const SPEED = 38; // px per second
    const wrap = (x, half) => { if (half <= 0) return x; x %= half; if (x < 0) x += half; return x; };
    const tick = (now) => {
      const dt = Math.min((now - last) / 1000, 0.05); last = now;
      const track = trackRef.current;
      if (track) {
        const half = track.scrollWidth / 2; // content is duplicated → half = one full set
        if (drag.current.active) {
          /* offset is being set by the drag handler */
        } else if (tween.current) {
          const tw = tween.current, p = Math.min(1, (now - tw.t0) / tw.dur);
          offset.current = tw.from + (tw.to - tw.from) * (1 - Math.pow(1 - p, 3)); // easeOutCubic
          if (p >= 1) tween.current = null;
        } else if (playing && !hovering.current) {
          offset.current += SPEED * dt;
        }
        offset.current = wrap(offset.current, half);
        track.style.transform = `translate3d(${-offset.current}px,0,0)`;
      }
      raf = requestAnimationFrame(tick);
    };
    raf = requestAnimationFrame(tick);
    return () => cancelAnimationFrame(raf);
  }, [playing]);

  const onDown = (e) => {
    drag.current = { active: true, startX: e.clientX, startOffset: offset.current, moved: 0 };
    tween.current = null;
    railRef.current?.classList.add("dragging");
    railRef.current?.setPointerCapture?.(e.pointerId);
  };
  const onMove = (e) => {
    if (!drag.current.active) return;
    const dx = e.clientX - drag.current.startX;
    drag.current.moved = Math.max(drag.current.moved, Math.abs(dx));
    offset.current = drag.current.startOffset - dx; // drag right → content right
  };
  const onUp = () => {
    drag.current.active = false;
    railRef.current?.classList.remove("dragging");
  };
  const nudge = (dir) => {
    tween.current = { from: offset.current, to: offset.current + dir * 280, t0: performance.now(), dur: 420 };
  };
  const clickPlayer = (id) => { if (drag.current.moved < 6) onSelect(id); };

  const loop = [...players, ...players];
  const isLeft = position === "left";
  const chosen = players.find(p => p.id === selectedId);

  return (
    <div className={`svs-pos ${isLeft ? "svs-pos-left" : "svs-pos-right"}`}>
      <div className="svs-pos-head">
        <div>
          <div className="svs-pos-num">Position {isLeft ? "01" : "02"} · tap a player to choose</div>
          <div className="svs-pos-side">{chosen ? chosen.name : (isLeft ? "Left challenger" : "Right challenger")}</div>
        </div>
        <div className="svs-scrub">
          <button className="svs-scrub-btn" onClick={() => nudge(-1)} aria-label="Scroll left">
            <svg width="15" height="15" viewBox="0 0 16 16" fill="none"><path d="M10 3L5 8l5 5" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" strokeLinejoin="round"/></svg>
          </button>
          <button className={`svs-scrub-toggle ${playing ? "playing" : ""}`} onClick={() => setPlaying(p => !p)}>
            {playing ? "▮▮ Auto" : "▶ Scroll"}
          </button>
          <button className="svs-scrub-btn" onClick={() => nudge(1)} aria-label="Scroll right">
            <svg width="15" height="15" viewBox="0 0 16 16" fill="none"><path d="M6 3l5 5-5 5" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" strokeLinejoin="round"/></svg>
          </button>
        </div>
      </div>

      <div
        className="svs-rail"
        ref={railRef}
        onPointerDown={onDown}
        onPointerMove={onMove}
        onPointerUp={onUp}
        onPointerLeave={(e) => { onUp(e); hovering.current = false; }}
        onMouseEnter={() => { hovering.current = true; }}
        onMouseLeave={() => { hovering.current = false; }}
      >
        <div className="svs-rail-track" ref={trackRef}>
          {loop.map((p, i) => (
            <div
              key={p.id + "-" + i}
              className={`svs-player ${selectedId === p.id ? "selected" : ""}`}
              onClick={() => clickPlayer(p.id)}
            >
              <div className="svs-player-ring">
                <span className="svs-player-rank">#{p.rank}</span>
                {selectedId === p.id && <span className="svs-player-check" aria-label="selected">✓</span>}
                <SvsAvatar player={p} className="svs-avatar"/>
              </div>
              <div className="svs-player-name">{p.name}</div>
              <div className="svs-player-country">{p.country}</div>
            </div>
          ))}
        </div>
      </div>
    </div>
  );
}

/* ============ One video panel ============ */
function VideoPanel({ side, player, clip, videoTitle, onReady }) {
  const holderId = `svs-yt-${side}`;
  return (
    <div className={`svs-video-col is-${side}`}>
      <div className="svs-video-tag">
        {player ? <SvsAvatar player={player} className="vt-av"/> : <div className="vt-av" style={{ background: "#888" }}>?</div>}
        <div>
          <div className="vt-name">{player ? player.name : "Select a player"}</div>
          <div className="vt-meta">{videoTitle || "—"}</div>
        </div>
      </div>
      <div className={`svs-video-frame ${side}`}>
        {!clip && <div className="svs-video-empty">PICK A PLAYER FROM POSITION {side === "left" ? "01" : "02"}<br/>TO LOAD THEIR SWING</div>}
        <div id={holderId}></div>
      </div>
    </div>
  );
}

/* ============ VS Arena (synced players, controls, breakdowns) ============ */
function VSArena({ left, right, controlsRef }) {
  const playersRef = useRf({ left: null, right: null });
  const [ready, setReady] = useSt({ left: false, right: false });
  const [state, setState] = useSt({ left: false, right: false }); // playing?
  const [rate, setRate] = useSt(1);
  const both = state.left && state.right;

  // create / load players when clip changes
  useEf(() => {
    let cancelled = false;
    ensureYT().then((YT) => {
      if (cancelled) return;
      ["left", "right"].forEach((side) => {
        const clip = (side === "left" ? left : right)?.clip;
        if (!clip) return;
        const existing = playersRef.current[side];
        if (existing && existing.loadVideoById) {
          existing.loadVideoById(clip);
          existing.pauseVideo?.();
        } else {
          const holder = document.getElementById(`svs-yt-${side}`);
          if (!holder) return;
          playersRef.current[side] = new YT.Player(holder, {
            videoId: clip,
            playerVars: { controls: 1, modestbranding: 1, rel: 0, playsinline: 1, fs: 1 },
            events: {
              onReady: () => setReady((r) => ({ ...r, [side]: true })),
              onStateChange: (e) => {
                const playing = e.data === YT.PlayerState.PLAYING;
                setState((s) => ({ ...s, [side]: playing }));
              },
            },
          });
        }
      });
    });
    return () => { cancelled = true; };
  }, [left?.clip, right?.clip]);

  const get = (side) => playersRef.current[side];
  const play = (side) => get(side)?.playVideo?.();
  const pause = (side) => get(side)?.pauseVideo?.();
  const toggle = (side) => { state[side] ? pause(side) : play(side); };

  const playBoth = () => {
    if (both) { pause("left"); pause("right"); }
    else { get("left")?.seekTo && get("left").seekTo(get("left").getCurrentTime?.() || 0, true); play("left"); play("right"); }
  };
  const restart = () => {
    ["left", "right"].forEach((s) => { get(s)?.seekTo?.(0, true); });
  };
  const setSpeed = (r) => {
    setRate(r);
    ["left", "right"].forEach((s) => get(s)?.setPlaybackRate?.(r));
  };
  const seek = (side, sec) => {
    const p = get(side);
    if (p) { p.seekTo(sec, true); p.playVideo(); }
  };

  // expose seek to outside (so the breakdown dropdowns can drive the videos)
  useEf(() => { if (controlsRef) controlsRef.current = { seek }; });

  return (
    <div className="svs-arena">
      <div className="svs-stage">
        {/* LEFT */}
        <div>
          <VideoPanel side="left" player={left} clip={left?.clip} videoTitle={left?.videoTitle}/>
          <div className="svs-vid-controls">
            <button className="svs-ctrl-btn solid" onClick={() => toggle("left")} disabled={!left?.clip}>
              {state.left ? "❚❚ Pause" : "▶ Play"}
            </button>
            <button className="svs-ctrl-btn" onClick={() => get("left")?.seekTo?.(0, true)} disabled={!left?.clip}>↺ Restart</button>
          </div>
        </div>

        {/* VS CENTER */}
        <div className={`svs-vs ${both ? "clash" : ""}`}>
          <div className="svs-vs-ring">
            <svg className="svs-vs-clubs" viewBox="-60 -60 120 120" aria-hidden="true">
              {[34, -34].map((deg) => (
                <g key={deg} transform={`rotate(${deg}) scale(0.46)`} strokeLinecap="round" strokeLinejoin="round">
                  <line x1="0" y1="-104" x2="0" y2="-74" stroke="rgb(191,154,56)" strokeWidth="15" opacity="0.85"/>
                  <line x1="0" y1="-74" x2="0" y2="92" stroke="rgba(226,224,214,0.55)" strokeWidth="6"/>
                  <path d="M-4 94 L15 102 L14 116 L7 121 L-5 115 Z" fill="rgb(191,154,56)" opacity="0.85"/>
                </g>
              ))}
            </svg>
            <span className="svs-vs-text">VS</span>
          </div>
          <button className={`svs-vs-play ${both ? "playing" : ""}`} onClick={playBoth} disabled={!left?.clip || !right?.clip}>
            {both ? "❚❚ PAUSE BOTH" : "▶ PLAY VS"}
          </button>
          <div className="svs-vs-extra">
            <button className="svs-vs-mini" onClick={restart}>↺ Sync</button>
            <button className={`svs-vs-mini ${rate === 0.5 ? "active" : ""}`} onClick={() => setSpeed(rate === 0.5 ? 1 : 0.5)}>Slow-mo</button>
            <button className={`svs-vs-mini ${rate === 0.25 ? "active" : ""}`} onClick={() => setSpeed(rate === 0.25 ? 1 : 0.25)}>¼×</button>
          </div>
        </div>

        {/* RIGHT */}
        <div>
          <VideoPanel side="right" player={right} clip={right?.clip} videoTitle={right?.videoTitle}/>
          <div className="svs-vid-controls">
            <button className="svs-ctrl-btn solid" onClick={() => toggle("right")} disabled={!right?.clip}>
              {state.right ? "❚❚ Pause" : "▶ Play"}
            </button>
            <button className="svs-ctrl-btn" onClick={() => get("right")?.seekTo?.(0, true)} disabled={!right?.clip}>↺ Restart</button>
          </div>
        </div>
      </div>
    </div>
  );
}

/* ============ Collapsible swing breakdown dropdowns ============ */
function SwingBreakdowns({ left, right, onSeek }) {
  const [open, setOpen] = useSt({ left: false, right: false });
  const toggle = (side) => setOpen((o) => ({ ...o, [side]: !o[side] }));
  return (
    <div className="wrap" style={{ paddingBottom: "clamp(40px, 6vw, 72px)" }}>
        <div className="svs-breakdowns">
          {[["left", left], ["right", right]].map(([side, data]) => {
            const pts = data?.points || [];
            const isOpen = open[side];
            return (
              <div key={side} className={`svs-bd-col ${isOpen ? "open" : ""}`}>
                <button className="svs-bd-head" onClick={() => toggle(side)} aria-expanded={isOpen}>
                  <span className="svs-bd-dot" style={{ background: side === "left" ? "rgb(var(--orange))" : "rgb(var(--sea))" }}></span>
                  <span className="svs-bd-htext">
                    <span className="svs-bd-htitle">Swing breakdown</span>
                    <span className="svs-bd-hname">{data?.name || "—"} · {pts.length} points</span>
                  </span>
                  <span className="svs-bd-chev" aria-hidden="true">▾</span>
                </button>
                {isOpen && (
                  <div className="svs-bd-body">
                    {pts.map((pt, i) => (
                      <button key={i} className="svs-bd-item" onClick={() => onSeek(side, svsToSeconds(pt.t))}>
                        <span className="svs-bd-time">{pt.t}</span>
                        <span>
                          <span className="svs-bd-label">{pt.label}</span>
                          {pt.note && <span className="svs-bd-note">{pt.note}</span>}
                        </span>
                      </button>
                    ))}
                    {pts.length === 0 && (
                      <div className="svs-bd-note" style={{ padding: "8px 2px" }}>No breakdown points yet — add them in Admin.</div>
                    )}
                  </div>
                )}
              </div>
            );
          })}
        </div>
    </div>
  );
}

/* ============ Stats compare ============ */
function StatsCompare({ left, right }) {
  if (!left || !right) return null;
  return (
    <section className="section svs-stats">
      <div className="wrap">
        <div className="svs-stats-head">
          <div className="svs-sec-eyebrow" style={{ color: "rgb(var(--gold))" }}>Launch monitor</div>
          <div className="svs-stats-title" style={{ marginTop: 14 }}>The <span className="it">numbers</span> behind the swing</div>
          <div className="svs-stats-players">
            <div className="svs-sp">
              <SvsAvatar player={left} className="svs-sp-av"/>
              <div><div className="svs-sp-name">{left.name}</div><div className="svs-sp-tag">#{left.rank} · {left.country}</div></div>
            </div>
            <div className="svs-sp-vs">VS</div>
            <div className="svs-sp right">
              <SvsAvatar player={right} className="svs-sp-av"/>
              <div><div className="svs-sp-name">{right.name}</div><div className="svs-sp-tag">#{right.rank} · {right.country}</div></div>
            </div>
          </div>
        </div>

        <div className="svs-stat-rows">
          {SVS_STAT_DEFS.map((def) => {
            const lv = left.stats[def.key], rv = right.stats[def.key];
            const min = def.min || 0;
            const range = def.max - min;
            const lpct = Math.max(0, Math.min(100, ((lv - min) / range) * 100));
            const rpct = Math.max(0, Math.min(100, ((rv - min) / range) * 100));
            const avg = SVS_TOUR_AVG[def.key];
            const avgPct = Math.max(0, Math.min(100, ((avg - min) / range) * 100));
            const lWin = lv > rv, rWin = rv > lv;
            const fmt = (v) => v.toFixed(def.dec) + (def.unit ? " " + def.unit : "");
            return (
              <div className="svs-stat-row" key={def.key}>
                <div className="svs-stat-label">
                  <span className="svs-stat-vals"><span className={`l ${lWin ? "svs-stat-win" : ""}`}>{fmt(lv)}{lWin && <span className="svs-stat-win-dot"/>}</span></span>
                  <span className="svs-stat-name">{def.label}</span>
                  <span className="svs-stat-vals"><span className={`r ${rWin ? "svs-stat-win" : ""}`}>{rWin && <span className="svs-stat-win-dot"/>}{fmt(rv)}</span></span>
                </div>
                <div className="svs-stat-bar">
                  <div className="svs-stat-track l">
                    <div className="svs-stat-fill l" style={{ width: lpct + "%" }}></div>
                    <div className="svs-stat-avg" style={{ right: avgPct + "%" }}></div>
                  </div>
                  <div className="svs-stat-track r">
                    <div className="svs-stat-fill r" style={{ width: rpct + "%" }}></div>
                    <div className="svs-stat-avg" style={{ left: avgPct + "%" }}></div>
                  </div>
                </div>
              </div>
            );
          })}
        </div>
        <p style={{ textAlign: "center", marginTop: 32, fontSize: 12, color: "rgba(255,255,255,0.45)", fontFamily: "var(--font-mono)", letterSpacing: "0.06em" }}>
          TOUR AVG BENCHMARK · SOURCE: PGATOUR.COM/STATS · PER-PLAYER DATA EDITABLE IN ADMIN
        </p>
      </div>
    </section>
  );
}

Object.assign(window, { ensureYT, SvsAvatar, PlayerRail, VSArena, SwingBreakdowns, StatsCompare });
