WebViewBridgeHost.cpp

#include "WebViewBridgeHost.h"

#include <wrl.h>
#include <wil/com.h>
#include <WebView2.h>

#include "HostProtocolBridge.h"
#include "ProtocolTypes.h"

using namespace Microsoft::WRL;

// Stores the host window, startup policy, callback registry, and log sink for one WebView instance.
WebViewBridgeHost::WebViewBridgeHost(
    HWND hostHwnd,
    WebViewBridgeHostConfig config,
    ClientCallbackRegistry callbacks,
    LogFn logFn)
    : m_hostHwnd(hostHwnd),
      m_config(std::move(config)),
      m_callbacks(std::move(callbacks)),
      m_logFn(std::move(logFn)) {
}

// Creates the WebView2 environment/controller pair and starts the initial navigation loop.
HRESULT WebViewBridgeHost::Initialize() {
    // The environment owns the browser process/profile root; the controller binds it to our host window.
    const HRESULT hr = CreateCoreWebView2EnvironmentWithOptions(
        nullptr,
        m_config.userDataFolder.c_str(),
        nullptr,
        Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
            [this](HRESULT res, ICoreWebView2Environment* env) -> HRESULT {
                if (FAILED(res)) {
                    FailInitialization(res, L"Native Error: Failed to create WebView environment.");
                    return res;
                }

                const auto createControllerHandler =
                    Callback<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>(
                        [this](HRESULT createRes, ICoreWebView2Controller* ctrl) -> HRESULT {
                            if (FAILED(createRes)) {
                                FailInitialization(createRes, L"Native Error: Failed to create WebView controller.");
                                return createRes;
                            }

                            m_controller = ctrl;
                            // A hidden controller still works for script/message bridging, but it is backgrounded.
                            BOOL isVisible = FALSE;
                            const HRESULT visibleHr = m_controller->get_IsVisible(&isVisible);
                            if (SUCCEEDED(visibleHr)) {
                                Log(WebViewBridgeLogVerbosity::Info,
                                    L"Native: WebView controller IsVisible=" + std::to_wstring(isVisible ? 1 : 0));
                            }
                            else {
                                Log(WebViewBridgeLogVerbosity::Info,
                                    L"Native Error: Failed to query WebView controller IsVisible.");
                            }
                            // Without ICoreWebView2, the controller exists but the page/message bridge cannot run.
                            HRESULT coreWebViewHr = m_controller->get_CoreWebView2(&m_webview);
                            if (FAILED(coreWebViewHr) || !m_webview) {
                                FailInitialization(coreWebViewHr, L"Native Error: Failed to get CoreWebView2 instance.");
                                return FAILED(coreWebViewHr) ? coreWebViewHr : E_POINTER;
                            }

                            // Install bridge handlers before navigating so page_ready and early failures are observed.
                            HRESULT handlersHr = SetupWebViewHandlers();
                            if (FAILED(handlersHr)) {
                                FailInitialization(handlersHr, L"Native Error: Failed to install WebView handlers.");
                                return handlersHr;
                            }

                            // The reconnect timer is part of startup policy, not optional background work.
                            if (SetTimer(m_hostHwnd, m_config.connectTimerId, m_config.connectRetryMs, nullptr) == 0) {
                                const HRESULT timerHr = HRESULT_FROM_WIN32(GetLastError());
                                FailInitialization(timerHr, L"Native Error: Failed to start reconnect timer.");
                                return timerHr;
                            }
                            EnsurePageNavigation();
                            return S_OK;
                        });

                if (m_config.profileName.empty()) {
                    return env->CreateCoreWebView2Controller(
                        m_hostHwnd,
                        createControllerHandler.Get());
                }

                // Browser-hosted profiles use the browser user-data root plus a WebView2 profile name.
                wil::com_ptr<ICoreWebView2Environment10> env10;
                if (FAILED(env->QueryInterface(IID_PPV_ARGS(&env10)))) {
                    FailInitialization(E_NOINTERFACE, L"Native Error: WebView environment does not support named profiles.");
                    return E_NOINTERFACE;
                }

                wil::com_ptr<ICoreWebView2ControllerOptions> controllerOptions;
                HRESULT optionsHr = env10->CreateCoreWebView2ControllerOptions(&controllerOptions);
                if (FAILED(optionsHr)) {
                    FailInitialization(optionsHr, L"Native Error: Failed to create WebView controller options.");
                    return optionsHr;
                }

                optionsHr = controllerOptions->put_ProfileName(m_config.profileName.c_str());
                if (FAILED(optionsHr)) {
                    FailInitialization(optionsHr, L"Native Error: Failed to set WebView profile name.");
                    return optionsHr;
                }

                return env10->CreateCoreWebView2ControllerWithOptions(
                    m_hostHwnd,
                    controllerOptions.get(),
                    createControllerHandler.Get());
            }).Get());
    if (FAILED(hr)) {
        // This is the synchronous kickoff failure before WebView2 can invoke async completion callbacks.
        Log(WebViewBridgeLogVerbosity::Info, L"Native Error: Failed to begin WebView environment creation.");
    }

    return hr;
}

// Handles the reconnect and poll timers owned by this bridge host.
bool WebViewBridgeHost::HandleTimer(UINT_PTR timerId) {
    if (timerId == m_config.connectTimerId) {
        EnsurePageNavigation();
        return true;
    }

    if (timerId == m_config.pollTimerId) {
        TriggerPollFromNative();
        return true;
    }

    return false;
}

// Evaluates whether a message should be emitted under the configured bridge verbosity.
bool WebViewBridgeHost::ShouldLog(WebViewBridgeLogVerbosity level) const {
    switch (m_config.logVerbosity) {
    case WebViewBridgeLogVerbosity::Silent:
        return false;
    case WebViewBridgeLogVerbosity::Info:
        return level == WebViewBridgeLogVerbosity::Info;
    case WebViewBridgeLogVerbosity::Debug:
        return true;
    default:
        return false;
    }
}

// Forwards one bridge log message to the client-provided sink when enabled.
void WebViewBridgeHost::Log(WebViewBridgeLogVerbosity level, const std::wstring& message) const {
    if (m_logFn && ShouldLog(level)) {
        m_logFn(message);
    }
}

void WebViewBridgeHost::FailInitialization(HRESULT hr, const std::wstring& message) const {
    Log(WebViewBridgeLogVerbosity::Info,
        message + L" HRESULT=" + std::to_wstring(static_cast<unsigned long>(hr)));

    if (m_hostHwnd && IsWindow(m_hostHwnd)) {
        // Async bootstrap failures happen after WebLink enters its message loop, so closing the host window is the
        // simplest way to surface a fatal bridge startup failure back to the owning app.
        PostMessageW(m_hostHwnd, WM_CLOSE, 0, 0);
    }
}

// Sends a typed native answer back into the page over the WebView2 message channel.
void WebViewBridgeHost::PostAnswerToPage(const std::wstring& questionId, const std::wstring& answerText) {
    if (!m_webview) return;

    const std::wstring json = SerializeAnswerMessageJson(AnswerMessage{ questionId, answerText });
    const HRESULT hr = m_webview->PostWebMessageAsJson(json.c_str());
    if (SUCCEEDED(hr)) {
        Log(WebViewBridgeLogVerbosity::Info, L"Native: Posted answer for " + questionId + L": " + answerText);
    }
    else {
        Log(WebViewBridgeLogVerbosity::Info, L"Native Error: Failed to post answer for " + questionId);
    }
}

// Executes the configured page polling function inside the currently loaded document.
void WebViewBridgeHost::TriggerPollFromNative() {
    if (!m_webview || !m_pageReady || m_pollInFlight) return;

    m_pollInFlight = true;
    Log(WebViewBridgeLogVerbosity::Debug, L"Native: Triggering poll script.");

    // Native owns cadence; the page only supplies the async function we execute inside the document.
    m_webview->ExecuteScript(
        m_config.pollScript.c_str(),
        Callback<ICoreWebView2ExecuteScriptCompletedHandler>(
            [this](HRESULT hr, LPCWSTR) -> HRESULT {
                m_pollInFlight = false;
                if (SUCCEEDED(hr)) {
                    Log(WebViewBridgeLogVerbosity::Debug, L"Native: Poll script executed successfully.");
                }
                else {
                    Log(WebViewBridgeLogVerbosity::Info, L"Native Error: Poll script execution failed.");
                }
                return S_OK;
            }).Get());
}

// Keeps retrying navigation until the page signals that its bridge is ready.
void WebViewBridgeHost::EnsurePageNavigation() {
    if (!m_webview || m_pageReady) return;

    Log(WebViewBridgeLogVerbosity::Info, L"Native: Navigating WebView to " + m_config.startUrl);
    const HRESULT hr = m_webview->Navigate(m_config.startUrl.c_str());
    if (FAILED(hr)) {
        // If initial navigation cannot start, the page can never report page_ready.
        FailInitialization(hr, L"Native Error: Navigate failed.");
    }
}

// Wires the navigation and message callbacks that connect WebView2 to the app protocol.
HRESULT WebViewBridgeHost::SetupWebViewHandlers() {
    HRESULT hr = m_webview->add_NavigationStarting(
        Callback<ICoreWebView2NavigationStartingEventHandler>(
            [this](ICoreWebView2*, ICoreWebView2NavigationStartingEventArgs* args) -> HRESULT {
                wil::unique_cotaskmem_string uri;
                if (SUCCEEDED(args->get_Uri(&uri)) && uri) {
                    Log(WebViewBridgeLogVerbosity::Debug, L"Native: Navigation starting: " + std::wstring(uri.get()));
                }
                else {
                    Log(WebViewBridgeLogVerbosity::Debug, L"Native: Navigation starting.");
                }
                return S_OK;
            }).Get(),
        nullptr);
    if (FAILED(hr)) {
        return hr;
    }

    hr = m_webview->add_NavigationCompleted(
        Callback<ICoreWebView2NavigationCompletedEventHandler>(
            [this](ICoreWebView2*, ICoreWebView2NavigationCompletedEventArgs* args) -> HRESULT {
                BOOL isSuccess = FALSE;
                COREWEBVIEW2_WEB_ERROR_STATUS errorStatus = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
                args->get_IsSuccess(&isSuccess);
                args->get_WebErrorStatus(&errorStatus);

                if (isSuccess) {
                    Log(WebViewBridgeLogVerbosity::Info, L"Native: Navigation completed successfully.");
                }
                else {
                    Log(WebViewBridgeLogVerbosity::Info, L"Native Error: Navigation failed with WebErrorStatus=" + std::to_wstring(static_cast<int>(errorStatus)));
                }
                return S_OK;
            }).Get(),
        nullptr);
    if (FAILED(hr)) {
        return hr;
    }

    hr = m_webview->add_WebMessageReceived(
        Callback<ICoreWebView2WebMessageReceivedEventHandler>(
            [this](ICoreWebView2*, ICoreWebView2WebMessageReceivedEventArgs* args) -> HRESULT {
                wil::unique_cotaskmem_string json;
                args->get_WebMessageAsJson(&json);

                // Page JS talks back through window.chrome.webview.postMessage(...); this is the native entrypoint.
                const auto dispatch = DispatchHostInboundMessageJson(json.get(), m_callbacks);
                if (!dispatch.has_value()) {
                    Log(WebViewBridgeLogVerbosity::Info, L"Native Error: Invalid host message payload.");
                    return S_OK;
                }

                if (dispatch->isPageReady) {
                    Log(WebViewBridgeLogVerbosity::Info, L"App: WebView reported PageReady.");
                    m_pageReady = true;
                    // Once the page declares its bridge ready, switch from connect retries to the poll heartbeat.
                    KillTimer(m_hostHwnd, m_config.connectTimerId);
                    // The poll timer drives ExecuteScript(window.hostBridge.pollOnce()) for steady-state operation.
                    if (SetTimer(m_hostHwnd, m_config.pollTimerId, m_config.pollMs, nullptr) == 0) {
                        const HRESULT timerHr = HRESULT_FROM_WIN32(GetLastError());
                        FailInitialization(timerHr, L"Native Error: Failed to start poll timer.");
                        return timerHr;
                    }
                }

                if (dispatch->answer.has_value()) {
                    // Callback dispatch resolves the server question id to native work, then posts an answer back to JS.
                    Log(WebViewBridgeLogVerbosity::Info, L"Native: Resolved callback answer for " + dispatch->answer->id + L": " + dispatch->answer->text);
                    PostAnswerToPage(dispatch->answer->id, dispatch->answer->text);
                }

                return S_OK;
            }).Get(),
        nullptr);
    if (FAILED(hr)) {
        return hr;
    }

    return S_OK;
}