use std::ffi::OsStr;
use std::time::{Duration, Instant};

fn which(cmd: &str) -> Option<std::path::PathBuf> {
    which::which(cmd).ok()
}

fn chrome_path() -> Option<std::path::PathBuf> {
    let mac =
        std::path::PathBuf::from("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome");
    if mac.exists() {
        return Some(mac);
    }
    which("google-chrome")
        .or_else(|| which("google-chrome-stable"))
        .or_else(|| which("chromium"))
}

fn wait_for_canvas_element(tab: &headless_chrome::Tab, timeout: Duration) -> anyhow::Result<()> {
    let deadline = Instant::now() + timeout;
    while Instant::now() < deadline {
        let js = r#"(function() {
  return !!document.querySelector('moq-watch canvas');
})();"#;
        let v = tab.evaluate(js, false)?;
        if v.value.and_then(|v| v.as_bool()).unwrap_or(false) {
            return Ok(());
        }
        std::thread::sleep(Duration::from_millis(200));
    }
    anyhow::bail!("timed out waiting for canvas player");
}

fn wait_for_moq_watch_element(tab: &headless_chrome::Tab, timeout: Duration) -> anyhow::Result<()> {
    let deadline = Instant::now() + timeout;
    while Instant::now() < deadline {
        let js = r#"(function() {
  return !!document.querySelector('moq-watch');
})();"#;
        let v = tab.evaluate(js, false)?;
        if v.value.and_then(|v| v.as_bool()).unwrap_or(false) {
            return Ok(());
        }
        std::thread::sleep(Duration::from_millis(200));
    }
    anyhow::bail!("timed out waiting for <moq-watch> element");
}

fn debug_player_state(tab: &headless_chrome::Tab) -> anyhow::Result<String> {
    let js = r#"(function() {
  let watch = document.querySelector('moq-watch');
  let canvas = document.querySelector('moq-watch canvas');
  let placeholder = document.querySelector('.placeholder');
  let placeholderText = placeholder ? (placeholder.innerText || '') : null;
  let status = document.querySelector('.source-status');
  let statusText = status ? (status.innerText || '') : null;
  let sources = Array.from(document.querySelectorAll('button[data-testid="global-watch"]')).length;
  let hint = document.querySelector('#hint');
  let hintText = hint ? (hint.innerText || '') : null;
  return JSON.stringify({
    hasWatch: !!watch,
    hasCanvas: !!canvas,
    canvasWidth: canvas ? canvas.width : null,
    canvasHeight: canvas ? canvas.height : null,
    muted: watch ? watch.muted : null,
    volume: watch ? watch.volume : null,
    hintText,
    placeholderText,
    statusText,
    sources
  });
})();"#;
    let v = tab.evaluate(js, false)?;
    Ok(v.value
        .and_then(|v| v.as_str().map(|s| s.to_string()))
        .unwrap_or_default())
}

fn canvas_motion_sample(tab: &headless_chrome::Tab) -> anyhow::Result<Option<(f64, u32)>> {
    let js = r#"(function() {
  let source = document.querySelector('moq-watch canvas');
  if (!source || !source.width || !source.height) return null;
  let canvas = window.__ec_motion_canvas || (window.__ec_motion_canvas = document.createElement('canvas'));
  canvas.width = 160;
  canvas.height = 90;
  let ctx = canvas.getContext('2d', { willReadFrequently: true });
  ctx.drawImage(source, 0, 0, canvas.width, canvas.height);
  let data = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
  let hash = 2166136261 >>> 0;
  for (let i = 0; i < data.length; i += 16) {
    hash ^= data[i]; hash = Math.imul(hash, 16777619);
    hash ^= data[i + 1]; hash = Math.imul(hash, 16777619);
    hash ^= data[i + 2]; hash = Math.imul(hash, 16777619);
  }
  return JSON.stringify({ currentTime: performance.now() / 1000, hash: hash >>> 0 });
})();"#;
    let v = tab.evaluate(&js, false)?;
    let Some(s) = v.value.and_then(|v| v.as_str().map(|s| s.to_string())) else {
        return Ok(None);
    };
    let value: serde_json::Value = serde_json::from_str(&s)?;
    let current_time = value
        .get("currentTime")
        .and_then(|v| v.as_f64())
        .unwrap_or_default();
    let hash = value
        .get("hash")
        .and_then(|v| v.as_u64())
        .unwrap_or_default() as u32;
    Ok(Some((current_time, hash)))
}

fn wait_for_canvas_motion(tab: &headless_chrome::Tab, timeout: Duration) -> anyhow::Result<()> {
    let deadline = Instant::now() + timeout;
    let mut first: Option<(f64, u32)> = None;
    while Instant::now() < deadline {
        if let Some(sample) = canvas_motion_sample(tab)? {
            if let Some((first_time, first_hash)) = first {
                if sample.0 > first_time + 0.5 && sample.1 != first_hash {
                    return Ok(());
                }
            } else {
                first = Some(sample);
            }
        }
        std::thread::sleep(Duration::from_millis(500));
    }
    let st = debug_player_state(tab).unwrap_or_default();
    anyhow::bail!("timed out waiting for changing canvas frames\nplayer_state={st}");
}

fn wait_for_unmuted_player(tab: &headless_chrome::Tab, timeout: Duration) -> anyhow::Result<()> {
    let deadline = Instant::now() + timeout;
    while Instant::now() < deadline {
        let js = r#"(function() {
  let watch = document.querySelector('moq-watch');
  return !!watch && watch.muted === false && watch.volume > 0 && !watch.hasAttribute('muted');
})();"#;
        let v = tab.evaluate(js, false)?;
        if v.value.and_then(|v| v.as_bool()).unwrap_or(false) {
            return Ok(());
        }
        std::thread::sleep(Duration::from_millis(200));
    }
    let st = debug_player_state(tab).unwrap_or_default();
    anyhow::bail!("timed out waiting for unmuted player\nplayer_state={st}");
}

fn watch_url(site_url: &str, relay_url: &str, stream_id: &str) -> anyhow::Result<String> {
    let mut url = url::Url::parse(site_url)?;
    url.set_path("/watch");
    url.query_pairs_mut()
        .clear()
        .append_pair("url", relay_url)
        .append_pair("name", stream_id);
    Ok(url.to_string())
}

#[test]
#[ignore]
fn e2e_remote_website_watch_existing_stream_id() -> anyhow::Result<()> {
    let chrome = match chrome_path() {
        Some(p) => p,
        None => return Ok(()), // skip
    };
    // We still want ffmpeg around for parity with other E2Es (and to discourage "works only without media tools").
    if which("ffmpeg").is_none() {
        return Ok(()); // skip
    }

    let site_url = std::env::var("EVERY_CHANNEL_SITE_URL")
        .unwrap_or_else(|_| "https://every.channel/".to_string());
    let relay_url = std::env::var("EVERY_CHANNEL_RELAY_URL")
        .unwrap_or_else(|_| "https://relay.every.channel/anon".to_string());
    let stream_id = match std::env::var("EVERY_CHANNEL_STREAM_ID") {
        Ok(v) if !v.trim().is_empty() => v,
        _ => return Ok(()), // skip
    };

    let launch_options = headless_chrome::LaunchOptionsBuilder::default()
        .path(Some(chrome))
        .headless(true)
        .args(vec![
            OsStr::new("--autoplay-policy=no-user-gesture-required"),
            OsStr::new("--disable-application-cache"),
            OsStr::new("--disable-service-worker"),
            OsStr::new("--disk-cache-size=0"),
        ])
        .build()
        .unwrap();
    let browser = headless_chrome::Browser::new(launch_options)?;
    let tab = browser.new_tab()?;
    tab.navigate_to(&watch_url(&site_url, &relay_url, &stream_id)?)?;
    tab.wait_until_navigated()?;

    // Ensure the player is instantiated.
    if let Err(err) = wait_for_moq_watch_element(&tab, Duration::from_secs(90)) {
        let st = debug_player_state(&tab).unwrap_or_default();
        anyhow::bail!("{err}\nplayer_state={st}");
    }

    if let Err(err) = wait_for_canvas_element(&tab, Duration::from_secs(90)) {
        let st = debug_player_state(&tab).unwrap_or_default();
        anyhow::bail!("{err}\nplayer_state={st}");
    }

    tab.wait_for_element("moq-watch canvas")?.click()?;
    wait_for_unmuted_player(&tab, Duration::from_secs(10))?;
    wait_for_canvas_motion(&tab, Duration::from_secs(30))?;

    Ok(())
}
