/++
	A thin wrapper around common system webviews.
	Based on: https://github.com/zserge/webview

	Work in progress. DO NOT USE YET as I am prolly gonna break everything.
+/
module arsd.webview;


/* Original https://github.com/zserge/webview notice below:
 * MIT License
 *
 * Copyright (c) 2017 Serge Zaitsev
 *
 * 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.
 */

/*
	Port to D by Adam D. Ruppe, November 30, 2019
*/

version(Windows)
	version=WEBVIEW_EDGE;
else version(linux)
	version=WEBVIEW_GTK;
else version(OSX)
	version=WEBVIEW_COCOA;

version(WEBVIEW_MSHTML)
	version=WindowsWindow;
version(WEBVIEW_EDGE)
	version=WindowsWindow;

version(Demo)
void main() {
	auto wv = new WebView(true, null);
	wv.navigate("http://dpldocs.info/");
	wv.setTitle("omg a D webview");
	wv.setSize(500, 500, true);
	wv.eval("console.log('just testing');");
	wv.run();
}

/++

+/
class WebView : browser_engine {

	/++
		Creates a new webview instance. If dbg is non-zero - developer tools will
		be enabled (if the platform supports them). Window parameter can be a
		pointer to the native window handle. If it's non-null - then child WebView
		is embedded into the given parent window. Otherwise a new window is created.
		Depending on the platform, a GtkWindow, NSWindow or HWND pointer can be
		passed here.
	+/
	this(bool dbg, void* window) {
		super(&on_message, dbg, window);
	}

	extern(C)
	static void on_message(const char*) {}

	/// Destroys a webview and closes the native window.
	void destroy() {

	}

	/// Runs the main loop until it's terminated. After this function exits - you
	/// must destroy the webview.
	override void run() { super.run(); }

	/// Stops the main loop. It is safe to call this function from another other
	/// background thread.
	override void terminate() { super.terminate(); }

	/+
	/// Posts a function to be executed on the main thread. You normally do not need
	/// to call this function, unless you want to tweak the native window.
	void dispatch(void function(WebView w, void *arg) fn, void *arg) {}
	+/

	/// Returns a native window handle pointer. When using GTK backend the pointer
	/// is GtkWindow pointer, when using Cocoa backend the pointer is NSWindow
	/// pointer, when using Win32 backend the pointer is HWND pointer.
	void* getWindow() { return m_window; }

	/// Updates the title of the native window. Must be called from the UI thread.
	override void setTitle(const char *title) { super.setTitle(title); }

	/// Navigates webview to the given URL. URL may be a data URI.
	override void navigate(const char *url) { super.navigate(url); }

	/// Injects JavaScript code at the initialization of the new page. Every time
	/// the webview will open a the new page - this initialization code will be
	/// executed. It is guaranteed that code is executed before window.onload.
	override void init(const char *js) { super.init(js); }

	/// Evaluates arbitrary JavaScript code. Evaluation happens asynchronously, also
	/// the result of the expression is ignored. Use RPC bindings if you want to
	/// receive notifications about the results of the evaluation.
	override void eval(const char *js) { super.eval(js); }

	/// Binds a native C callback so that it will appear under the given name as a
	/// global JavaScript function. Internally it uses webview_init(). Callback
	/// receives a request string and a user-provided argument pointer. Request
	/// string is a JSON array of all the arguments passed to the JavaScript
	/// function.
	void bind(const char *name, void function(const char *, void *) fn, void *arg) {}

	/// Allows to return a value from the native binding. Original request pointer
	/// must be provided to help internal RPC engine match requests with responses.
	/// If status is zero - result is expected to be a valid JSON result value.
	/// If status is not zero - result is an error JSON object.
	void webview_return(const char *req, int status, const char *result) {}

  /*
  void on_message(const char *msg) {
    auto seq = json_parse(msg, "seq", 0);
    auto name = json_parse(msg, "name", 0);
    auto args = json_parse(msg, "args", 0);
    auto fn = bindings[name];
    if (fn == null) {
      return;
    }
    std::async(std::launch::async, [=]() {
      auto result = (*fn)(args);
      dispatch([=]() {
        eval(("var b = window['" + name + "'];b['callbacks'][" + seq + "](" +
              result + ");b['callbacks'][" + seq +
              "] = undefined;b['errors'][" + seq + "] = undefined;")
                 .c_str());
      });
    });
  }
  std::map<std::string, binding_t *> bindings;

  alias binding_t = std::function<std::string(std::string)>;

  void bind(const char *name, binding_t f) {
    auto js = "(function() { var name = '" + std::string(name) + "';" + R"(
      window[name] = function() {
        var me = window[name];
        var errors = me['errors'];
        var callbacks = me['callbacks'];
        if (!callbacks) {
          callbacks = {};
          me['callbacks'] = callbacks;
        }
        if (!errors) {
          errors = {};
          me['errors'] = errors;
        }
        var seq = (me['lastSeq'] || 0) + 1;
        me['lastSeq'] = seq;
        var promise = new Promise(function(resolve, reject) {
          callbacks[seq] = resolve;
          errors[seq] = reject;
        });
        window.external.invoke(JSON.stringify({
          name: name,
          seq:seq,
          args: Array.prototype.slice.call(arguments),
        }));
        return promise;
      }
    })())";
    init(js.c_str());
    bindings[name] = new binding_t(f);
  }

*/
}

private extern(C) {
	alias dispatch_fn_t = void function();
	alias msg_cb_t = void function(const char *msg);
}

version(WEBVIEW_GTK) {

	pragma(lib, "gtk-3");
	pragma(lib, "glib-2.0");
	pragma(lib, "gobject-2.0");
	pragma(lib, "webkit2gtk-4.0");
	pragma(lib, "javascriptcoregtk-4.0");

	private extern(C) {
		import core.stdc.config;
		alias GtkWidget = void;
		enum GtkWindowType {
			GTK_WINDOW_TOPLEVEL = 0
		}
		bool gtk_init_check(int*, char***);
		GtkWidget* gtk_window_new(GtkWindowType);
		c_ulong g_signal_connect_data(void*, const char*, void* /* function pointer!!! */, void*, void*, int);
		GtkWidget* webkit_web_view_new();
		alias WebKitUserContentManager = void;
		WebKitUserContentManager* webkit_web_view_get_user_content_manager(GtkWidget*);

		void gtk_container_add(GtkWidget*, GtkWidget*);
		void gtk_widget_grab_focus(GtkWidget*);
		void gtk_widget_show_all(GtkWidget*);
		void gtk_main();
		void gtk_main_quit();
		void webkit_web_view_load_uri(GtkWidget*, const char*);
		alias WebKitSettings = void;
		WebKitSettings* webkit_web_view_get_settings(GtkWidget*);
		void webkit_settings_set_enable_write_console_messages_to_stdout(WebKitSettings*, bool);
		void webkit_settings_set_enable_developer_extras(WebKitSettings*, bool);
		void webkit_user_content_manager_register_script_message_handler(WebKitUserContentManager*, const char*);
		alias JSCValue = void;
		alias WebKitJavascriptResult = void;
		JSCValue* webkit_javascript_result_get_js_value(WebKitJavascriptResult*);
		char* jsc_value_to_string(JSCValue*);
		void g_free(void*);
		void webkit_web_view_run_javascript(GtkWidget*, const char*, void*, void*, void*);
		alias WebKitUserScript = void;
		void webkit_user_content_manager_add_script(WebKitUserContentManager*, WebKitUserScript*);
		WebKitUserScript* webkit_user_script_new(const char*, WebKitUserContentInjectedFrames, WebKitUserScriptInjectionTime, const char*, const char*);
		enum WebKitUserContentInjectedFrames {
			WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES,
			WEBKIT_USER_CONTENT_INJECT_TOP_FRAME
		}
		enum WebKitUserScriptInjectionTime {
			WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
			WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_END
		}
		void gtk_window_set_title(GtkWidget*, const char*);

		void gtk_window_set_resizable(GtkWidget*, bool);
		void gtk_window_set_default_size(GtkWidget*, int, int);
		void gtk_widget_set_size_request(GtkWidget*, int, int);
	}

	private class browser_engine {

		static extern(C)
		void ondestroy (GtkWidget *w, void* arg) {
			(cast(browser_engine) arg).terminate();
		}

		static extern(C)
		void smr(WebKitUserContentManager* m, WebKitJavascriptResult* r, void* arg) {
			auto w = cast(browser_engine) arg;
			JSCValue *value = webkit_javascript_result_get_js_value(r);
			auto s = jsc_value_to_string(value);
			w.m_cb(s);
			g_free(s);
		}

		this(msg_cb_t cb, bool dbg, void* window) {
			m_cb = cb;

			gtk_init_check(null, null);
			m_window = cast(GtkWidget*) window;
			if (m_window == null)
				m_window = gtk_window_new(GtkWindowType.GTK_WINDOW_TOPLEVEL);

			g_signal_connect_data(m_window, "destroy", &ondestroy, cast(void*) this, null, 0);

			m_webview = webkit_web_view_new();
			WebKitUserContentManager* manager = webkit_web_view_get_user_content_manager(m_webview);

			g_signal_connect_data(manager, "script-message-received::external", &smr, cast(void*) this, null, 0);
			webkit_user_content_manager_register_script_message_handler(manager, "external");
			init("window.external={invoke:function(s){window.webkit.messageHandlers.external.postMessage(s);}}");

			gtk_container_add(m_window, m_webview);
			gtk_widget_grab_focus(m_webview);

			if (dbg) {
				WebKitSettings *settings = webkit_web_view_get_settings(m_webview);
				webkit_settings_set_enable_write_console_messages_to_stdout(settings, true);
				webkit_settings_set_enable_developer_extras(settings, true);
			}

			gtk_widget_show_all(m_window);
		}
		void run() { gtk_main(); }
		void terminate() { gtk_main_quit(); }

		void navigate(const char *url) {
			webkit_web_view_load_uri(m_webview, url);
		}

		void setTitle(const char* title) {
			gtk_window_set_title(m_window, title);
		}

		/+
			void dispatch(std::function<void()> f) {
				g_idle_add_full(G_PRIORITY_HIGH_IDLE, (GSourceFunc)([](void *f) -> int {
							(*static_cast<dispatch_fn_t *>(f))();
							return G_SOURCE_REMOVE;
							}),
						new std::function<void()>(f),
						[](void *f) { delete static_cast<dispatch_fn_t *>(f); });
			}
		+/

		void setSize(int width, int height, bool resizable) {
			gtk_window_set_resizable(m_window, resizable);
			if (resizable) {
				gtk_window_set_default_size(m_window, width, height);
			}
			gtk_widget_set_size_request(m_window, width, height);
		}

		void init(const char *js) {
			WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager(m_webview);
			webkit_user_content_manager_add_script(
				manager, webkit_user_script_new(
					js, WebKitUserContentInjectedFrames.WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
					WebKitUserScriptInjectionTime.WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START, null, null));
			}

		void eval(const char *js) {
			webkit_web_view_run_javascript(m_webview, js, null, null, null);
		}

		protected:
		GtkWidget* m_window;
		GtkWidget* m_webview;
		msg_cb_t m_cb;
	}
} else version(WEBVIEW_COCOA) {
/+

//
// ====================================================================
//
// This implementation uses Cocoa WKWebView backend on macOS. It is
// written using ObjC runtime and uses WKWebView class as a browser runtime.
// You should pass "-framework Webkit" flag to the compiler.
//
// ====================================================================
//

#define OBJC_OLD_DISPATCH_PROTOTYPES 1
#include <CoreGraphics/CoreGraphics.h>
#include <objc/objc-runtime.h>

#define NSBackingStoreBuffered 2

#define NSWindowStyleMaskResizable 8
#define NSWindowStyleMaskMiniaturizable 4
#define NSWindowStyleMaskTitled 1
#define NSWindowStyleMaskClosable 2

#define NSApplicationActivationPolicyRegular 0

#define WKUserScriptInjectionTimeAtDocumentStart 0

id operator"" _cls(const char *s, std::size_t sz) {
  return (id)objc_getClass(s);
}
SEL operator"" _sel(const char *s, std::size_t sz) {
  return sel_registerName(s);
}
id operator"" _str(const char *s, std::size_t sz) {
  return objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, s);
}

class browser_engine {
public:
  browser_engine(msg_cb_t cb, bool dbg, void *window) : m_cb(cb) {
    // Application
    id app = objc_msgSend("NSApplication"_cls, "sharedApplication"_sel);
    objc_msgSend(app, "setActivationPolicy:"_sel,
                 NSApplicationActivationPolicyRegular);

    // Delegate
    auto cls = objc_allocateClassPair((Class) "NSObject"_cls, "AppDelegate", 0);
    class_addProtocol(cls, objc_getProtocol("NSApplicationDelegate"));
    class_addProtocol(cls, objc_getProtocol("WKScriptMessageHandler"));
    class_addMethod(
        cls, "applicationShouldTerminateAfterLastWindowClosed:"_sel,
        (IMP)(+[](id self, SEL cmd, id notification) -> BOOL { return 1; }),
        "c@:@");
    class_addMethod(
        cls, "userContentController:didReceiveScriptMessage:"_sel,
        (IMP)(+[](id self, SEL cmd, id notification, id msg) {
          auto w = (browser_engine *)objc_getAssociatedObject(self, "webview");
          w->m_cb((const char *)objc_msgSend(objc_msgSend(msg, "body"_sel),
                                             "UTF8String"_sel));
        }),
        "v@:@@");
    objc_registerClassPair(cls);

    auto delegate = objc_msgSend((id)cls, "new"_sel);
    objc_setAssociatedObject(delegate, "webview", (id)this,
                             OBJC_ASSOCIATION_ASSIGN);
    objc_msgSend(app, sel_registerName("setDelegate:"), delegate);

    // Main window
    if (window is null) {
      m_window = objc_msgSend("NSWindow"_cls, "alloc"_sel);
      m_window = objc_msgSend(
          m_window, "initWithContentRect:styleMask:backing:defer:"_sel,
          CGRectMake(0, 0, 0, 0), 0, NSBackingStoreBuffered, 0);
      setSize(480, 320, true);
    } else {
      m_window = (id)window;
    }

    // Webview
    auto config = objc_msgSend("WKWebViewConfiguration"_cls, "new"_sel);
    m_manager = objc_msgSend(config, "userContentController"_sel);
    m_webview = objc_msgSend("WKWebView"_cls, "alloc"_sel);
    objc_msgSend(m_webview, "initWithFrame:configuration:"_sel,
                 CGRectMake(0, 0, 0, 0), config);
    objc_msgSend(m_manager, "addScriptMessageHandler:name:"_sel, delegate,
                 "external"_str);
    init(R"script(
                      window.external = {
                        invoke: function(s) {
                          window.webkit.messageHandlers.external.postMessage(s);
                        },
                      };
                     )script");
    if (dbg) {
      objc_msgSend(objc_msgSend(config, "preferences"_sel),
                   "setValue:forKey:"_sel, 1, "developerExtrasEnabled"_str);
    }
    objc_msgSend(m_window, "setContentView:"_sel, m_webview);
    objc_msgSend(m_window, "makeKeyAndOrderFront:"_sel, null);
  }
  ~browser_engine() { close(); }
  void terminate() { close(); objc_msgSend("NSApp"_cls, "terminate:"_sel, null); }
  void run() {
    id app = objc_msgSend("NSApplication"_cls, "sharedApplication"_sel);
    dispatch([&]() { objc_msgSend(app, "activateIgnoringOtherApps:"_sel, 1); });
    objc_msgSend(app, "run"_sel);
  }
  void dispatch(std::function<void()> f) {
    dispatch_async_f(dispatch_get_main_queue(), new dispatch_fn_t(f),
                     (dispatch_function_t)([](void *arg) {
                       auto f = static_cast<dispatch_fn_t *>(arg);
                       (*f)();
                       delete f;
                     }));
  }
  void setTitle(const char *title) {
    objc_msgSend(
        m_window, "setTitle:"_sel,
        objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, title));
  }
  void setSize(int width, int height, bool resizable) {
    auto style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
                 NSWindowStyleMaskMiniaturizable;
    if (resizable) {
      style = style | NSWindowStyleMaskResizable;
    }
    objc_msgSend(m_window, "setStyleMask:"_sel, style);
    objc_msgSend(m_window, "setFrame:display:animate:"_sel,
                 CGRectMake(0, 0, width, height), 1, 0);
  }
  void navigate(const char *url) {
    auto nsurl = objc_msgSend(
        "NSURL"_cls, "URLWithString:"_sel,
        objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, url));
    objc_msgSend(
        m_webview, "loadRequest:"_sel,
        objc_msgSend("NSURLRequest"_cls, "requestWithURL:"_sel, nsurl));
  }
  void init(const char *js) {
    objc_msgSend(
        m_manager, "addUserScript:"_sel,
        objc_msgSend(
            objc_msgSend("WKUserScript"_cls, "alloc"_sel),
            "initWithSource:injectionTime:forMainFrameOnly:"_sel,
            objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, js),
            WKUserScriptInjectionTimeAtDocumentStart, 1));
  }
  void eval(const char *js) {
    objc_msgSend(m_webview, "evaluateJavaScript:completionHandler:"_sel,
                 objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, js),
                 null);
  }

protected:
  void close() { objc_msgSend(m_window, "close"_sel); }
  id m_window;
  id m_webview;
  id m_manager;
  msg_cb_t m_cb;
};

+/

} else version(WindowsWindow) {
/+

	//
	// ====================================================================
	//
	// This implementation uses Win32 API to create a native window. It can
	// use either MSHTML or EdgeHTML backend as a browser engine.
	//
	// ====================================================================
	//

	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>

	pragma(lib, "user32");

	class browser_window {
	public:
	  browser_window(msg_cb_t cb, void *window) : m_cb(cb) {
	    if (window is null) {
	      WNDCLASSEX wc;
	      ZeroMemory(&wc, sizeof(WNDCLASSEX));
	      wc.cbSize = sizeof(WNDCLASSEX);
	      wc.hInstance = GetModuleHandle(null);
	      wc.lpszClassName = "webview";
	      wc.lpfnWndProc =
		  (WNDPROC)(+[](HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) -> int {
		    auto w = (browser_window *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
		    switch (msg) {
		    case WM_SIZE:
		      w->resize();
		      break;
		    case WM_CLOSE:
		      DestroyWindow(hwnd);
		      break;
		    case WM_DESTROY:
		      w->terminate();
		      break;
		    default:
		      return DefWindowProc(hwnd, msg, wp, lp);
		    }
		    return 0;
		  });
	      RegisterClassEx(&wc);
	      m_window = CreateWindow("webview", "", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
				      CW_USEDEFAULT, 640, 480, null, null,
				      GetModuleHandle(null), null);
	      SetWindowLongPtr(m_window, GWLP_USERDATA, (LONG_PTR)this);
	    } else {
	      m_window = *(static_cast<HWND *>(window));
	    }

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

	  void run() {
	    MSG msg;
	    BOOL res;
	    while ((res = GetMessage(&msg, null, 0, 0)) != -1) {
	      if (msg.hwnd) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
		continue;
	      }
	      if (msg.message == WM_APP) {
		auto f = (dispatch_fn_t *)(msg.lParam);
		(*f)();
		delete f;
	      } else if (msg.message == WM_QUIT) {
		return;
	      }
	    }
	  }

	  void terminate() { PostQuitMessage(0); }
	  void dispatch(dispatch_fn_t f) {
	    PostThreadMessage(m_main_thread, WM_APP, 0, (LPARAM) new dispatch_fn_t(f));
	  }

	  void setTitle(const char *title) { SetWindowText(m_window, title); }

	  void setSize(int width, int height, bool resizable) {
	    RECT r;
	    r.left = 50;
	    r.top = 50;
	    r.right = width;
	    r.bottom = height;
	    AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, 0);
	    SetWindowPos(m_window, null, r.left, r.top, r.right - r.left,
			 r.bottom - r.top,
			 SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
	  }

	protected:
	  virtual void resize() {}
	  HWND m_window;
	  DWORD m_main_thread = GetCurrentThreadId();
	  msg_cb_t m_cb;
	};
+/
}

version(WEBVIEW_MSHTML) {
/+
	#include <exdisp.h>
	#include <exdispid.h>
	#include <mshtmhst.h>
	#include <mshtml.h>
	#include <shobjidl.h>
	pragma(lib, "ole32");
	pragma(lib, "oleaut32");

	#define DISPID_EXTERNAL_INVOKE 0x1000

	class browser_engine : public browser_window,
			       public IOleClientSite,
			       public IOleInPlaceSite,
			       public IOleInPlaceFrame,
			       public IDocHostUIHandler,
			       public DWebBrowserEvents2 {
	public:
	  browser_engine(msg_cb_t cb, bool dbg, void *window)
	      : browser_window(cb, window) {
	    RECT rect;
	    LPCLASSFACTORY cf = null;
	    IOleObject *obj = null;

	    fix_ie_compat_mode();

	    OleInitialize(null);
	    CoGetClassObject(CLSID_WebBrowser,
			     CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER, null,
			     IID_IClassFactory, (void **)&cf);
	    cf->CreateInstance(null, IID_IOleObject, (void **)&obj);
	    cf->Release();

	    obj->SetClientSite(this);
	    OleSetContainedObject(obj, TRUE);
	    GetWindowRect(m_window, &rect);
	    obj->DoVerb(OLEIVERB_INPLACEACTIVATE, null, this, -1, m_window, &rect);
	    obj->QueryInterface(IID_IWebBrowser2, (void **)&m_webview);

	    IConnectionPointContainer *cpc;
	    IConnectionPoint *cp;
	    DWORD cookie;
	    m_webview->QueryInterface(IID_IConnectionPointContainer, (void **)&cpc);
	    cpc->FindConnectionPoint(DIID_DWebBrowserEvents2, &cp);
	    cpc->Release();
	    cp->Advise(static_cast<IOleClientSite *>(this), &cookie);

	    resize();
	    navigate("about:blank");
	  }

	  ~browser_engine() { OleUninitialize(); }

	  void navigate(const char *url) {
	    VARIANT v;
	    DWORD size = MultiByteToWideChar(CP_UTF8, 0, url, -1, 0, 0);
	    WCHAR *ws = (WCHAR *)GlobalAlloc(GMEM_FIXED, sizeof(WCHAR) * size);
	    MultiByteToWideChar(CP_UTF8, 0, url, -1, ws, size);
	    VariantInit(&v);
	    v.vt = VT_BSTR;
	    v.bstrVal = SysAllocString(ws);
	    m_webview->Navigate2(&v, null, null, null, null);
	    VariantClear(&v);
	  }

	  void eval(const char *js) {
	    // TODO
	  }

	private:
	  IWebBrowser2 *m_webview;

	  int fix_ie_compat_mode() {
	    const char *WEBVIEW_KEY_FEATURE_BROWSER_EMULATION =
		"Software\\Microsoft\\Internet "
		"Explorer\\Main\\FeatureControl\\FEATURE_BROWSER_EMULATION";
	    HKEY hKey;
	    DWORD ie_version = 11000;
	    TCHAR appname[MAX_PATH + 1];
	    TCHAR *p;
	    if (GetModuleFileName(null, appname, MAX_PATH + 1) == 0) {
	      return -1;
	    }
	    for (p = &appname[strlen(appname) - 1]; p != appname && *p != '\\'; p--) {
	    }
	    p++;
	    if (RegCreateKey(HKEY_CURRENT_USER, WEBVIEW_KEY_FEATURE_BROWSER_EMULATION,
			     &hKey) != ERROR_SUCCESS) {
	      return -1;
	    }
	    if (RegSetValueEx(hKey, p, 0, REG_DWORD, (BYTE *)&ie_version,
			      sizeof(ie_version)) != ERROR_SUCCESS) {
	      RegCloseKey(hKey);
	      return -1;
	    }
	    RegCloseKey(hKey);
	    return 0;
	  }

	  // Inheruted via browser_window
	  void resize() override {
	    RECT rect;
	    GetClientRect(m_window, &rect);
	    m_webview->put_Left(0);
	    m_webview->put_Top(0);
	    m_webview->put_Width(rect.right);
	    m_webview->put_Height(rect.bottom);
	    m_webview->put_Visible(VARIANT_TRUE);
	  }

	  // Inherited via IUnknown
	  ULONG __stdcall AddRef(void) override { return 1; }
	  ULONG __stdcall Release(void) override { return 1; }
	  HRESULT __stdcall QueryInterface(REFIID riid, void **obj) override {
	    if (riid == IID_IUnknown || riid == IID_IOleClientSite) {
	      *obj = static_cast<IOleClientSite *>(this);
	      return S_OK;
	    }
	    if (riid == IID_IOleInPlaceSite) {
	      *obj = static_cast<IOleInPlaceSite *>(this);
	      return S_OK;
	    }
	    if (riid == IID_IDocHostUIHandler) {
	      *obj = static_cast<IDocHostUIHandler *>(this);
	      return S_OK;
	    }
	    if (riid == IID_IDispatch || riid == DIID_DWebBrowserEvents2) {
	      *obj = static_cast<IDispatch *>(this);
	      return S_OK;
	    }
	    *obj = null;
	    return E_NOINTERFACE;
	  }

	  // Inherited via IOleClientSite
	  HRESULT __stdcall SaveObject(void) override { return E_NOTIMPL; }
	  HRESULT __stdcall GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
				       IMoniker **ppmk) override {
	    return E_NOTIMPL;
	  }
	  HRESULT __stdcall GetContainer(IOleContainer **ppContainer) override {
	    *ppContainer = null;
	    return E_NOINTERFACE;
	  }
	  HRESULT __stdcall ShowObject(void) override { return S_OK; }
	  HRESULT __stdcall OnShowWindow(BOOL fShow) override { return S_OK; }
	  HRESULT __stdcall RequestNewObjectLayout(void) override { return E_NOTIMPL; }

	  // Inherited via IOleInPlaceSite
	  HRESULT __stdcall GetWindow(HWND *phwnd) override {
	    *phwnd = m_window;
	    return S_OK;
	  }
	  HRESULT __stdcall ContextSensitiveHelp(BOOL fEnterMode) override {
	    return E_NOTIMPL;
	  }
	  HRESULT __stdcall CanInPlaceActivate(void) override { return S_OK; }
	  HRESULT __stdcall OnInPlaceActivate(void) override { return S_OK; }
	  HRESULT __stdcall OnUIActivate(void) override { return S_OK; }
	  HRESULT __stdcall GetWindowContext(
	      IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc,
	      LPRECT lprcPosRect, LPRECT lprcClipRect,
	      LPOLEINPLACEFRAMEINFO lpFrameInfo) override {
	    *ppFrame = static_cast<IOleInPlaceFrame *>(this);
	    *ppDoc = null;
	    lpFrameInfo->fMDIApp = FALSE;
	    lpFrameInfo->hwndFrame = m_window;
	    lpFrameInfo->haccel = 0;
	    lpFrameInfo->cAccelEntries = 0;
	    return S_OK;
	  }
	  HRESULT __stdcall Scroll(SIZE scrollExtant) override { return E_NOTIMPL; }
	  HRESULT __stdcall OnUIDeactivate(BOOL fUndoable) override { return S_OK; }
	  HRESULT __stdcall OnInPlaceDeactivate(void) override { return S_OK; }
	  HRESULT __stdcall DiscardUndoState(void) override { return E_NOTIMPL; }
	  HRESULT __stdcall DeactivateAndUndo(void) override { return E_NOTIMPL; }
	  HRESULT __stdcall OnPosRectChange(LPCRECT lprcPosRect) override {
	    IOleInPlaceObject *inplace;
	    m_webview->QueryInterface(IID_IOleInPlaceObject, (void **)&inplace);
	    inplace->SetObjectRects(lprcPosRect, lprcPosRect);
	    return S_OK;
	  }

	  // Inherited via IDocHostUIHandler
	  HRESULT __stdcall ShowContextMenu(DWORD dwID, POINT *ppt,
					    IUnknown *pcmdtReserved,
					    IDispatch *pdispReserved) override {
	    return S_OK;
	  }
	  HRESULT __stdcall GetHostInfo(DOCHOSTUIINFO *pInfo) override {
	    pInfo->dwDoubleClick = DOCHOSTUIDBLCLK_DEFAULT;
	    pInfo->dwFlags = DOCHOSTUIFLAG_NO3DBORDER;
	    return S_OK;
	  }
	  HRESULT __stdcall ShowUI(DWORD dwID, IOleInPlaceActiveObject *pActiveObject,
				   IOleCommandTarget *pCommandTarget,
				   IOleInPlaceFrame *pFrame,
				   IOleInPlaceUIWindow *pDoc) override {
	    return S_OK;
	  }
	  HRESULT __stdcall HideUI(void) override { return S_OK; }
	  HRESULT __stdcall UpdateUI(void) override { return S_OK; }
	  HRESULT __stdcall EnableModeless(BOOL fEnable) override { return S_OK; }
	  HRESULT __stdcall OnDocWindowActivate(BOOL fActivate) override {
	    return S_OK;
	  }
	  HRESULT __stdcall OnFrameWindowActivate(BOOL fActivate) override {
	    return S_OK;
	  }
	  HRESULT __stdcall ResizeBorder(LPCRECT prcBorder,
					 IOleInPlaceUIWindow *pUIWindow,
					 BOOL fRameWindow) override {
	    return S_OK;
	  }
	  HRESULT __stdcall GetOptionKeyPath(LPOLESTR *pchKey, DWORD dw) override {
	    return S_FALSE;
	  }
	  HRESULT __stdcall GetDropTarget(IDropTarget *pDropTarget,
					  IDropTarget **ppDropTarget) override {
	    return E_NOTIMPL;
	  }
	  HRESULT __stdcall GetExternal(IDispatch **ppDispatch) override {
	    *ppDispatch = static_cast<IDispatch *>(this);
	    return S_OK;
	  }
	  HRESULT __stdcall TranslateUrl(DWORD dwTranslate, LPWSTR pchURLIn,
					 LPWSTR *ppchURLOut) override {
	    *ppchURLOut = null;
	    return S_FALSE;
	  }
	  HRESULT __stdcall FilterDataObject(IDataObject *pDO,
					     IDataObject **ppDORet) override {
	    *ppDORet = null;
	    return S_FALSE;
	  }
	  HRESULT __stdcall TranslateAcceleratorA(LPMSG lpMsg,
						  const GUID *pguidCmdGroup,
						  DWORD nCmdID) {
	    return S_FALSE;
	  }

	  // Inherited via IOleInPlaceFrame
	  HRESULT __stdcall GetBorder(LPRECT lprectBorder) override { return S_OK; }
	  HRESULT __stdcall RequestBorderSpace(LPCBORDERWIDTHS pborderwidths) override {
	    return S_OK;
	  }
	  HRESULT __stdcall SetBorderSpace(LPCBORDERWIDTHS pborderwidths) override {
	    return S_OK;
	  }
	  HRESULT __stdcall SetActiveObject(IOleInPlaceActiveObject *pActiveObject,
					    LPCOLESTR pszObjName) override {
	    return S_OK;
	  }
	  HRESULT __stdcall InsertMenus(HMENU hmenuShared,
					LPOLEMENUGROUPWIDTHS lpMenuWidths) override {
	    return S_OK;
	  }
	  HRESULT __stdcall SetMenu(HMENU hmenuShared, HOLEMENU holemenu,
				    HWND hwndActiveObject) override {
	    return S_OK;
	  }
	  HRESULT __stdcall RemoveMenus(HMENU hmenuShared) override { return S_OK; }
	  HRESULT __stdcall SetStatusText(LPCOLESTR pszStatusText) override {
	    return S_OK;
	  }
	  HRESULT __stdcall TranslateAcceleratorA(LPMSG lpmsg, WORD wID) {
	    return S_OK;
	  }

	  // Inherited via IDispatch
	  HRESULT __stdcall GetTypeInfoCount(UINT *pctinfo) override { return S_OK; }
	  HRESULT __stdcall GetTypeInfo(UINT iTInfo, LCID lcid,
					ITypeInfo **ppTInfo) override {
	    return S_OK;
	  }
	  HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
					  LCID lcid, DISPID *rgDispId) override {
	    *rgDispId = DISPID_EXTERNAL_INVOKE;
	    return S_OK;
	  }
	  HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
				   WORD wFlags, DISPPARAMS *pDispParams,
				   VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
				   UINT *puArgErr) override {
	    if (dispIdMember == DISPID_NAVIGATECOMPLETE2) {
	    } else if (dispIdMember == DISPID_DOCUMENTCOMPLETE) {
	    } else if (dispIdMember == DISPID_EXTERNAL_INVOKE) {
	    }
	    return S_OK;
	  }
	};
+/
} else version(WEBVIEW_EDGE) {
/+
	#include <objbase.h>
	#include <winrt/Windows.Foundation.h>
	#include <winrt/Windows.Web.UI.Interop.h>

	#pragma comment(lib, "windowsapp")

	using namespace winrt;
	using namespace Windows::Foundation;
	using namespace Windows::Web::UI;
	using namespace Windows::Web::UI::Interop;

	class browser_engine : public browser_window {
	public:
	  browser_engine(msg_cb_t cb, bool dbg, void *window)
	      : browser_window(cb, window) {
	    init_apartment(winrt::apartment_type::single_threaded);
	    m_process = WebViewControlProcess();
	    auto op = m_process.CreateWebViewControlAsync(
		reinterpret_cast<int64_t>(m_window), Rect());
	    if (op.Status() != AsyncStatus::Completed) {
	      handle h(CreateEvent(null, false, false, null));
	      op.Completed([h = h.get()](auto, auto) { SetEvent(h); });
	      HANDLE hs[] = {h.get()};
	      DWORD i;
	      CoWaitForMultipleHandles(COWAIT_DISPATCH_WINDOW_MESSAGES |
					   COWAIT_DISPATCH_CALLS |
					   COWAIT_INPUTAVAILABLE,
				       INFINITE, 1, hs, &i);
	    }
	    m_webview = op.GetResults();
	    m_webview.Settings().IsScriptNotifyAllowed(true);
	    m_webview.IsVisible(true);
	    m_webview.ScriptNotify([=](auto const &sender, auto const &args) {
	      std::string s = winrt::to_string(args.Value());
	      m_cb(s.c_str());
	    });
	    m_webview.NavigationStarting([=](auto const &sender, auto const &args) {
	      m_webview.AddInitializeScript(winrt::to_hstring(init_js));
	    });
	    init("window.external.invoke = s => window.external.notify(s)");
	    resize();
	  }

	  void navigate(const char *url) {
	    Uri uri(winrt::to_hstring(url));
	    // TODO: if url starts with 'data:text/html,' prefix then use it as a string
	    m_webview.Navigate(uri);
	    // m_webview.NavigateToString(winrt::to_hstring(url));
	  }
	  void init(const char *js) {
	    init_js = init_js + "(function(){" + js + "})();";
	  }
	  void eval(const char *js) {
	    m_webview.InvokeScriptAsync(
		L"eval", single_threaded_vector<hstring>({winrt::to_hstring(js)}));
	  }

	private:
	  void resize() {
	    RECT r;
	    GetClientRect(m_window, &r);
	    Rect bounds(r.left, r.top, r.right - r.left, r.bottom - r.top);
	    m_webview.Bounds(bounds);
	  }
	  WebViewControlProcess m_process;
	  WebViewControl m_webview = null;
	  std::string init_js = "";
	};
+/
}