//! JS: live/source-lock.mjs. Per-source-file lock under
//! `<live>/locks/<sha256(abs)[:24]>.lock`, created `wx`, stale when its
//! owner pid is gone (or unreadable and older than 60 s), retried every
//! `retryMs` until `waitMs`, then `source_locked`.

use crate::paths::live_dir;
use crate::util::{jsp, now_ms, pid_reachable, sha256_hex, Env};
use serde_json::{json, Value};
use std::io::Write;

const UNREADABLE_LOCK_STALE_MS: f64 = 60_000.0;

/// A thrown lock error: `source_locked` (`code: 'SOURCE_LOCKED'`) on
/// contention, or the message of the fs error the JS would have rethrown.
#[derive(Debug)]
pub struct SourceLocked {
    pub message: String,
}

/// JS: sourceLockPath(file, cwd)
pub fn source_lock_path(file: &str, cwd: &str, env: &Env) -> String {
    let digest = sha256_hex(&jsp::resolve(cwd, &[file]));
    jsp::join(&[
        &live_dir(cwd, env),
        "locks",
        &format!("{}.lock", &digest[..24]),
    ])
}

fn read_lock(lock_path: &str) -> Option<Value> {
    let text = std::fs::read_to_string(lock_path).ok()?;
    serde_json::from_str(&text).ok()
}

/// JS: clearStaleLock(lockPath)
fn clear_stale_lock(lock_path: &str) {
    match read_lock(lock_path) {
        None => {
            if let Ok(meta) = std::fs::metadata(lock_path) {
                let mtime = meta
                    .modified()
                    .ok()
                    .and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok())
                    .map(|d| d.as_secs_f64() * 1000.0)
                    .unwrap_or(0.0);
                if now_ms() - mtime > UNREADABLE_LOCK_STALE_MS {
                    let _ = std::fs::remove_file(lock_path);
                }
            }
        }
        Some(held) => {
            if let Some(pid) = held.get("pid").and_then(|p| p.as_f64()) {
                // JS: typeof held.pid === 'number' && isLiveServerPidReachable(pid)
                if pid_reachable(pid as i64) {
                    return;
                }
            }
            let _ = std::fs::remove_file(lock_path);
        }
    }
}

/// JS: releaseOwnLock(lockPath, token)
fn release_own_lock(lock_path: &str, token: &str) {
    if let Some(held) = read_lock(lock_path) {
        if held.get("token").and_then(|t| t.as_str()) != Some(token) {
            return;
        }
    }
    let _ = std::fs::remove_file(lock_path);
}

fn random_uuid() -> String {
    let t = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_nanos())
        .unwrap_or(0);
    let mut x = (t as u64) ^ ((std::process::id() as u64) << 32) ^ 0x9E37_79B9_7F4A_7C15;
    let mut words = [0u64; 2];
    for w in words.iter_mut() {
        x ^= x >> 33;
        x = x.wrapping_mul(0xff51_afd7_ed55_8ccd);
        x ^= x >> 33;
        x = x.wrapping_mul(0xc4ce_b9fe_1a85_ec53);
        x ^= x >> 33;
        *w = x;
        x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
    }
    let hi = words[0];
    let lo = words[1];
    format!(
        "{:08x}-{:04x}-4{:03x}-{:04x}-{:012x}",
        (hi >> 32) as u32,
        ((hi >> 16) & 0xffff) as u16,
        (hi & 0xfff) as u16,
        (((lo >> 48) & 0x3fff) | 0x8000) as u16,
        lo & 0xffff_ffff_ffff
    )
}

/// JS: withSourceLockSync(file, owner, fn, { cwd, waitMs, retryMs })
pub fn with_source_lock<T>(
    file: &str,
    owner: &str,
    cwd: &str,
    env: &Env,
    wait_ms: f64,
    f: impl FnOnce() -> T,
) -> Result<T, SourceLocked> {
    let retry_ms: f64 = 5.0;
    let lock_path = source_lock_path(file, cwd, env);
    if let Some(parent) = std::path::Path::new(&lock_path).parent() {
        let _ = std::fs::create_dir_all(parent);
    }
    let deadline = now_ms() + wait_ms.max(0.0);
    let token = random_uuid();
    loop {
        clear_stale_lock(&lock_path);
        match std::fs::OpenOptions::new()
            .write(true)
            .create_new(true)
            .open(&lock_path)
        {
            Ok(mut fd) => {
                let payload = json!({
                    "owner": owner,
                    "token": token,
                    "pid": std::process::id(),
                    "at": now_ms() as i64,
                    "file": jsp::resolve(cwd, &[file]),
                });
                let _ = fd.write_all(format!("{}\n", payload).as_bytes());
                break;
            }
            Err(e) => {
                if e.kind() != std::io::ErrorKind::AlreadyExists {
                    // JS rethrows other errors as-is.
                    return Err(SourceLocked {
                        message: e.to_string(),
                    });
                }
                if now_ms() >= deadline {
                    return Err(SourceLocked {
                        message: "source_locked".to_string(),
                    });
                }
                let remaining = deadline - now_ms();
                let sleep = retry_ms.min(remaining).max(1.0);
                std::thread::sleep(std::time::Duration::from_millis(sleep as u64));
            }
        }
    }
    let out = f();
    release_own_lock(&lock_path, &token);
    Ok(out)
}