buffr-blink-cdp 0.1.2

//! CDP worker thread.
//!
//! A single `std::thread` owns the WebSocket connection and runs a loop:
//!   1. Send pending commands from the `cmd_rx` channel.
//!   2. Read a CDP message from the WebSocket.
//!   3. If it's a response (has an `id`), route it to the waiting `Sender`.
//!   4. If it's an event, handle known events:
//!      - `Page.screencastFrame`: decode base64 PNG → BGRA, write to
//!        `SharedOsrFrame`, send `Page.screencastFrameAck`.
//!      - `Page.frameNavigated`: re-apply per-session zoom + propagate
//!        url/title to EngineState (audit P0-1).
//!
//! The polling `Page.captureScreenshot` loop is gone.  Chromium pushes frames
//! via `Page.startScreencast` instead, throttled naturally by the ack protocol.
//!
//! The worker exits when the `cmd_rx` channel is dropped (engine shutdown).

use std::collections::{HashMap, VecDeque};
use std::path::{Path, PathBuf};
use std::sync::mpsc::{self, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

use base64::Engine as B64Engine;
use serde_json::Value;

use buffr_core::{DownloadNotice, DownloadNoticeKind, DownloadNoticeQueue};
use buffr_downloads::{DownloadId, Downloads};
use buffr_engine::{PermissionsQueue, SharedOsrFrame, SharedOsrViewState};
use buffr_permissions::Capability;

use crate::context_menu::ContextMenuSink;

use crate::cdp::{
    CdpCommand, CdpMessage, DispatchKeyEventParams, DispatchMouseEventParams, NavigateParams,
    ScreencastFrameAckParams, SetDeviceMetricsParams, StartScreencastParams,
};
use crate::error::BlinkError;
use crate::ws::WsClient;

// ── URL update sink (P0-1) ────────────────────────────────────────────────────

/// Queue written by the worker when `Page.frameNavigated` fires, drained by
/// the engine in `pump_address_changes`.
///
/// Each entry is `(session_id, url, title)`.
pub type UrlUpdateSink = Arc<Mutex<VecDeque<(String, String, String)>>>;

/// Create a new [`UrlUpdateSink`].
pub fn new_url_update_sink() -> UrlUpdateSink {
    Arc::new(Mutex::new(VecDeque::new()))
}

// ── Live title map (P2-5) ─────────────────────────────────────────────────────

/// Map written by the worker when `Target.targetInfoChanged` fires.
///
/// Keyed by `target_id`; value is the latest page title reported by Chromium.
/// The engine reads this in `tabs_summary` / `active_tab` to serve live titles
/// without waiting for `Page.frameNavigated`.
pub type TitleMap = Arc<Mutex<HashMap<String, String>>>;

/// Create a new [`TitleMap`].
pub fn new_title_map() -> TitleMap {
    Arc::new(Mutex::new(HashMap::new()))
}

// ── Commands sent to the worker ───────────────────────────────────────────────

/// Commands the engine sends to the worker thread.
pub enum Command {
    /// Issue a CDP command on the browser-level connection and return the response.
    BrowserCmd {
        cmd: CdpCommand,
        reply: Sender<Result<Value, BlinkError>>,
    },
    /// Issue a CDP command on a specific session and return the response.
    SessionCmd {
        session_id: String,
        cmd: CdpCommand,
        reply: Sender<Result<Value, BlinkError>>,
    },
    /// Navigate the active tab to `url`.
    ///
    /// Reply type is `Result<Value, BlinkError>` — same as `SessionCmd` — so the
    /// worker can insert the sender directly into the `pending` map without
    /// spawning a type-converting thread.  Callers map `Ok(_) → Ok(())`.
    Navigate {
        session_id: String,
        url: String,
        reply: Sender<Result<Value, BlinkError>>,
    },
    /// Resize the viewport for a tab and restart screencast with new dimensions.
    Resize {
        session_id: String,
        width: u32,
        height: u32,
    },
    /// Forward a mouse event to the active tab.
    MouseEvent {
        session_id: String,
        params: DispatchMouseEventParams,
    },
    /// Forward a key event to the active tab.
    KeyEvent {
        session_id: String,
        params: DispatchKeyEventParams,
    },
    /// Apply a CSS zoom level to the given tab session via `Runtime.evaluate`.
    ///
    /// `level` is the linear scale factor (e.g. `1.25` = 125 %).
    SetZoom { session_id: String, level: f64 },
    /// Switch the "active" screencast session.
    ///
    /// Sends `Page.stopScreencast` on the previous session (if any) and
    /// `Page.startScreencast` on the new one.  `None` stops all screencasting.
    SetActiveSession {
        session_id: Option<String>,
        /// Viewport dimensions at the time of the switch (for startScreencast).
        width: u32,
        height: u32,
    },
    /// Shutdown the worker cleanly.
    Shutdown,
}

// ── Worker ────────────────────────────────────────────────────────────────────

/// Timeout waiting for a CDP response (per command).
///
/// 10 s is generous enough to survive a slow remote page load while still
/// surfacing a hung Chromium within a user-visible timeframe.
pub const CDP_RESPONSE_TIMEOUT_SECS: u64 = 10;

/// Capacity of the engine→worker command channel.
///
/// 256 slots allows the engine to queue one command per open tab (realistic
/// max session count) plus headroom for concurrent resize/zoom/navigate
/// bursts without blocking the UI thread.
pub const WORKER_CMD_CHANNEL_CAP: usize = 256;

/// Run the CDP worker event loop (blocking; call from a dedicated thread).
#[allow(clippy::too_many_arguments)]
pub fn run(
    mut ws: WsClient,
    cmd_rx: Receiver<Command>,
    osr_frame: SharedOsrFrame,
    osr_view: SharedOsrViewState,
    permissions_queue: PermissionsQueue,
    perm_session_map: Arc<Mutex<HashMap<String, String>>>,
    downloads: Option<Arc<Downloads>>,
    notice_queue: Option<DownloadNoticeQueue>,
    download_dir: PathBuf,
    context_menu_sink: ContextMenuSink,
    url_update_sink: UrlUpdateSink,
    // P1-5: per-session loading flag. `true` = page loading, `false` = load complete.
    loading_state: Arc<Mutex<HashMap<String, bool>>>,
    // P1-5: per-session navigation count. Incremented on each `Page.frameNavigated` event.
    nav_count: Arc<Mutex<HashMap<String, usize>>>,
    // P2-5: live tab title map. The worker writes target_id → title on
    // `Target.targetInfoChanged`; the engine reads it in tabs_summary.
    title_map: TitleMap,
) {
    // Map from CDP message-id → reply sender.
    let mut pending: HashMap<u64, Sender<Result<Value, BlinkError>>> = HashMap::new();
    // Current active screencast session.
    let mut active_session: Option<String> = None;
    // Per-session zoom levels (re-applied after each navigation).
    let mut session_zoom: HashMap<String, f64> = HashMap::new();
    // Map from CDP download guid → (Downloads row id, suggested filename).
    // Storing the filename here avoids a separate store lookup in downloadProgress (P0-6).
    let mut download_ids: HashMap<String, (DownloadId, String)> = HashMap::new();

    tracing::debug!("CDP worker started");

    loop {
        // ── Drain commands ────────────────────────────────────────────────────
        loop {
            match cmd_rx.try_recv() {
                Ok(Command::Shutdown) => {
                    tracing::debug!("CDP worker: shutdown command received");
                    return;
                }
                Ok(Command::SetActiveSession {
                    session_id,
                    width,
                    height,
                }) => {
                    // Stop the old screencast.
                    if let Some(ref old) = active_session {
                        send_stop_screencast(&mut ws, old);
                    }
                    active_session = session_id;
                    // Start the new one.
                    if let Some(ref new_sess) = active_session {
                        send_start_screencast(&mut ws, new_sess, width.max(1), height.max(1));
                    }
                }
                Ok(Command::Navigate {
                    session_id,
                    url,
                    reply,
                }) => {
                    // Route through the same pending map as SessionCmd — no
                    // extra thread needed.  The reply sender accepts
                    // `Result<Value, BlinkError>` and callers map Ok(_) → Ok(()).
                    let cmd = CdpCommand::new("Page.navigate", NavigateParams { url: &url })
                        .with_session(session_id);
                    let id = cmd.id;
                    if let Err(e) = ws.send_text(cmd.serialize()) {
                        let _ = reply.send(Err(e));
                        continue;
                    }
                    pending.insert(id, reply);
                }
                Ok(Command::Resize {
                    session_id,
                    width,
                    height,
                }) => {
                    // Update device metrics.
                    let cmd = CdpCommand::new(
                        "Page.setDeviceMetricsOverride",
                        SetDeviceMetricsParams {
                            width,
                            height,
                            device_scale_factor: 1.0,
                            mobile: false,
                        },
                    )
                    .with_session(session_id.clone());
                    let _ = ws.send_text(cmd.serialize());

                    // Restart screencast at the new dimensions if this is the
                    // active session.
                    if active_session.as_deref() == Some(&session_id) {
                        send_stop_screencast(&mut ws, &session_id);
                        send_start_screencast(&mut ws, &session_id, width.max(1), height.max(1));
                    }
                }
                Ok(Command::MouseEvent { session_id, params }) => {
                    let cmd = CdpCommand::new("Input.dispatchMouseEvent", params)
                        .with_session(session_id);
                    let _ = ws.send_text(cmd.serialize());
                }
                Ok(Command::KeyEvent { session_id, params }) => {
                    let cmd =
                        CdpCommand::new("Input.dispatchKeyEvent", params).with_session(session_id);
                    let _ = ws.send_text(cmd.serialize());
                }
                Ok(Command::SetZoom { session_id, level }) => {
                    // P2-6: fall back to documentElement for pages without <body> (XML, SVG, about:blank).
                    let expr = format!(
                        "(document.body || document.documentElement).style.zoom = '{level}'"
                    );
                    let cmd = CdpCommand::new(
                        "Runtime.evaluate",
                        serde_json::json!({ "expression": expr }),
                    )
                    .with_session(session_id.clone());
                    let _ = ws.send_text(cmd.serialize());
                    if (level - 1.0_f64).abs() < f64::EPSILON {
                        session_zoom.remove(&session_id);
                    } else {
                        session_zoom.insert(session_id, level);
                    }
                }
                Ok(Command::BrowserCmd { cmd, reply }) => {
                    let id = cmd.id;
                    if let Err(e) = ws.send_text(cmd.serialize()) {
                        let _ = reply.send(Err(e));
                        continue;
                    }
                    pending.insert(id, reply);
                }
                Ok(Command::SessionCmd {
                    session_id,
                    cmd,
                    reply,
                }) => {
                    let cmd = cmd.with_session(session_id);
                    let id = cmd.id;
                    if let Err(e) = ws.send_text(cmd.serialize()) {
                        let _ = reply.send(Err(e));
                        continue;
                    }
                    pending.insert(id, reply);
                }
                Err(mpsc::TryRecvError::Empty) => break,
                Err(mpsc::TryRecvError::Disconnected) => {
                    tracing::debug!("CDP worker: command channel closed — exiting");
                    return;
                }
            }
        }

        // ── Read one WS message (non-blocking) ────────────────────────────────
        match ws.try_recv_text() {
            Ok(None) => {
                // No message ready — yield briefly to avoid a hot spin.
                std::thread::sleep(Duration::from_millis(crate::ws::WS_POLL_INTERVAL_MS));
                continue;
            }
            Err(e) => {
                tracing::warn!(error = %e, "CDP worker: WS read error — exiting");
                for (_, tx) in pending.drain() {
                    let _ = tx.send(Err(BlinkError::WsIo(e.to_string())));
                }
                return;
            }
            Ok(Some(text)) => match serde_json::from_str::<CdpMessage>(&text) {
                Err(e) => {
                    tracing::debug!(error = %e, raw = %text, "CDP worker: unparse-able message");
                }
                Ok(msg) => {
                    dispatch_message(
                        msg,
                        &mut pending,
                        &session_zoom,
                        &mut ws,
                        &osr_frame,
                        &osr_view,
                        &permissions_queue,
                        &perm_session_map,
                        downloads.as_deref(),
                        notice_queue.as_ref(),
                        &download_dir,
                        &mut download_ids,
                        &context_menu_sink,
                        &url_update_sink,
                        &loading_state,
                        &nav_count,
                        &title_map,
                    );
                }
            },
        }
    }
}

// ── Screencast helpers ────────────────────────────────────────────────────────

fn send_start_screencast(ws: &mut WsClient, session_id: &str, width: u32, height: u32) {
    let cmd = CdpCommand::new(
        "Page.startScreencast",
        StartScreencastParams {
            format: "png",
            quality: 100,
            max_width: width,
            max_height: height,
            every_nth_frame: 1,
        },
    )
    .with_session(session_id.to_owned());
    tracing::debug!(session_id, width, height, "CDP: startScreencast");
    let _ = ws.send_text(cmd.serialize());
}

fn send_stop_screencast(ws: &mut WsClient, session_id: &str) {
    let cmd = CdpCommand::new_bare("Page.stopScreencast").with_session(session_id.to_owned());
    tracing::debug!(session_id, "CDP: stopScreencast");
    let _ = ws.send_text(cmd.serialize());
}

// ── Message dispatch ──────────────────────────────────────────────────────────

#[allow(clippy::too_many_arguments)]
fn dispatch_message(
    msg: CdpMessage,
    pending: &mut HashMap<u64, Sender<Result<Value, BlinkError>>>,
    session_zoom: &HashMap<String, f64>,
    ws: &mut WsClient,
    osr_frame: &SharedOsrFrame,
    _osr_view: &SharedOsrViewState,
    permissions_queue: &PermissionsQueue,
    perm_session_map: &Arc<Mutex<HashMap<String, String>>>,
    downloads: Option<&Downloads>,
    notice_queue: Option<&DownloadNoticeQueue>,
    download_dir: &Path,
    download_ids: &mut HashMap<String, (DownloadId, String)>,
    context_menu_sink: &ContextMenuSink,
    url_update_sink: &UrlUpdateSink,
    loading_state: &Arc<Mutex<HashMap<String, bool>>>,
    nav_count: &Arc<Mutex<HashMap<String, usize>>>,
    title_map: &TitleMap,
) {
    // Command response.
    if let Some(id) = msg.id {
        if let Some(tx) = pending.remove(&id) {
            let result = if let Some(err) = msg.error {
                Err(BlinkError::Protocol(format!(
                    "CDP error {}: {}",
                    err.code, err.message
                )))
            } else {
                Ok(msg.result.unwrap_or(Value::Null))
            };
            let _ = tx.send(result);
        }
        return;
    }

    // Unsolicited event.
    let Some(ref method) = msg.method else {
        return;
    };
    tracing::debug!(method, "CDP event");

    match method.as_str() {
        "Page.screencastFrame" => {
            handle_screencast_frame(&msg, ws, osr_frame);
        }
        "Page.frameNavigated" => {
            // Re-apply zoom after each navigation.
            if let Some(ref session_id) = msg.session_id
                && let Some(&level) = session_zoom.get(session_id)
            {
                // P2-6: fall back to documentElement for pages without <body> (XML, SVG, about:blank).
                let expr =
                    format!("(document.body || document.documentElement).style.zoom = '{level}'");
                let cmd = CdpCommand::new(
                    "Runtime.evaluate",
                    serde_json::json!({ "expression": expr }),
                )
                .with_session(session_id.clone());
                let _ = ws.send_text(cmd.serialize());
            }
            // P0-1: propagate frame url + title to EngineState so the address bar
            // stays current after in-page navigations, pushState, and redirects.
            // The engine's original_urls map takes precedence for display (buffr://,
            // view-source:, etc.) but this keeps CdpTab::url/title up to date for
            // tabs that navigate normally.
            if let Some(ref session_id) = msg.session_id
                && let Some(ref params) = msg.params
            {
                // The navigated frame is nested under params.frame.
                if let Some(frame) = params.get("frame") {
                    let url = frame
                        .get("url")
                        .and_then(|v| v.as_str())
                        .unwrap_or("")
                        .to_owned();
                    let title = frame
                        .get("name")
                        .and_then(|v| v.as_str())
                        .unwrap_or("")
                        .to_owned();
                    if !url.is_empty() {
                        tracing::debug!(
                            session_id,
                            url,
                            title,
                            "CDP: Page.frameNavigated — pushing url update"
                        );
                        if let Ok(mut sink) = url_update_sink.lock() {
                            sink.push_back((session_id.clone(), url, title));
                        }
                    }
                }

                // P1-5: increment navigation count for this session so
                // can_go_back has a signal after the first real navigation.
                if let Ok(mut map) = nav_count.lock() {
                    *map.entry(session_id.clone()).or_insert(0) += 1;
                    tracing::debug!(
                        session_id,
                        count = map.get(session_id).copied().unwrap_or(0),
                        "CDP: Page.frameNavigated — nav_count bumped"
                    );
                }
            }
        }
        "Page.lifecycleEvent" => {
            // P1-5: track per-session loading state.
            // `name` values from Chromium: "init", "DOMContentLoaded", "load".
            // We set loading=true on "init" (page starts loading) and
            // loading=false on "load" (page fully loaded).
            if let Some(ref session_id) = msg.session_id
                && let Some(ref params) = msg.params
            {
                let event_name = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
                tracing::debug!(session_id, event_name, "CDP: Page.lifecycleEvent");
                match event_name {
                    "init" | "commit" => {
                        if let Ok(mut map) = loading_state.lock() {
                            map.insert(session_id.clone(), true);
                        }
                    }
                    "load" => {
                        if let Ok(mut map) = loading_state.lock() {
                            map.insert(session_id.clone(), false);
                        }
                    }
                    _ => {}
                }
            }
        }
        "Runtime.bindingCalled" => {
            // Phase 8a (#88): handle permission binding calls from the JS shim.
            if let Some(ref params) = msg.params {
                let name = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
                if name == "__buffrPermissionRequest" {
                    let payload = params.get("payload").and_then(|v| v.as_str()).unwrap_or("");
                    handle_permission_binding(
                        payload,
                        msg.session_id.as_deref(),
                        permissions_queue,
                        perm_session_map,
                    );
                } else if name == "__buffrContextMenu" {
                    // Phase 8c (#87): context-menu hit-test from the JS shim.
                    let payload = params.get("payload").and_then(|v| v.as_str()).unwrap_or("");
                    handle_context_menu_binding(payload, context_menu_sink);
                }
            }
        }
        "Browser.downloadWillBegin" => {
            if let Some(ref params) = msg.params {
                handle_download_will_begin(
                    params,
                    downloads,
                    notice_queue,
                    download_dir,
                    download_ids,
                );
            }
        }
        "Browser.downloadProgress" => {
            if let Some(ref params) = msg.params {
                handle_download_progress(
                    params,
                    downloads,
                    notice_queue,
                    download_dir,
                    download_ids,
                );
            }
        }
        // P2-5: live tab title via Target.targetInfoChanged.
        //
        // Chromium fires this on the browser-level session (no session_id) whenever
        // a target's title or URL changes — e.g., after `<title>` updates,
        // pushState, or redirect completion.  We record target_id → title in
        // `title_map` so the engine can serve live titles without a separate
        // CDP round-trip.
        "Target.targetInfoChanged" => {
            if let Some(ref params) = msg.params
                && let Some(info) = params.get("targetInfo")
            {
                let target_id = info
                    .get("targetId")
                    .and_then(|v| v.as_str())
                    .unwrap_or("")
                    .to_owned();
                let title = info
                    .get("title")
                    .and_then(|v| v.as_str())
                    .unwrap_or("")
                    .to_owned();
                if !target_id.is_empty() {
                    tracing::debug!(
                        target_id,
                        title,
                        "CDP: Target.targetInfoChanged — updating live title"
                    );
                    if let Ok(mut map) = title_map.lock() {
                        map.insert(target_id, title);
                    }
                }
            }
        }
        _ => {}
    }
}

/// Handle a `Runtime.bindingCalled` event for `__buffrPermissionRequest`.
///
/// Parses the JSON payload from the JS shim, maps the capability string to a
/// [`Capability`], pushes a neutral [`buffr_engine::permissions::PendingPermission`]
/// onto the queue, and records the `resolve_id → session_id` mapping so
/// `resolve_permission` can target the right tab.
fn handle_permission_binding(
    payload: &str,
    session_id: Option<&str>,
    permissions_queue: &PermissionsQueue,
    perm_session_map: &Arc<Mutex<HashMap<String, String>>>,
) {
    let v: serde_json::Value = match serde_json::from_str(payload) {
        Ok(v) => v,
        Err(e) => {
            tracing::debug!(error = %e, payload, "blink-cdp: invalid permission binding payload");
            return;
        }
    };

    let id = match v.get("id").and_then(|v| v.as_str()) {
        Some(s) => s.to_owned(),
        None => {
            tracing::debug!("blink-cdp: permission binding payload missing 'id'");
            return;
        }
    };
    let cap_str = v.get("capability").and_then(|v| v.as_str()).unwrap_or("");
    let origin = v
        .get("origin")
        .and_then(|v| v.as_str())
        .unwrap_or("")
        .to_owned();

    let cap: Capability =
        crate::permissions::capability_from_str(cap_str).unwrap_or(Capability::Other(0));

    tracing::debug!(
        id,
        cap_str,
        origin,
        "blink-cdp: permission request from JS shim"
    );

    // Record resolve_id → session_id.
    if let Some(sess) = session_id
        && let Ok(mut map) = perm_session_map.lock()
    {
        map.insert(id.clone(), sess.to_owned());
    }

    // Push neutral entry to the queue.
    let perm = buffr_engine::permissions::PendingPermission {
        origin,
        capabilities: vec![cap],
        resolve_id: Some(id),
    };
    if let Ok(mut q) = permissions_queue.lock() {
        q.push_back(perm);
    }
}

/// Handle a `Runtime.bindingCalled` event for `__buffrContextMenu`.
///
/// Parses the JSON payload from the JS hit-test shim and pushes a neutral
/// [`buffr_engine::ContextMenuRequest`] onto the context-menu sink so the
/// UI thread can drain and display it.
fn handle_context_menu_binding(payload: &str, context_menu_sink: &ContextMenuSink) {
    match crate::context_menu::parse_context_menu_binding(payload) {
        Some(req) => {
            tracing::debug!(
                x = req.x,
                y = req.y,
                page_url = %req.page_url,
                media_type = ?req.media_type,
                "blink-cdp: context-menu request from JS shim"
            );
            if let Ok(mut q) = context_menu_sink.lock() {
                q.push_back(req);
            }
        }
        None => {
            tracing::debug!(payload, "blink-cdp: invalid context-menu binding payload");
        }
    }
}

// ── Download event handlers ───────────────────────────────────────────────────

/// Handle `Browser.downloadWillBegin` — a download has started.
///
/// Inserts a row into the downloads store as `InFlight` and pushes a
/// `Started` notice onto the notice queue.  The CDP guid is mapped to the
/// store's `DownloadId` and suggested filename so progress events can update
/// the right row and populate notices with the correct filename (P0-6).
fn handle_download_will_begin(
    params: &Value,
    downloads: Option<&Downloads>,
    notice_queue: Option<&DownloadNoticeQueue>,
    download_dir: &Path,
    download_ids: &mut HashMap<String, (DownloadId, String)>,
) {
    let guid = match params.get("guid").and_then(|v| v.as_str()) {
        Some(s) => s.to_owned(),
        None => {
            tracing::debug!("downloadWillBegin: missing guid");
            return;
        }
    };
    let url = params
        .get("url")
        .and_then(|v| v.as_str())
        .unwrap_or("")
        .to_owned();
    let filename = params
        .get("suggestedFilename")
        .and_then(|v| v.as_str())
        .unwrap_or("")
        .to_owned();
    let target_path = download_dir.join(&filename);

    tracing::debug!(
        guid,
        url,
        filename,
        path = %target_path.display(),
        "blink-cdp: downloadWillBegin"
    );

    // We use a synthetic numeric id derived from the guid hash as the
    // `cef_id` placeholder.  The schema requires a `cef_id u32` as a
    // unique key; for blink-cdp we use a stable hash of the guid string
    // so that repeated calls with the same guid are idempotent (matching
    // the `record_started` no-op guarantee).
    let cef_id = guid_to_cef_id(&guid);

    if let Some(store) = downloads {
        match store.record_started(cef_id, &url, &filename, None, None) {
            Ok(id) => {
                // P0-6: store (row_id, filename) so downloadProgress can build the full path.
                download_ids.insert(guid.clone(), (id, filename.clone()));
                tracing::debug!(guid, row_id = id.0, "blink-cdp: download row inserted");
            }
            Err(e) => {
                tracing::warn!(guid, error = %e, "blink-cdp: record_started failed");
            }
        }
    }

    if let Some(queue) = notice_queue {
        buffr_core::push_download_notice(
            queue,
            DownloadNotice {
                kind: DownloadNoticeKind::Started,
                filename,
                path: target_path.to_string_lossy().into_owned(),
                created_at: Instant::now(),
            },
        );
    }
}

/// Handle `Browser.downloadProgress` — progress tick or terminal state.
///
/// Updates progress on the matching store row; on terminal states
/// (`completed` / `canceled`) flips the row status and pushes a notice.
/// P0-6: uses the filename stored in `download_ids` to populate notice fields
/// and constructs the full path via `download_dir.join(filename)`.
fn handle_download_progress(
    params: &Value,
    downloads: Option<&Downloads>,
    notice_queue: Option<&DownloadNoticeQueue>,
    download_dir: &Path,
    download_ids: &mut HashMap<String, (DownloadId, String)>,
) {
    let guid = match params.get("guid").and_then(|v| v.as_str()) {
        Some(s) => s.to_owned(),
        None => {
            tracing::debug!("downloadProgress: missing guid");
            return;
        }
    };
    let state = params
        .get("state")
        .and_then(|v| v.as_str())
        .unwrap_or("inProgress");
    let received = params
        .get("receivedBytes")
        .and_then(|v| v.as_f64())
        .map(|f| f as u64)
        .unwrap_or(0);
    let total = params
        .get("totalBytes")
        .and_then(|v| v.as_f64())
        .filter(|&f| f > 0.0)
        .map(|f| f as u64);

    tracing::debug!(guid, state, received, "blink-cdp: downloadProgress");

    let (row_id, filename) = match download_ids.get(&guid) {
        Some(entry) => (entry.0, entry.1.clone()),
        None => {
            tracing::debug!(
                guid,
                "blink-cdp: downloadProgress — no row for guid (ignoring)"
            );
            return;
        }
    };

    match state {
        "inProgress" => {
            if let Some(store) = downloads
                && let Err(e) = store.update_progress(row_id, received, total)
            {
                tracing::warn!(guid, error = %e, "blink-cdp: update_progress failed");
            }
        }
        "completed" => {
            // P0-6: construct the full path from the stored suggested filename.
            let full_path = download_dir.join(&filename);
            if let Some(store) = downloads
                && let Err(e) = store.record_completed(row_id, &full_path)
            {
                tracing::warn!(guid, error = %e, "blink-cdp: record_completed failed");
            }
            download_ids.remove(&guid);
            if let Some(queue) = notice_queue {
                buffr_core::push_download_notice(
                    queue,
                    DownloadNotice {
                        kind: DownloadNoticeKind::Completed,
                        filename: filename.clone(),
                        path: full_path.to_string_lossy().into_owned(),
                        created_at: Instant::now(),
                    },
                );
            }
        }
        "canceled" => {
            // P0-6: still populate filename + full path even on cancellation.
            let full_path = download_dir.join(&filename);
            if let Some(store) = downloads
                && let Err(e) = store.record_canceled(row_id)
            {
                tracing::warn!(guid, error = %e, "blink-cdp: record_canceled failed");
            }
            download_ids.remove(&guid);
            if let Some(queue) = notice_queue {
                buffr_core::push_download_notice(
                    queue,
                    DownloadNotice {
                        kind: DownloadNoticeKind::Failed,
                        filename: filename.clone(),
                        path: full_path.to_string_lossy().into_owned(),
                        created_at: Instant::now(),
                    },
                );
            }
        }
        other => {
            tracing::debug!(guid, state = other, "blink-cdp: unknown download state");
        }
    }
}

/// Derive a stable `u32` cef_id from a CDP download guid string.
///
/// The `downloads` schema requires a `cef_id` unique key of type `u32`.
/// For blink-cdp we have a GUID string, not an integer id.  We hash the
/// guid with FNV-1a (no dep needed — just a loop) to produce a stable u32.
/// Collisions are theoretically possible but negligible in practice — a
/// session will rarely have 2^32 concurrent downloads.
fn guid_to_cef_id(guid: &str) -> u32 {
    // FNV-1a 32-bit hash.
    let mut hash: u32 = 2_166_136_261;
    for byte in guid.bytes() {
        hash ^= u32::from(byte);
        hash = hash.wrapping_mul(16_777_619);
    }
    hash
}

fn handle_screencast_frame(msg: &CdpMessage, ws: &mut WsClient, osr_frame: &SharedOsrFrame) {
    let params = match &msg.params {
        Some(p) => p,
        None => {
            tracing::debug!("screencastFrame: missing params");
            return;
        }
    };

    let data_str = match params.get("data").and_then(|v| v.as_str()) {
        Some(s) => s,
        None => {
            tracing::debug!("screencastFrame: missing data field");
            return;
        }
    };

    // The `sessionId` in the screencast frame params is a CDP screencast
    // sequence number (i64), not the session string.
    let screencast_session_id = params
        .get("sessionId")
        .and_then(|v| v.as_i64())
        .unwrap_or(0);

    // Decode and write frame.
    decode_and_write_frame(data_str, osr_frame);

    // Must ack every frame or Chromium stalls the screencast.
    let ack = CdpCommand::new(
        "Page.screencastFrameAck",
        ScreencastFrameAckParams {
            session_id: screencast_session_id,
        },
    );
    // Ack is session-scoped: use the session_id from the enclosing CdpMessage.
    let ack = match &msg.session_id {
        Some(s) => ack.with_session(s.clone()),
        None => ack,
    };
    tracing::debug!(screencast_session_id, "CDP: screencastFrameAck");
    let _ = ws.send_text(ack.serialize());
}

// ── Frame decode ──────────────────────────────────────────────────────────────

/// Decode a base64-encoded PNG into BGRA and write it to `osr_frame`.
///
/// Exposed as `pub(crate)` for unit tests.
pub(crate) fn decode_and_write_frame(b64: &str, osr_frame: &SharedOsrFrame) {
    let data = match base64::engine::general_purpose::STANDARD.decode(b64) {
        Ok(d) => d,
        Err(e) => {
            tracing::debug!(error = %e, "screencastFrame base64 decode failed");
            return;
        }
    };

    let img = match image::load_from_memory_with_format(&data, image::ImageFormat::Png) {
        Ok(i) => i,
        Err(e) => {
            tracing::debug!(error = %e, "screencastFrame PNG decode failed");
            return;
        }
    };

    let rgba = img.into_rgba8();
    let width = rgba.width();
    let height = rgba.height();
    // Convert RGBA → BGRA (the OsrFrame pixel format).
    let mut bgra = rgba.into_raw();
    for chunk in bgra.chunks_exact_mut(4) {
        chunk.swap(0, 2); // R ↔ B
    }

    if let Ok(mut frame) = osr_frame.lock() {
        frame.width = width;
        frame.height = height;
        frame.pixels = bgra;
        frame.generation = frame.generation.wrapping_add(1);
        frame.needs_fresh = false;
        tracing::debug!(
            width,
            height,
            generation = frame.generation,
            "OSR frame updated"
        );
    }
}

// ── Tests ─────────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use std::sync::{Arc, Mutex};

    use base64::Engine as _;

    use buffr_engine::OsrFrame;

    use super::*;

    // Build a 2×2 solid-colour PNG in memory and return it.
    fn make_png_bytes(r: u8, g: u8, b: u8) -> Vec<u8> {
        use image::{ImageBuffer, Rgba};
        let img: ImageBuffer<Rgba<u8>, Vec<u8>> =
            ImageBuffer::from_fn(2, 2, |_, _| Rgba([r, g, b, 255]));
        let mut buf = std::io::Cursor::new(Vec::new());
        img.write_to(&mut buf, image::ImageFormat::Png)
            .expect("encode png");
        buf.into_inner()
    }

    #[test]
    fn screencast_frame_decode_writes_bgra() {
        // Build a 2×2 red PNG (RGBA = [255, 0, 0, 255]).
        let png_bytes = make_png_bytes(255, 0, 0);
        let b64 = base64::engine::general_purpose::STANDARD.encode(&png_bytes);

        let osr_frame: SharedOsrFrame = Arc::new(Mutex::new(OsrFrame::new(1, 1)));
        decode_and_write_frame(&b64, &osr_frame);

        let frame = osr_frame.lock().unwrap();
        assert_eq!(frame.width, 2);
        assert_eq!(frame.height, 2);
        // RGBA [255, 0, 0, 255] → BGRA [0, 0, 255, 255]
        assert_eq!(&frame.pixels[0..4], &[0u8, 0, 255, 255], "BGRA swap");
        // All 4 pixels identical.
        for chunk in frame.pixels.chunks_exact(4) {
            assert_eq!(chunk, &[0u8, 0, 255, 255]);
        }
        assert_eq!(frame.generation, 1);
        assert!(!frame.needs_fresh);
    }

    #[test]
    fn screencast_ack_message_shape() {
        // Verify the JSON shape of a screencastFrameAck message.
        let ack = CdpCommand::new(
            "Page.screencastFrameAck",
            ScreencastFrameAckParams { session_id: 42 },
        )
        .with_session("sess-abc".to_owned());

        let json = ack.serialize();
        let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON");

        assert_eq!(v["method"], "Page.screencastFrameAck");
        assert_eq!(v["params"]["sessionId"], 42);
        assert_eq!(v["sessionId"], "sess-abc");
        assert!(v["id"].as_u64().unwrap_or(0) > 0);
    }

    #[test]
    fn decode_bad_base64_is_silent() {
        let osr_frame: SharedOsrFrame = Arc::new(Mutex::new(OsrFrame::new(4, 4)));
        decode_and_write_frame("not-valid-base64!!!", &osr_frame);
        // Frame should be untouched.
        let frame = osr_frame.lock().unwrap();
        assert_eq!(frame.generation, 0);
    }

    // ── P0-6: download_ids stores (DownloadId, filename) ────────────────────

    /// Verify the new `download_ids` map type stores both id and filename.
    #[test]
    fn download_ids_map_tuple_stores_filename() {
        use buffr_downloads::DownloadId;
        let mut download_ids: HashMap<String, (DownloadId, String)> = HashMap::new();

        // Simulate handle_download_will_begin inserting a row.
        download_ids.insert(
            "guid-abc".to_owned(),
            (DownloadId(1), "report.pdf".to_owned()),
        );

        let (id, filename) = download_ids.get("guid-abc").cloned().unwrap();
        assert_eq!(id, DownloadId(1));
        assert_eq!(filename, "report.pdf");
    }

    /// Full-path construction: download_dir.join(filename) builds a correct path.
    #[test]
    fn download_progress_full_path_construction() {
        use std::path::Path;
        let download_dir = Path::new("/home/user/Downloads");
        let filename = "video.mp4";
        let full_path = download_dir.join(filename);
        let expected = download_dir.join("video.mp4");
        assert_eq!(full_path, expected);
    }

    // ── P0-1: url_update_sink push/drain ─────────────────────────────────────

    /// Verify the sink can hold and drain multiple entries FIFO.
    #[test]
    fn url_update_sink_fifo_order() {
        let sink = new_url_update_sink();
        {
            let mut guard = sink.lock().unwrap();
            guard.push_back(("s1".into(), "https://a.example".into(), "A".into()));
            guard.push_back(("s2".into(), "https://b.example".into(), "B".into()));
        }
        let items: Vec<_> = sink.lock().unwrap().drain(..).collect();
        assert_eq!(items[0].0, "s1");
        assert_eq!(items[1].0, "s2");
        // After drain the sink is empty.
        assert!(sink.lock().unwrap().is_empty());
    }

    // ── P2-8: dispatch_message routing tests ──────────────────────────────────

    /// Build shared test fixtures used by multiple dispatch_message routing tests.
    #[allow(clippy::type_complexity)]
    fn make_test_sinks() -> (
        PermissionsQueue,
        Arc<Mutex<HashMap<String, String>>>,
        ContextMenuSink,
        UrlUpdateSink,
        Arc<Mutex<HashMap<String, bool>>>,
        Arc<Mutex<HashMap<String, usize>>>,
        TitleMap,
        SharedOsrFrame,
        SharedOsrViewState,
    ) {
        use buffr_engine::{OsrFrame, OsrViewState};
        (
            buffr_engine::permissions::new_queue(),
            Arc::new(Mutex::new(HashMap::new())),
            crate::context_menu::new_context_menu_sink(),
            new_url_update_sink(),
            Arc::new(Mutex::new(HashMap::new())),
            Arc::new(Mutex::new(HashMap::new())),
            new_title_map(),
            Arc::new(Mutex::new(OsrFrame::new(1, 1))),
            Arc::new(OsrViewState::new()),
        )
    }

    /// Helper: build a CdpMessage for an unsolicited event.
    fn make_event(method: &str, params: serde_json::Value) -> CdpMessage {
        serde_json::from_str(
            &serde_json::to_string(&serde_json::json!({
                "method": method,
                "params": params,
            }))
            .unwrap(),
        )
        .unwrap()
    }

    /// Helper: build a session-scoped event CdpMessage.
    fn make_session_event(method: &str, session_id: &str, params: serde_json::Value) -> CdpMessage {
        serde_json::from_str(
            &serde_json::to_string(&serde_json::json!({
                "method": method,
                "sessionId": session_id,
                "params": params,
            }))
            .unwrap(),
        )
        .unwrap()
    }

    // ── P2-8a: Runtime.bindingCalled → permission queue ──────────────────────

    /// Permission binding happy path: payload is delivered to the queue.
    #[test]
    fn dispatch_binding_called_permission_happy_path() {
        let payload = serde_json::json!({
            "id": "req-1",
            "capability": "geolocation",
            "origin": "https://example.com",
        })
        .to_string();

        let permissions_queue = buffr_engine::permissions::new_queue();
        let perm_session_map: Arc<Mutex<HashMap<String, String>>> =
            Arc::new(Mutex::new(HashMap::new()));

        handle_permission_binding(
            &payload,
            Some("sess-abc"),
            &permissions_queue,
            &perm_session_map,
        );

        // Queue should have one entry.
        let guard = permissions_queue.lock().unwrap();
        assert_eq!(guard.len(), 1, "one permission request queued");
        let perm = guard.front().unwrap();
        assert_eq!(perm.resolve_id.as_deref(), Some("req-1"));
        assert_eq!(perm.origin, "https://example.com");

        // Session map should record resolve_id → session_id.
        drop(guard);
        let sm = perm_session_map.lock().unwrap();
        assert_eq!(sm.get("req-1").map(String::as_str), Some("sess-abc"));
    }

    /// Malformed permission payload (missing id) is silently dropped.
    #[test]
    fn dispatch_binding_called_permission_malformed_no_id() {
        let payload = serde_json::json!({
            "capability": "geolocation",
            "origin": "https://example.com",
        })
        .to_string();

        let permissions_queue = buffr_engine::permissions::new_queue();
        let perm_session_map: Arc<Mutex<HashMap<String, String>>> =
            Arc::new(Mutex::new(HashMap::new()));

        handle_permission_binding(
            &payload,
            Some("sess-abc"),
            &permissions_queue,
            &perm_session_map,
        );

        // No entry should be queued.
        assert!(permissions_queue.lock().unwrap().is_empty());
    }

    // ── P2-8b: Runtime.bindingCalled → context-menu sink ─────────────────────

    /// Context-menu binding happy path: request lands in the sink.
    #[test]
    fn dispatch_binding_called_context_menu_happy_path() {
        let payload = serde_json::json!({
            "x": 100,
            "y": 200,
            "pageUrl": "https://example.com",
            "mediaType": "none",
            "linkUrl": null,
            "srcUrl": null,
            "altText": null,
        })
        .to_string();

        let sink = crate::context_menu::new_context_menu_sink();
        handle_context_menu_binding(&payload, &sink);

        let guard = sink.lock().unwrap();
        assert_eq!(guard.len(), 1, "one context-menu request queued");
        let req = guard.front().unwrap();
        assert_eq!(req.x, 100);
        assert_eq!(req.y, 200);
    }

    /// Malformed context-menu payload produces no entry in the sink.
    #[test]
    fn dispatch_binding_called_context_menu_malformed() {
        let sink = crate::context_menu::new_context_menu_sink();
        handle_context_menu_binding("not-json", &sink);
        assert!(sink.lock().unwrap().is_empty());
    }

    // ── P2-8c: Page.lifecycleEvent → loading_state ───────────────────────────

    /// `init` lifecycle event marks the session as loading.
    #[test]
    fn lifecycle_event_init_sets_loading_true() {
        let (pq, psm, cms, uu, loading_state, nav_count, tm, osr, view) = make_test_sinks();
        let _ = (pq, psm, cms, uu, nav_count, osr, view);

        let msg = make_session_event(
            "Page.lifecycleEvent",
            "sess-1",
            serde_json::json!({"name": "init"}),
        );

        // Manually replicate the lifecycle handler (can't call dispatch_message
        // without a real WsClient, so we test the state logic directly).
        if let Some(ref session_id) = msg.session_id
            && let Some(ref params) = msg.params
        {
            let event_name = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
            if event_name == "init"
                && let Ok(mut map) = loading_state.lock()
            {
                map.insert(session_id.clone(), true);
            }
        }

        let map = loading_state.lock().unwrap();
        assert_eq!(map.get("sess-1").copied(), Some(true));
        drop(map);
        drop(tm);
    }

    /// `load` lifecycle event clears the loading flag.
    #[test]
    fn lifecycle_event_load_sets_loading_false() {
        let (pq, psm, cms, uu, loading_state, nav_count, tm, osr, view) = make_test_sinks();
        let _ = (pq, psm, cms, uu, nav_count, osr, view);

        // Pre-seed loading = true.
        loading_state
            .lock()
            .unwrap()
            .insert("sess-2".to_owned(), true);

        let msg = make_session_event(
            "Page.lifecycleEvent",
            "sess-2",
            serde_json::json!({"name": "load"}),
        );

        if let Some(ref session_id) = msg.session_id
            && let Some(ref params) = msg.params
        {
            let event_name = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
            if event_name == "load"
                && let Ok(mut map) = loading_state.lock()
            {
                map.insert(session_id.clone(), false);
            }
        }

        let map = loading_state.lock().unwrap();
        assert_eq!(map.get("sess-2").copied(), Some(false));
        drop(map);
        drop(tm);
    }

    // ── P2-8d: Target.targetInfoChanged → title_map (P2-5) ───────────────────

    /// targetInfoChanged happy path: title_map updated with new title.
    #[test]
    fn target_info_changed_updates_title_map() {
        let title_map = new_title_map();

        let msg = make_event(
            "Target.targetInfoChanged",
            serde_json::json!({
                "targetInfo": {
                    "targetId": "tgt-1",
                    "title": "Hello World",
                    "url": "https://example.com",
                    "type": "page",
                }
            }),
        );

        // Run the handler logic inline (mirrors dispatch_message's arm).
        if let Some(ref params) = msg.params
            && let Some(info) = params.get("targetInfo")
        {
            let target_id = info
                .get("targetId")
                .and_then(|v| v.as_str())
                .unwrap_or("")
                .to_owned();
            let title = info
                .get("title")
                .and_then(|v| v.as_str())
                .unwrap_or("")
                .to_owned();
            if !target_id.is_empty() {
                title_map.lock().unwrap().insert(target_id, title);
            }
        }

        let map = title_map.lock().unwrap();
        assert_eq!(map.get("tgt-1").map(String::as_str), Some("Hello World"));
    }

    /// targetInfoChanged with missing targetInfo is a no-op.
    #[test]
    fn target_info_changed_missing_target_info_is_noop() {
        let title_map = new_title_map();
        let msg = make_event(
            "Target.targetInfoChanged",
            serde_json::json!({ "something": "else" }),
        );

        if let Some(ref params) = msg.params
            && let Some(info) = params.get("targetInfo")
        {
            let target_id = info
                .get("targetId")
                .and_then(|v| v.as_str())
                .unwrap_or("")
                .to_owned();
            if !target_id.is_empty() {
                title_map.lock().unwrap().insert(target_id, "x".to_owned());
            }
        }

        assert!(title_map.lock().unwrap().is_empty());
    }

    // ── P2-8e: unknown method is a no-op ─────────────────────────────────────

    /// Unknown CDP methods must not modify any shared state.
    #[test]
    fn dispatch_unknown_method_is_noop() {
        let (pq, psm, cms, uu, loading, nav, tm, _, _) = make_test_sinks();
        let msg = make_event("Some.UnknownMethod", serde_json::json!({"data": 42}));

        // None of the handler paths run for an unknown method, so sinks stay empty.
        assert_eq!(msg.method.as_deref(), Some("Some.UnknownMethod"));
        assert!(pq.lock().unwrap().is_empty());
        assert!(psm.lock().unwrap().is_empty());
        assert!(cms.lock().unwrap().is_empty());
        assert!(uu.lock().unwrap().is_empty());
        assert!(loading.lock().unwrap().is_empty());
        assert!(nav.lock().unwrap().is_empty());
        assert!(tm.lock().unwrap().is_empty());
    }

    // ── P2-8f: response routing via pending map ───────────────────────────────

    /// A message with an id routes to the matching pending sender.
    #[test]
    fn response_message_routes_to_pending_sender() {
        let mut pending: HashMap<u64, std::sync::mpsc::Sender<Result<Value, BlinkError>>> =
            HashMap::new();
        let (tx, rx) = std::sync::mpsc::channel();
        pending.insert(42, tx);

        // Simulate a response message (has an id).
        let msg: CdpMessage =
            serde_json::from_str(r#"{"id": 42, "result": {"frameId": "fr-1"}}"#).unwrap();

        // Replicate the response routing logic.
        if let Some(id) = msg.id
            && let Some(sender) = pending.remove(&id)
        {
            let result = if let Some(err) = msg.error {
                Err(BlinkError::Protocol(format!(
                    "CDP error {}: {}",
                    err.code, err.message
                )))
            } else {
                Ok(msg.result.unwrap_or(Value::Null))
            };
            let _ = sender.send(result);
        }

        // The sender should be consumed from the map.
        assert!(pending.is_empty());
        // The receiver should have the result.
        let result = rx.try_recv().unwrap();
        assert!(result.is_ok());
        assert_eq!(result.unwrap()["frameId"], "fr-1");
    }

    /// Response with an id not in the pending map is silently ignored.
    #[test]
    fn response_message_unknown_id_is_noop() {
        let mut pending: HashMap<u64, std::sync::mpsc::Sender<Result<Value, BlinkError>>> =
            HashMap::new();

        let msg: CdpMessage = serde_json::from_str(r#"{"id": 999, "result": {}}"#).unwrap();

        if let Some(id) = msg.id
            && let Some(sender) = pending.remove(&id)
        {
            let _ = sender.send(Ok(Value::Null));
        }

        // pending was empty — nothing changed.
        assert!(pending.is_empty());
    }

    // ── P2-8g: Browser.downloadWillBegin → download_ids ─────────────────────

    /// downloadWillBegin with missing guid is silently ignored.
    #[test]
    fn download_will_begin_missing_guid_is_noop() {
        let mut download_ids: HashMap<String, (buffr_downloads::DownloadId, String)> =
            HashMap::new();

        let params = serde_json::json!({
            "url": "https://example.com/file.pdf",
            "suggestedFilename": "file.pdf",
            // guid deliberately absent
        });

        handle_download_will_begin(
            &params,
            None, // no Downloads store
            None, // no notice_queue
            std::path::Path::new("/tmp"),
            &mut download_ids,
        );

        // Nothing inserted.
        assert!(download_ids.is_empty());
    }

    /// downloadProgress with unrecognised guid is silently ignored.
    #[test]
    fn download_progress_unknown_guid_is_noop() {
        let mut download_ids: HashMap<String, (buffr_downloads::DownloadId, String)> =
            HashMap::new();

        let params = serde_json::json!({
            "guid": "no-such-guid",
            "state": "inProgress",
            "receivedBytes": 1024,
            "totalBytes": 4096,
        });

        handle_download_progress(
            &params,
            None,
            None,
            std::path::Path::new("/tmp"),
            &mut download_ids,
        );

        // download_ids still empty — no panic, no insertion.
        assert!(download_ids.is_empty());
    }

    // ── P2-8h: P2-5 title_map new_title_map initialises empty ────────────────

    #[test]
    fn new_title_map_starts_empty() {
        let tm = new_title_map();
        assert!(tm.lock().unwrap().is_empty());
    }

    /// title_map survives multiple concurrent inserts.
    #[test]
    fn title_map_stores_multiple_targets() {
        let tm = new_title_map();
        {
            let mut m = tm.lock().unwrap();
            m.insert("t1".to_owned(), "Title 1".to_owned());
            m.insert("t2".to_owned(), "Title 2".to_owned());
        }
        let m = tm.lock().unwrap();
        assert_eq!(m.get("t1").map(String::as_str), Some("Title 1"));
        assert_eq!(m.get("t2").map(String::as_str), Some("Title 2"));
    }
}