axmol/cocos/ui/UIWebView/UIWebViewImpl-win32.cpp

/****************************************************************************
 MIT License

 Portions copyright (c) 2017 Serge Zaitsev

 https://adxe.org

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/

#if CC_TARGET_PLATFORM == CC_PLATFORM_WIN32

#    include "UIWebViewImpl-win32.h"
#    include "UIWebView.h"
#    include "base/CCDirector.h"
#    include "platform/CCFileUtils.h"
#    include "platform/CCGLView.h"
#    include "base/base64.h"
#    include "ui/UIHelper.h"
#    include "rapidjson/document.h"
#    include "rapidjson/stringbuffer.h"
#    include "rapidjson/writer.h"

#    define WIN32_LEAN_AND_MEAN
#    include <Shlwapi.h>
#    include <codecvt>
#    include <utility>
#    include <stdlib.h>
#    include <Windows.h>

#    pragma comment(lib, "user32.lib")
#    pragma comment(lib, "Shlwapi.lib")

// Edge/Chromium headers and libs
#    include "WebView2.h"
#    pragma comment(lib, "ole32.lib")
#    pragma comment(lib, "oleaut32.lib")

#    include "platform/CCPlatformConfig.h"

USING_NS_CC;
using namespace rapidjson;

using msg_cb_t = std::function<void(const std::string)>;

inline std::string htmlFromUri(const std::string& s)
{
    if (s.substr(0, 15) == "data:text/html,")
    {
        return utils::urlDecode(s.substr(15));
    }
    return "";
}

inline int jsonUnescape(const char* s, size_t n, char* out)
{
    int r = 0;
    if (*s++ != '"')
    {
        return -1;
    }
    while (n > 2)
    {
        char c = *s;
        if (c == '\\')
        {
            s++;
            n--;
            switch (*s)
            {
            case 'b':
                c = '\b';
                break;
            case 'f':
                c = '\f';
                break;
            case 'n':
                c = '\n';
                break;
            case 'r':
                c = '\r';
                break;
            case 't':
                c = '\t';
                break;
            case '\\':
                c = '\\';
                break;
            case '/':
                c = '/';
                break;
            case '\"':
                c = '\"';
                break;
            default:  // TODO: support unicode decoding
                return -1;
            }
        }
        if (out != NULL)
        {
            *out++ = c;
        }
        s++;
        n--;
        r++;
    }
    if (*s != '"')
    {
        return -1;
    }
    if (out != NULL)
    {
        *out = '\0';
    }
    return r;
}

// These are the results that must be returned by this method
// assert(jsonParse(R"({"foo":"bar"})", "foo", -1) == "bar");
// assert(jsonParse(R"({"foo":""})", "foo", -1) == "");
// assert(jsonParse(R"(["foo", "bar", "baz"])", "", 0) == "foo");
// assert(jsonParse(R"(["foo", "bar", "baz"])", "", 2) == "baz");
// The following is a special case, where the exact json string is not returned due
// to how rapidjson re-creates the nested object, original: "{"bar": 1}", parsed result: "{"bar":1}"
// assert(jsonParse(R"({"foo": {"bar": 1}})", "foo", -1) == R"({"bar":1})");
inline std::string jsonParse(const std::string& s, const std::string& key, const int index)
{
    const char* value = nullptr;
    size_t value_sz{};
    StringBuffer sb;
    Writer<StringBuffer> writer(sb);
    Document d;
    d.Parse(s.c_str());
    if (key.empty() && index > -1)
    {
        if (d.IsArray())
        {
            auto&& jsonArray = d.GetArray();
            if (SizeType(index) < jsonArray.Size())
            {
                auto&& arrayValue = jsonArray[SizeType(index)];
                value             = arrayValue.GetString();
                value_sz          = arrayValue.GetStringLength();
            }
        }
    }
    else
    {
        auto&& fieldItr = d.FindMember(key.c_str());
        if (fieldItr != d.MemberEnd())
        {
            auto&& jsonValue = fieldItr->value;
            if (jsonValue.IsString())
            {
                value    = jsonValue.GetString();
                value_sz = jsonValue.GetStringLength();
            }
            else
            {
                jsonValue.Accept(writer);
                value    = sb.GetString();
                value_sz = sb.GetLength();
            }
        }
    }

    if (value != nullptr)
    {
        if (value[0] != '"')
        {
            return std::string(value, value_sz);
        }

        const auto n = jsonUnescape(value, value_sz, nullptr);
        if (n > 0)
        {
            const auto decoded = std::unique_ptr<char[]>(new char[n + 1]);
            jsonUnescape(value, value_sz, decoded.get());
            return std::string(decoded.get(), n);
        }
    }
    return "";
}

template <class ArgType>
static std::string getUriStringFromArgs(ArgType* args)
{
    if (args != nullptr)
    {
        LPWSTR uri;
        args->get_Uri(&uri);
        std::wstring ws(uri);
        std::string result = std::string(ws.begin(), ws.end());

        return result;
    }

    return {};
}

static std::string getDataURI(const std::string& data, const std::string& mime_type)
{
    char* encodedData;
    cocos2d::base64Encode(reinterpret_cast<const unsigned char*>(data.data()), static_cast<unsigned>(data.size()),
                          &encodedData);
    return "data:" + mime_type + ";base64," + utils::urlEncode(encodedData);
}

static double getDeviceScaleFactor()
{
    static double scale_factor = 1.0;
    static bool initialized    = false;

    if (!initialized)
    {
        // This value is safe to cache for the life time of the app since the user
        // must logout to change the DPI setting. This value also applies to all
        // screens.
#    if _WIN32
        HDC screen_dc = ::GetDC(NULL);
        int dpi_x     = GetDeviceCaps(screen_dc, LOGPIXELSX);
        scale_factor  = static_cast<double>(dpi_x) / 96.0;
        ::ReleaseDC(NULL, screen_dc);
#    endif
        initialized = true;
    }

    return scale_factor;
}

// declarate
class Win32WebControl
{
public:
    Win32WebControl();

    bool createWebView(const std::function<bool(const std::string&)>& shouldStartLoading,
                       const std::function<void(const std::string&)>& didFinishLoading,
                       const std::function<void(const std::string&)>& didFailLoading,
                       const std::function<void(const std::string&)>& onJsCallback);
    void removeWebView();

    void setWebViewRect(const int left, const int top, const int width, const int height);
    void setJavascriptInterfaceScheme(const std::string& scheme);
    void loadHTMLString(const std::string& html, const std::string& baseURL);
    void loadURL(const std::string& url, bool cleanCachedData);
    void loadFile(const std::string& filePath);
    void stopLoading();
    void reload() const;
    bool canGoBack() const;
    bool canGoForward() const;
    void goBack() const;
    void goForward() const;
    void evaluateJS(const std::string& js);
    void setScalesPageToFit(const bool scalesPageToFit);
    void setWebViewVisible(const bool visible) const;
    void setBounces(bool bounces);
    void setOpacityWebView(float opacity);
    float getOpacityWebView() const;
    void setBackgroundTransparent();

private:
    ICoreWebView2* m_webview              = nullptr;
    ICoreWebView2Controller* m_controller = nullptr;
    HWND m_window{};
    POINT m_minsz       = POINT{0, 0};
    POINT m_maxsz       = POINT{0, 0};
    DWORD m_main_thread = GetCurrentThreadId();

    std::string m_jsScheme;
    bool _scalesPageToFit{};

    std::function<bool(const std::string&)> _shouldStartLoading;
    std::function<void(const std::string&)> _didFinishLoading;
    std::function<void(const std::string&)> _didFailLoading;
    std::function<void(const std::string&)> _onJsCallback;

    static bool s_isInitialized;
    static void lazyInit();

    static LPWSTR to_lpwstr(const std::string s)
    {
        const int n = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, NULL, 0);
        auto* ws    = new wchar_t[n];
        MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, ws, n);
        return ws;
    }

    bool embed(HWND wnd, bool debug, msg_cb_t cb)
    {
        std::atomic_flag flag = ATOMIC_FLAG_INIT;
        flag.test_and_set();

        char currentExePath[MAX_PATH];
        GetModuleFileNameA(NULL, currentExePath, MAX_PATH);
        char* currentExeName = PathFindFileNameA(currentExePath);

        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> wideCharConverter;
        std::wstring userDataFolder  = wideCharConverter.from_bytes(std::getenv("APPDATA"));
        std::wstring currentExeNameW = wideCharConverter.from_bytes(currentExeName);

        HRESULT res = CreateCoreWebView2EnvironmentWithOptions(
            nullptr, (userDataFolder + L"/" + currentExeNameW).c_str(), nullptr,
            new webview2_com_handler(
                wnd, cb,
                [&](ICoreWebView2Controller* controller) {
                    m_controller = controller;
                    m_controller->get_CoreWebView2(&m_webview);
                    m_webview->AddRef();
                    flag.clear();
                },
                [this](const std::string& url) -> bool {
                    const auto scheme = url.substr(0, url.find_first_of(':'));
                    if (scheme == m_jsScheme)
                    {
                        if (_onJsCallback)
                        {
                            _onJsCallback(url);
                        }
                        return true;
                    }

                    if (_shouldStartLoading && !url.empty())
                    {
                        return _shouldStartLoading(url);
                    }
                    return true;
                },
                [this]() {
                    LPWSTR uri;
                    this->m_webview->get_Source(&uri);
                    std::wstring ws(uri);
                    const auto result = std::string(ws.begin(), ws.end());
                    if (_didFinishLoading)
                        _didFinishLoading(result);
                },
                [this]() {
                    LPWSTR uri;
                    this->m_webview->get_Source(&uri);
                    std::wstring ws(uri);
                    const auto result = std::string(ws.begin(), ws.end());
                    if (_didFailLoading)
                        _didFailLoading(result);
                },
                [this](const std::string& url) { loadURL(url, false); }));

        if (res != S_OK)
        {
            CoUninitialize();
            return false;
        }
        MSG msg = {};
        while (flag.test_and_set() && GetMessage(&msg, NULL, 0, 0))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        init("window.external={invoke:s=>window.chrome.webview.postMessage(s)}");
        return true;
    }

    void resize(HWND wnd)
    {
        if (m_controller == nullptr)
        {
            return;
        }
        RECT bounds;
        GetClientRect(wnd, &bounds);
        m_controller->put_Bounds(bounds);
    }

    void navigate(const std::string url)
    {
        auto wurl = to_lpwstr(url);
        m_webview->Navigate(wurl);
        delete[] wurl;
    }

    void init(const std::string js)
    {
        LPCWSTR wjs = to_lpwstr(js);
        m_webview->AddScriptToExecuteOnDocumentCreated(wjs, nullptr);
        delete[] wjs;
    }

    void eval(const std::string js)
    {
        LPCWSTR wjs = to_lpwstr(js);
        m_webview->ExecuteScript(wjs, nullptr);
        delete[] wjs;
    }

    void on_message(const std::string msg)
    {
        const auto seq  = jsonParse(msg, "id", 0);
        const auto name = jsonParse(msg, "method", 0);
        const auto args = jsonParse(msg, "params", 0);
        if (bindings.find(name) == bindings.end())
        {
            return;
        }
        const auto fn = bindings[name];
        (*fn->first)(seq, args, fn->second);
    }

    using binding_t     = std::function<void(std::string, std::string, void*)>;
    using binding_ctx_t = std::pair<binding_t*, void*>;
    std::map<std::string, binding_ctx_t*> bindings;

    class webview2_com_handler : public ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler,
                                 public ICoreWebView2CreateCoreWebView2ControllerCompletedHandler,
                                 public ICoreWebView2WebMessageReceivedEventHandler,
                                 public ICoreWebView2PermissionRequestedEventHandler,
                                 public ICoreWebView2NavigationStartingEventHandler,
                                 public ICoreWebView2NavigationCompletedEventHandler,
                                 public ICoreWebView2NewWindowRequestedEventHandler,
                                 public ICoreWebView2ContentLoadingEventHandler,
                                 public ICoreWebView2DOMContentLoadedEventHandler
    {
        using webview2_com_handler_cb_t = std::function<void(ICoreWebView2Controller*)>;

    public:
        webview2_com_handler(HWND hwnd,
                             msg_cb_t msgCb,
                             webview2_com_handler_cb_t cb,
                             std::function<bool(const std::string&)> navStartingCallback,
                             std::function<void()> navCompleteCallback,
                             std::function<void()> navErrorCallback,
                             std::function<void(const std::string& url)> loadUrlCallback)
            : m_window(hwnd)
            , m_msgCb(std::move(msgCb))
            , m_cb(std::move(cb))
            , m_navStartingCallback(std::move(navStartingCallback))
            , m_navCompleteCallback(std::move(navCompleteCallback))
            , m_navErrorCallback(std::move(navErrorCallback))
            , m_loadUrlCallback(std::move(loadUrlCallback))
        {}
        ULONG STDMETHODCALLTYPE AddRef() { return 1; }
        ULONG STDMETHODCALLTYPE Release() { return 1; }
        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, LPVOID* ppv) { return S_OK; }

        // ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler
        HRESULT STDMETHODCALLTYPE Invoke(HRESULT res, ICoreWebView2Environment* env)
        {
            env->CreateCoreWebView2Controller(m_window, this);
            return S_OK;
        }

        // ICoreWebView2CreateCoreWebView2ControllerCompletedHandler
        HRESULT STDMETHODCALLTYPE Invoke(HRESULT res, ICoreWebView2Controller* controller)
        {
            controller->AddRef();

            ICoreWebView2* webview;
            ::EventRegistrationToken token;
            controller->get_CoreWebView2(&webview);
            webview->add_WebMessageReceived(this, &token);
            webview->add_PermissionRequested(this, &token);
            webview->add_NavigationStarting(this, &token);
            webview->add_NavigationCompleted(this, &token);
            webview->add_ContentLoading(this, &token);
            webview->add_NewWindowRequested(this, &token);

            m_cb(controller);
            return S_OK;
        }

        // ICoreWebView2WebMessageReceivedEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2WebMessageReceivedEventArgs* args)
        {
            LPWSTR message;
            args->TryGetWebMessageAsString(&message);

            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> wideCharConverter;
            m_msgCb(wideCharConverter.to_bytes(message));
            sender->PostWebMessageAsString(message);

            CoTaskMemFree(message);
            return S_OK;
        }

        // ICoreWebView2PermissionRequestedEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2PermissionRequestedEventArgs* args)
        {
            COREWEBVIEW2_PERMISSION_KIND kind;
            args->get_PermissionKind(&kind);
            if (kind == COREWEBVIEW2_PERMISSION_KIND_CLIPBOARD_READ)
            {
                args->put_State(COREWEBVIEW2_PERMISSION_STATE_ALLOW);
            }
            return S_OK;
        }

        // ICoreWebView2NavigationStartingEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2NavigationStartingEventArgs* args)
        {
            if (m_navStartingCallback)
            {
                const auto uriString = getUriStringFromArgs(args);
                if (!m_navStartingCallback(uriString))
                {
                    args->put_Cancel(true);
                }
            }

            return S_OK;
        }

        // ICoreWebView2NavigationCompletedEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2NavigationCompletedEventArgs* args)
        {
            BOOL success;
            if (SUCCEEDED(args->get_IsSuccess(&success)) && success)
            {
                if (m_navCompleteCallback)
                {
                    m_navCompleteCallback();
                }
            }
            else
            {
                // example of how to get status error if required
                // COREWEBVIEW2_WEB_ERROR_STATUS status;
                // if (SUCCEEDED(args->get_WebErrorStatus(&status)))
                //{
                //}

                if (m_navErrorCallback)
                {
                    m_navErrorCallback();
                }
            }
            return S_OK;
        }

        // ICoreWebView2ContentLoadingEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2ContentLoadingEventArgs* args)
        {
            return S_OK;
        }

        // ICoreWebView2NewWindowRequestedEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2NewWindowRequestedEventArgs* args)
        {
            args->put_Handled(true);
            return S_OK;
        }

        // ICoreWebView2NewWindowRequestedEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2NewWindowRequestedEventArgs2* args)
        {
            args->put_Handled(true);

            if (m_loadUrlCallback)
            {
                const auto uriString = getUriStringFromArgs(args);
                m_loadUrlCallback(uriString);
            }
            args->put_Handled(true);
            return S_OK;
        }

        // ICoreWebView2DOMContentLoadedEventHandler
        HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender, ICoreWebView2DOMContentLoadedEventArgs* args)
        {
            return S_OK;
        }

    private:
        HWND m_window;
        msg_cb_t m_msgCb;
        webview2_com_handler_cb_t m_cb;
        std::function<bool(const std::string&)> m_navStartingCallback;
        std::function<void()> m_navCompleteCallback;
        std::function<void()> m_navErrorCallback;
        std::function<void(const std::string& url)> m_loadUrlCallback;
    };
};

namespace cocos2d
{
namespace ui
{
WebViewImpl::WebViewImpl(WebView* webView) : _createSucceeded(false), _systemWebControl(nullptr), _webView(webView)
{
    _systemWebControl = new Win32WebControl();
    if (_systemWebControl == nullptr)
    {
        return;
    }

    _createSucceeded = _systemWebControl->createWebView(
        [this](const std::string& url) -> bool {
            const auto shouldStartLoading = _webView->getOnShouldStartLoading();
            if (shouldStartLoading != nullptr)
            {
                return shouldStartLoading(_webView, url);
            }
            return true;
        },
        [this](const std::string& url) {
            WebView::ccWebViewCallback didFinishLoading = _webView->getOnDidFinishLoading();
            if (didFinishLoading != nullptr)
            {
                didFinishLoading(_webView, url);
            }
        },
        [this](const std::string& url) {
            WebView::ccWebViewCallback didFailLoading = _webView->getOnDidFailLoading();
            if (didFailLoading != nullptr)
            {
                didFailLoading(_webView, url);
            }
        },
        [this](const std::string& url) {
            WebView::ccWebViewCallback onJsCallback = _webView->getOnJSCallback();
            if (onJsCallback != nullptr)
            {
                onJsCallback(_webView, url);
            }
        });
}

WebViewImpl::~WebViewImpl()
{
    if (_systemWebControl != nullptr)
    {
        _systemWebControl->removeWebView();
        delete _systemWebControl;
        _systemWebControl = nullptr;
    }
}

void WebViewImpl::loadData(const Data& data,
                           const std::string& MIMEType,
                           const std::string& encoding,
                           const std::string& baseURL)
{
    if (_createSucceeded)
    {
        const std::string dataString(reinterpret_cast<char*>(data.getBytes()),
                                     static_cast<unsigned int>(data.getSize()));
        const auto url = getDataURI(dataString, MIMEType);
        _systemWebControl->loadURL(url, false);
    }
}

void WebViewImpl::loadHTMLString(const std::string& string, const std::string& baseURL)
{
    if (_createSucceeded)
    {
        if (string.empty())
        {
            _systemWebControl->loadHTMLString("data:text/html," + utils::urlEncode("<html></html>"), baseURL);
            return;
        }

        const auto html = htmlFromUri(string);
        if (!html.empty())
        {
            _systemWebControl->loadHTMLString("data:text/html," + utils::urlEncode(html), baseURL);
        }
        else
        {
            _systemWebControl->loadHTMLString(string, baseURL);
        }
    }
}

void WebViewImpl::loadURL(const std::string& url, bool cleanCachedData)
{
    if (_createSucceeded)
    {
        _systemWebControl->loadURL(url, cleanCachedData);
    }
}

void WebViewImpl::loadFile(const std::string& fileName)
{
    if (_createSucceeded)
    {
        const auto fullPath = FileUtils::getInstance()->fullPathForFilename(fileName);
        _systemWebControl->loadFile(fullPath);
    }
}

void WebViewImpl::stopLoading()
{
    if (_createSucceeded)
    {
        _systemWebControl->stopLoading();
    }
}

void WebViewImpl::reload()
{
    if (_createSucceeded)
    {
        _systemWebControl->reload();
    }
}

bool WebViewImpl::canGoBack()
{
    if (_createSucceeded)
    {
        return _systemWebControl->canGoBack();
    }
    return false;
}

bool WebViewImpl::canGoForward()
{
    if (_createSucceeded)
    {
        return _systemWebControl->canGoForward();
    }
    return false;
}

void WebViewImpl::goBack()
{
    if (_createSucceeded)
    {
        _systemWebControl->goBack();
    }
}

void WebViewImpl::goForward()
{
    if (_createSucceeded)
    {
        _systemWebControl->goForward();
    }
}

void WebViewImpl::setJavascriptInterfaceScheme(const std::string& scheme)
{
    if (_createSucceeded)
    {
        _systemWebControl->setJavascriptInterfaceScheme(scheme);
    }
}

void WebViewImpl::evaluateJS(const std::string& js)
{
    if (_createSucceeded)
    {
        _systemWebControl->evaluateJS(js);
    }
}

void WebViewImpl::setScalesPageToFit(const bool scalesPageToFit)
{
    if (_createSucceeded)
    {
        _systemWebControl->setScalesPageToFit(scalesPageToFit);
    }
}

void WebViewImpl::draw(Renderer* renderer, Mat4 const& transform, uint32_t flags)
{
    if (_createSucceeded && (flags & Node::FLAGS_TRANSFORM_DIRTY))
    {
        const auto uiRect = cocos2d::ui::Helper::convertBoundingBoxToScreen(_webView);
        _systemWebControl->setWebViewRect(static_cast<int>(uiRect.origin.x), static_cast<int>(uiRect.origin.y),
                                          static_cast<int>(uiRect.size.width), static_cast<int>(uiRect.size.height));
    }
}

void WebViewImpl::setVisible(bool visible)
{
    if (_createSucceeded)
    {
        _systemWebControl->setWebViewVisible(visible);
    }
}

void WebViewImpl::setBounces(bool bounces)
{
    _systemWebControl->setBounces(bounces);
}

void WebViewImpl::setOpacityWebView(float opacity)
{
    _systemWebControl->setOpacityWebView(opacity);
}

float WebViewImpl::getOpacityWebView() const
{
    return _systemWebControl->getOpacityWebView();
}

void WebViewImpl::setBackgroundTransparent()
{
    _systemWebControl->setBackgroundTransparent();
}
}  // namespace ui
}  // namespace cocos2d

//
// Implement Win32WebControl
//
bool Win32WebControl::s_isInitialized = false;

void Win32WebControl::lazyInit()
{
    // reset the main windows style so that its drawing does not cover the webview sub window
    auto hwnd        = cocos2d::Director::getInstance()->getOpenGLView()->getWin32Window();
    const auto style = GetWindowLong(hwnd, GWL_STYLE);
    SetWindowLong(hwnd, GWL_STYLE, style | WS_CLIPCHILDREN);

    CoInitialize(NULL);
}

Win32WebControl::Win32WebControl() : _shouldStartLoading(nullptr), _didFinishLoading(nullptr), _didFailLoading(nullptr)
{
    if (!s_isInitialized)
    {
        lazyInit();
    }
}

bool Win32WebControl::createWebView(const std::function<bool(const std::string&)>& shouldStartLoading,
                                    const std::function<void(const std::string&)>& didFinishLoading,
                                    const std::function<void(const std::string&)>& didFailLoading,
                                    const std::function<void(const std::string&)>& onJsCallback)
{
    bool ret = false;
    do
    {
        HWND hwnd           = cocos2d::Director::getInstance()->getOpenGLView()->getWin32Window();
        HINSTANCE hInstance = GetModuleHandle(nullptr);
        WNDCLASSEX wc;
        ZeroMemory(&wc, sizeof(WNDCLASSEX));
        wc.cbSize        = sizeof(WNDCLASSEX);
        wc.hInstance     = hInstance;
        wc.lpszClassName = L"webview";
        wc.hIcon         = nullptr;
        wc.hIconSm       = nullptr;
        // wc.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
        wc.lpfnWndProc = (WNDPROC)(+[](HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) -> int {
            auto w = (Win32WebControl*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
            if (!w)
            {
                return DefWindowProc(hwnd, msg, wp, lp);
            }

            switch (msg)
            {
            case WM_SIZE:
                w->resize(hwnd);
                break;

            case WM_CLOSE:
                DestroyWindow(hwnd);
                break;

            case WM_GETMINMAXINFO:
            {
                auto lpmmi = (LPMINMAXINFO)lp;
                if (w == nullptr)
                {
                    return 0;
                }
                if (w->m_maxsz.x > 0 && w->m_maxsz.y > 0)
                {
                    lpmmi->ptMaxSize      = w->m_maxsz;
                    lpmmi->ptMaxTrackSize = w->m_maxsz;
                }
                if (w->m_minsz.x > 0 && w->m_minsz.y > 0)
                {
                    lpmmi->ptMinTrackSize = w->m_minsz;
                }
            }
            break;

            default:
                return DefWindowProc(hwnd, msg, wp, lp);
            }
            return 0;
        });
        RegisterClassEx(&wc);
        m_window = CreateWindow(L"webview", L"", WS_VISIBLE | WS_CHILD, 0, 0, 0, 0, hwnd, nullptr, hInstance, nullptr);
        SetWindowLongPtr(m_window, GWLP_USERDATA, (LONG_PTR)this);

        ShowWindow(m_window, SW_SHOW);
        UpdateWindow(m_window);
        SetFocus(m_window);

        auto cb = [this](const std::string msg) { on_message(msg); };

        if (!embed(m_window, false, cb))
        {
            CCLOG("Cannot create edge chromium webview");
            ret = false;
            break;
        }

        resize(m_window);
        ret = true;
    } while (0);

    if (!ret)
    {
        removeWebView();
    }

    _shouldStartLoading = shouldStartLoading;
    _didFinishLoading   = didFinishLoading;
    _didFailLoading     = didFailLoading;
    _onJsCallback       = onJsCallback;
    return ret;
}

void Win32WebControl::removeWebView()
{
    m_controller->Close();

    m_controller = nullptr;
    m_webview    = nullptr;
}

void Win32WebControl::setWebViewRect(const int left, const int top, const int width, const int height)
{
    if (m_controller == nullptr)
    {
        return;
    }

    RECT r;
    r.left   = left;
    r.top    = top;
    r.right  = left + width;
    r.bottom = top - height;
    AdjustWindowRect(&r, WS_CHILD | WS_VISIBLE, 0);
    SetWindowPos(m_window, nullptr, left, top, width, height, SWP_NOZORDER);

    m_controller->put_ZoomFactor(_scalesPageToFit ? getDeviceScaleFactor() : 1.0);
}

void Win32WebControl::setJavascriptInterfaceScheme(const std::string& scheme)
{
    m_jsScheme = scheme;
}

void Win32WebControl::loadHTMLString(const std::string& html, const std::string& baseURL)
{
    if (!html.empty())
    {
        const auto whtml = to_lpwstr(html);
        m_webview->NavigateToString(whtml);
        delete[] whtml;
    }
}

void Win32WebControl::loadURL(const std::string& url, bool cleanCachedData)
{
    if (cleanCachedData)
    {
        m_webview->CallDevToolsProtocolMethod(L"Network.clearBrowserCache", L"{}", nullptr);
    }
    navigate(url);
}

void Win32WebControl::loadFile(const std::string& filePath)
{
    auto fullPath = cocos2d::FileUtils::getInstance()->fullPathForFilename(filePath);
    if (fullPath.find("file:///") != 0)
    {
        if (fullPath[0] == '/')
        {
            fullPath = "file://" + fullPath;
        }
        else
        {
            fullPath = "file:///" + fullPath;
        }
    }
    loadURL(fullPath, false);
}

void Win32WebControl::stopLoading()
{
    m_webview->Stop();
}

void Win32WebControl::reload() const
{
    m_webview->Reload();
}

bool Win32WebControl::canGoBack() const
{
    BOOL result;
    return SUCCEEDED(m_webview->get_CanGoBack(&result)) && result;
}

bool Win32WebControl::canGoForward() const
{
    BOOL result;
    return SUCCEEDED(m_webview->get_CanGoForward(&result)) && result;
}

void Win32WebControl::goBack() const
{
    m_webview->GoBack();
}

void Win32WebControl::goForward() const
{
    m_webview->GoForward();
}

void Win32WebControl::evaluateJS(const std::string& js)
{
    eval(js);
}

void Win32WebControl::setScalesPageToFit(const bool scalesPageToFit)
{
    _scalesPageToFit = scalesPageToFit;
    m_controller->put_ZoomFactor(_scalesPageToFit ? getDeviceScaleFactor() : 1.0);
}

void Win32WebControl::setWebViewVisible(const bool visible) const
{
    ShowWindow(m_window, visible ? SW_SHOW : SW_HIDE);
    if (!visible)
    {
        // When the frame window is minimized set the browser window size to 0x0 to
        // reduce resource usage.
        SetWindowPos(m_window, nullptr, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
    }
}

void Win32WebControl::setBounces(bool bounces) {}

void Win32WebControl::setOpacityWebView(float opacity) {}

float Win32WebControl::getOpacityWebView() const
{
    return 1.0f;
}

void Win32WebControl::setBackgroundTransparent()
{
    ICoreWebView2Controller2* viewController2;
    if (SUCCEEDED(m_controller->QueryInterface(__uuidof(ICoreWebView2Controller2),
                                               reinterpret_cast<void**>(&viewController2))))
    {
        COREWEBVIEW2_COLOR color;
        viewController2->get_DefaultBackgroundColor(&color);
        color.A = 0;  // Only supports 0 or 255. Other values not supported
        viewController2->put_DefaultBackgroundColor(color);
    }
}

#endif  // CC_TARGET_PLATFORM == CC_PLATFORM_WIN32