lingxia-webview 0.11.1

//! WebView2 event handler registration (navigation, downloads,
//! messages, resource requests).

use super::*;
use crate::events::normalizer::{self, NativeNavigationResult, NativeSignal};
use crate::traits::{LoadError, LoadErrorKind};

/// Map a WebView2 `COREWEBVIEW2_WEB_ERROR_STATUS` to the normalized error
/// kind. Numeric values per the WebView2 SDK enum.
fn windows_load_error_kind(status: i32) -> LoadErrorKind {
    match status {
        1..=5 => LoadErrorKind::Security,
        6 | 9..=12 => LoadErrorKind::Network,
        7 => LoadErrorKind::Timeout,
        13 => LoadErrorKind::Dns,
        _ => LoadErrorKind::Unknown,
    }
}

pub(crate) fn register_event_handlers(
    env: &ICoreWebView2Environment,
    webview: &ICoreWebView2,
    webtag: WebTag,
    registered_schemes: &[String],
    memory_pages: Arc<Mutex<HashMap<String, Vec<u8>>>>,
) -> StdResult<()> {
    let started_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_NavigationStarting(
                &NavigationStartingEventHandler::create(Box::new(move |_sender, args| {
                    let Some(args) = args else {
                        return Ok(());
                    };

                    let mut uri = PWSTR::null();
                    args.Uri(&mut uri)?;
                    let uri = CoTaskMemPWSTR::from(uri).to_string();

                    let mut navigation_id = 0u64;
                    args.NavigationId(&mut navigation_id)?;

                    if let Some(webview) = find_webview(&started_tag)
                        && matches!(
                            webview.handle_navigation(&crate::NavigationRequest::new(
                                uri.clone(),
                                false,
                                true,
                            )),
                            NavigationPolicy::Cancel
                        )
                    {
                        // Policy rejected before loading: the follow-up
                        // completion for this key is expected and consumed.
                        normalizer::submit(
                            &started_tag,
                            NativeSignal::NavigationSuppressed {
                                key: Some(navigation_id),
                            },
                        );
                        args.SetCancel(true)?;
                        return Ok(());
                    }

                    // Redirect restarts reuse the native id; the tracker
                    // coalesces them into one attempt.
                    normalizer::submit(
                        &started_tag,
                        NativeSignal::NavigationStarted {
                            key: Some(navigation_id),
                            url: uri,
                        },
                    );
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| {
                WebViewError::WebView(format!("add_NavigationStarting failed: {err}"))
            })?;
    }

    let committed_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_ContentLoading(
                &ContentLoadingEventHandler::create(Box::new(move |_sender, _args| {
                    // Commit evidence: the displayed document was replaced.
                    normalizer::submit(&committed_tag, NativeSignal::DocumentCommitted);
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| WebViewError::WebView(format!("add_ContentLoading failed: {err}")))?;
    }

    let finished_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_NavigationCompleted(
                &NavigationCompletedEventHandler::create(Box::new(move |sender, args| {
                    let (Some(sender), Some(args)) = (sender, args) else {
                        return Ok(());
                    };
                    let mut navigation_id = 0u64;
                    args.NavigationId(&mut navigation_id)?;
                    let mut succeeded = BOOL::default();
                    args.IsSuccess(&mut succeeded)?;
                    let result = if succeeded.as_bool() {
                        // Final URL captured inside the callback: WebView2 COM
                        // objects are thread-affine and cannot be queried later.
                        let mut source = PWSTR::null();
                        sender.Source(&mut source)?;
                        let final_url = CoTaskMemPWSTR::from(source).to_string();
                        NativeNavigationResult::Succeeded { final_url }
                    } else {
                        let mut status = COREWEBVIEW2_WEB_ERROR_STATUS::default();
                        args.WebErrorStatus(&mut status)?;
                        // 14 = OPERATION_CANCELED: control flow, not an error.
                        if status.0 == 14 {
                            NativeNavigationResult::Cancelled(None)
                        } else {
                            NativeNavigationResult::Failed(LoadError {
                                failing_url: None,
                                kind: windows_load_error_kind(status.0),
                                description: format!("WebView2 web error status {}", status.0),
                            })
                        }
                    };
                    normalizer::submit(
                        &finished_tag,
                        NativeSignal::NavigationFinished {
                            key: Some(navigation_id),
                            result,
                        },
                    );
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| {
                WebViewError::WebView(format!("add_NavigationCompleted failed: {err}"))
            })?;
    }

    let source_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_SourceChanged(
                &SourceChangedEventHandler::create(Box::new(move |sender, _args| {
                    let Some(sender) = sender else {
                        return Ok(());
                    };
                    let mut source = PWSTR::null();
                    sender.Source(&mut source)?;
                    let source = CoTaskMemPWSTR::from(source).to_string();
                    normalizer::submit(&source_tag, NativeSignal::LocationChanged { url: source });
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| WebViewError::WebView(format!("add_SourceChanged failed: {err}")))?;
    }

    let history_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_HistoryChanged(
                &HistoryChangedEventHandler::create(Box::new(move |sender, _args| {
                    let Some(sender) = sender else {
                        return Ok(());
                    };
                    let mut can_back = BOOL::default();
                    let mut can_forward = BOOL::default();
                    sender.CanGoBack(&mut can_back)?;
                    sender.CanGoForward(&mut can_forward)?;
                    normalizer::submit(
                        &history_tag,
                        NativeSignal::BackForwardChanged {
                            can_go_back: can_back.as_bool(),
                            can_go_forward: can_forward.as_bool(),
                        },
                    );
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| WebViewError::WebView(format!("add_HistoryChanged failed: {err}")))?;
    }

    let title_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_DocumentTitleChanged(
                &DocumentTitleChangedEventHandler::create(Box::new(move |sender, _args| {
                    let Some(sender) = sender else {
                        return Ok(());
                    };
                    let mut title = PWSTR::null();
                    sender.DocumentTitle(&mut title)?;
                    let title = CoTaskMemPWSTR::from(title).to_string();
                    if !title.is_empty() {
                        normalizer::submit(
                            &title_tag,
                            NativeSignal::TitleChanged { title: Some(title) },
                        );
                    }
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| {
                WebViewError::WebView(format!("add_DocumentTitleChanged failed: {err}"))
            })?;
    }

    // Favicon change notifications need ICoreWebView2_15 (newer WebView2
    // runtimes); older runtimes simply do without favicons.
    let favicon_tag = webtag.clone();
    if let Ok(webview15) = webview.cast::<ICoreWebView2_15>() {
        let handler = FaviconChangedEventHandler::create(Box::new(move |sender, _args| {
            let Some(sender) = sender else {
                return Ok(());
            };
            let Ok(sender15) = sender.cast::<ICoreWebView2_15>() else {
                return Ok(());
            };
            let tag = favicon_tag.clone();
            unsafe {
                sender15.GetFavicon(
                    COREWEBVIEW2_FAVICON_IMAGE_FORMAT_PNG,
                    &GetFaviconCompletedHandler::create(Box::new(move |result, stream| {
                        if result.is_err() {
                            return Ok(());
                        }
                        // No stream / empty bytes = page has no favicon.
                        let png_bytes = stream
                            .as_ref()
                            .and_then(|stream| read_stream_to_end(stream).ok())
                            .filter(|bytes| !bytes.is_empty());
                        normalizer::submit(&tag, NativeSignal::FaviconChanged { png_bytes });
                        Ok(())
                    })),
                )?;
            }
            Ok(())
        }));
        let mut token = 0;
        if let Err(err) = unsafe { webview15.add_FaviconChanged(&handler, &mut token) } {
            // Favicons are cosmetic; never fail webview creation over them.
            log::warn!("add_FaviconChanged failed: {err}");
        }
    }

    let new_window_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_NewWindowRequested(
                &NewWindowRequestedEventHandler::create(Box::new(move |sender, args| {
                    let Some(args) = args else {
                        return Ok(());
                    };

                    let uri = take_request_string(|slot| args.Uri(slot))?;
                    let Some(webview) = find_webview(&new_window_tag) else {
                        args.SetHandled(true)?;
                        return Ok(());
                    };

                    match webview.handle_new_window(&uri) {
                        NewWindowPolicy::LoadInSelf => {
                            if let Some(sender) = sender {
                                let uri = CoTaskMemPWSTR::from(uri.as_str());
                                sender.Navigate(*uri.as_ref().as_pcwstr())?;
                            }
                            args.SetHandled(true)?;
                        }
                        NewWindowPolicy::Cancel => {
                            args.SetHandled(true)?;
                        }
                    }
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| {
                WebViewError::WebView(format!("add_NewWindowRequested failed: {err}"))
            })?;
    }

    let download_tag = webtag.clone();
    unsafe {
        let webview4: ICoreWebView2_4 = webview.cast().map_err(|err| {
            WebViewError::WebView(format!("WebView2_4 cast failed for downloads: {err}"))
        })?;
        let mut token = 0;
        webview4
            .add_DownloadStarting(
                &DownloadStartingEventHandler::create(Box::new(move |_sender, args| {
                    let Some(args) = args else {
                        return Ok(());
                    };
                    let Some(webview) = find_webview(&download_tag) else {
                        return Ok(());
                    };
                    if !webview.has_download_handler() {
                        return Ok(());
                    }

                    let operation = args.DownloadOperation()?;
                    let request = download_request_from_operation(&operation)?;
                    webview.handle_download(request);
                    args.SetCancel(true)?;
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| WebViewError::WebView(format!("add_DownloadStarting failed: {err}")))?;
    }

    let message_tag = webtag.clone();
    unsafe {
        let mut token = 0;
        webview
            .add_WebMessageReceived(
                &WebMessageReceivedEventHandler::create(Box::new(move |_sender, args| {
                    let Some(args) = args else {
                        return Ok(());
                    };

                    let mut message = PWSTR::null();
                    args.TryGetWebMessageAsString(&mut message)?;
                    let payload = CoTaskMemPWSTR::from(message).to_string();

                    if let Some(delegate) = find_webview_delegate(&message_tag) {
                        let _ = thread::Builder::new()
                            .name(format!("lingxia-web-message-{}", message_tag.key()))
                            .spawn(move || delegate.handle_post_message(payload));
                    }
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| {
                WebViewError::WebView(format!("add_WebMessageReceived failed: {err}"))
            })?;
    }

    for scheme in registered_request_schemes(registered_schemes) {
        let filter = format!("{scheme}://*");
        let filter = CoTaskMemPWSTR::from(filter.as_str());
        unsafe {
            webview
                .AddWebResourceRequestedFilter(
                    *filter.as_ref().as_pcwstr(),
                    COREWEBVIEW2_WEB_RESOURCE_CONTEXT_ALL,
                )
                .map_err(|err| {
                    WebViewError::WebView(format!(
                        "AddWebResourceRequestedFilter failed for {scheme}: {err}"
                    ))
                })?;
        }
    }

    let request_tag = webtag;
    let env = env.clone();
    let memory_pages = memory_pages.clone();
    let custom_schemes = webview2_custom_schemes(registered_schemes);
    unsafe {
        let mut token = 0;
        webview
            .add_WebResourceRequested(
                &WebResourceRequestedEventHandler::create(Box::new(move |_sender, args| {
                    let Some(args) = args else {
                        return Ok(());
                    };

                    let request = args.Request()?;
                    let uri = take_request_string(|slot| request.Uri(slot))?;
                    let method = take_request_string(|slot| request.Method(slot))?;
                    if let Some(html) = find_memory_page(&memory_pages, &uri) {
                        let native_response = build_memory_html_response(&env, html)?;
                        args.SetResponse(&native_response)?;
                        return Ok(());
                    }

                    let body = request
                        .Content()
                        .ok()
                        .and_then(|stream| read_stream_to_end(&stream).ok())
                        .unwrap_or_default();

                    let mut http_request = Request::builder()
                        .method(method.as_str())
                        .uri(uri.as_str())
                        .body(body)
                        .map_err(http_error_to_win)?;
                    populate_request_headers(&request, http_request.headers_mut())?;

                    let scheme = request_scheme(&uri);
                    let response = find_webview(&request_tag)
                        .and_then(|webview| webview.handle_scheme_request(scheme, http_request));

                    let Some(response) = response else {
                        // PassThrough (or no webview found): leave the response
                        // unset so WebView2 default handling proceeds for real
                        // http/https requests. Only custom/app schemes, which
                        // the network stack cannot resolve, get a synthetic 404.
                        if custom_schemes.iter().any(|custom| custom == scheme) {
                            let native_response =
                                build_webview2_response(&env, not_found_response())?;
                            args.SetResponse(&native_response)?;
                        }
                        return Ok(());
                    };

                    let native_response = build_webview2_response(&env, response)?;
                    args.SetResponse(&native_response)?;
                    Ok(())
                })),
                &mut token,
            )
            .map_err(|err| {
                WebViewError::WebView(format!("add_WebResourceRequested failed: {err}"))
            })?;
    }

    Ok(())
}

pub(crate) fn download_request_from_operation(
    operation: &ICoreWebView2DownloadOperation,
) -> WinResult<DownloadRequest> {
    let url = take_request_string(|slot| unsafe { operation.Uri(slot) })?;
    let content_disposition = non_empty(take_request_string(|slot| unsafe {
        operation.ContentDisposition(slot)
    })?);
    let mime_type = non_empty(take_request_string(|slot| unsafe {
        operation.MimeType(slot)
    })?);
    let result_file_path = non_empty(take_request_string(|slot| unsafe {
        operation.ResultFilePath(slot)
    })?);
    let content_length = unsafe {
        let mut total = 0i64;
        operation.TotalBytesToReceive(&mut total)?;
        u64::try_from(total).ok().filter(|value| *value > 0)
    };
    let suggested_filename = result_file_path
        .as_ref()
        .and_then(|path| std::path::Path::new(path).file_name())
        .map(|name| name.to_string_lossy().to_string());

    Ok(DownloadRequest {
        url,
        user_agent: None,
        content_disposition,
        mime_type,
        content_length,
        suggested_filename,
        source_page_url: None,
        cookie: None,
    })
}

pub(crate) fn non_empty(value: String) -> Option<String> {
    let value = value.trim().to_string();
    if value.is_empty() { None } else { Some(value) }
}

pub(crate) fn take_request_string(
    getter: impl FnOnce(*mut PWSTR) -> WinResult<()>,
) -> WinResult<String> {
    let mut value = PWSTR::null();
    getter(&mut value)?;
    Ok(CoTaskMemPWSTR::from(value).to_string())
}