/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License v3 as published by the Free
Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with LiveCode.  If not see <http://www.gnu.org/licenses/>.  */

#include "foundation.h"

#include <include/cef_app.h>

#include <map>

#include "cefbrowser_msg.h"

////////////////////////////////////////////////////////////////////////////////

// Use JS "String" function to convert values to string
bool MCCefV8ValueConvertToString(CefRefPtr<CefV8Context> p_context, CefRefPtr<CefV8Value> &x_value)
{
	if (x_value->IsString())
		return true;

	bool t_success;
	t_success = true;

	CefRefPtr<CefV8Exception> t_exception;

	CefRefPtr<CefV8Value> t_string_func;
	if (t_success)
		t_success = p_context->Eval("String", "", 1, t_string_func, t_exception);

	CefRefPtr<CefV8Value> t_string_value;
	if (t_success)
	{
		CefV8ValueList t_args;
		t_args.push_back(x_value);

		t_string_value = t_string_func->ExecuteFunctionWithContext(p_context, NULL, t_args);

		t_success = t_string_value != NULL;
	}

	if (t_success)
		x_value = t_string_value;

	return t_success;
}

bool MCCefHandleExecuteScript(CefRefPtr<CefBrowser> p_browser, const CefString &p_script, CefRefPtr<CefV8Value> &r_return_value)
{
	bool t_success;
	t_success = true;

	CefRefPtr<CefFrame> t_frame;
	t_frame = p_browser->GetMainFrame();

	CefRefPtr<CefV8Context> t_context;
	t_context = t_frame->GetV8Context();

	CefRefPtr<CefV8Value> t_return_value;
	CefRefPtr<CefV8Exception> t_exception;

	t_success = t_context != NULL;

	if (t_success)
		t_success = t_context->Eval(p_script, "", 1, t_return_value, t_exception);

	if (t_success)
		r_return_value = t_return_value;

	return t_success;
}

//////////

bool MCCefListToV8List(CefRefPtr<CefV8Context> p_context, CefRefPtr<CefListValue> p_list, CefV8ValueList &x_list)
{
	bool t_success;
	t_success = true;

	p_context->Enter();

	size_t t_size;
	t_size = p_list->GetSize();

	x_list.clear();

	for (uint32_t i = 0; t_success && i < t_size; i++)
	{
		CefValueType t_type;
		t_type = p_list->GetType(i);

		CefRefPtr<CefV8Value> t_v8;

		switch (t_type)
		{
		case VTYPE_NULL:
			t_v8 = CefV8Value::CreateNull();
			break;

		case VTYPE_BOOL:
			t_v8 = CefV8Value::CreateBool(p_list->GetBool(i));
			break;

		case VTYPE_INT:
			t_v8 = CefV8Value::CreateInt(p_list->GetInt(i));
			break;

		case VTYPE_DOUBLE:
			t_v8 = CefV8Value::CreateDouble(p_list->GetDouble(i));
			break;

		case VTYPE_STRING:
			t_v8 = CefV8Value::CreateString(p_list->GetString(i));
			break;

		case VTYPE_BINARY:
		case VTYPE_DICTIONARY:
		case VTYPE_LIST:
			/* TODO - IMPLEMENT */
			t_success = false;
			break;
		case VTYPE_INVALID:
			t_success = false;
		}

		t_success = t_v8 != NULL;

		if (t_success)
			x_list.push_back(t_v8);
	}

	p_context->Exit();

	return t_success;
}

bool MCCefHandleCallScript(CefRefPtr<CefBrowser> p_browser, const CefString &p_function_name, CefRefPtr<CefListValue> p_args, CefString &r_return_value)
{
	bool t_success;
	t_success = true;

	CefRefPtr<CefFrame> t_frame;
	t_frame = p_browser->GetMainFrame();

	CefRefPtr<CefV8Context> t_context;
	t_context = t_frame->GetV8Context();

	CefRefPtr<CefV8Value> t_function;
	CefV8ValueList t_args;

	CefRefPtr<CefV8Value> t_return_value;
	CefRefPtr<CefV8Exception> t_exception;

	t_success = t_context != NULL;

	if (t_success)
		t_success = t_context->Eval(p_function_name, "", 1, t_function, t_exception);

	if (t_success)
		t_success = MCCefListToV8List(t_context, p_args, t_args);

	if (t_success)
	{
		t_return_value = t_function->ExecuteFunctionWithContext(t_context, NULL, t_args);
		t_success = t_return_value != NULL;
	}

	if (t_success && !t_return_value->IsString())
		t_success = MCCefV8ValueConvertToString(t_context, t_return_value);

	if (t_success)
		r_return_value = t_return_value->GetStringValue();

	return t_success;
}

//////////

class MCGetSelectedTextDOMVisitor : public CefDOMVisitor
{
private:
	CefString m_selected_text;

public:
	CefString GetSelectedText() { return m_selected_text; };

	void Visit(CefRefPtr<CefDOMDocument> p_document) OVERRIDE
	{
		if (p_document->HasSelection())
			m_selected_text = p_document->GetSelectionAsText();
	}

	IMPLEMENT_REFCOUNTING(MCGetSelectedTextDOMVisitor);
};

bool MCCefHandleGetSelectedText(CefRefPtr<CefBrowser> p_browser, CefString &r_return_value)
{
	bool t_success;
	t_success = true;

	MCGetSelectedTextDOMVisitor *t_dom_visitor;
	t_dom_visitor = new (nothrow) MCGetSelectedTextDOMVisitor();
	t_success = t_dom_visitor != nil;

	CefRefPtr<CefDOMVisitor> t_visitor_ref;
	t_visitor_ref = t_dom_visitor;

	if (t_success)
	{
		p_browser->GetMainFrame()->VisitDOM(t_visitor_ref);

		r_return_value = t_dom_visitor->GetSelectedText();
	}

	return t_success;
}

//////////

class MCGetTitleDOMVisitor : public CefDOMVisitor
{
private:
	CefString m_title;

public:
	CefString GetTitle() { return m_title; };

	void Visit(CefRefPtr<CefDOMDocument> p_dom) OVERRIDE
	{
		m_title = p_dom->GetTitle();
	}

	IMPLEMENT_REFCOUNTING(MCGetTitleDOMVisitor);
};

bool MCCefHandleGetTitle(CefRefPtr<CefBrowser> p_browser, CefString &r_return_value)
{
	bool t_success;
	t_success = true;

	MCGetTitleDOMVisitor *t_dom_visitor;
	t_dom_visitor = new (nothrow) MCGetTitleDOMVisitor();
	t_success = t_dom_visitor != nil;

	CefRefPtr<CefDOMVisitor> t_visitor_ref;
	t_visitor_ref = t_dom_visitor;

	if (t_success)
	{
		p_browser->GetMainFrame()->VisitDOM(t_visitor_ref);

		r_return_value = t_dom_visitor->GetTitle();
	}

	return t_success;
}

////////////////////////////////////////////////////////////////////////////////

bool MCCefSendStringResult(CefRefPtr<CefBrowser> p_browser, bool p_success, const CefString &p_return_value)
{
	bool t_success;
	t_success = true;

	CefRefPtr<CefProcessMessage> t_message;
	t_message = CefProcessMessage::Create(MC_CEFMSG_RESULT);
	t_success = t_message != nil;
	
	if (t_success)
	{
		CefRefPtr<CefListValue> t_args;

		t_args = t_message->GetArgumentList();

		t_success = t_args->SetBool(0, p_success) &&
			t_args->SetString(1, p_return_value);
	}

	if (t_success)
		t_success = p_browser->SendProcessMessage(PID_BROWSER, t_message);
	
	return t_success;
}

bool MCCefSendIntResult(CefRefPtr<CefBrowser> p_browser, bool p_success, int p_return_value)
{
	bool t_success;
	t_success = true;

	CefRefPtr<CefProcessMessage> t_message;
	t_message = CefProcessMessage::Create(MC_CEFMSG_RESULT);
	t_success = t_message != nil;
	
	if (t_success)
	{
		CefRefPtr<CefListValue> t_args;

		t_args = t_message->GetArgumentList();

		t_success = t_args->SetBool(0, p_success) &&
			t_args->SetInt(1, p_return_value);
	}

	if (t_success)
		t_success = p_browser->SendProcessMessage(PID_BROWSER, t_message);
	
	return t_success;
}

bool MCCefSendHandlerMessage(CefRefPtr<CefBrowser> p_browser, const CefString &p_handler, const CefV8ValueList &p_args)
{
	bool t_success;
	t_success = true;

	CefRefPtr<CefProcessMessage> t_message;
	t_message = CefProcessMessage::Create(MC_CEFMSG_JS_HANDLER);
	t_success = t_message != nil;
	
	if (t_success)
	{
		CefRefPtr<CefListValue> t_args;

		t_args = t_message->GetArgumentList();

		t_success = t_args->SetString(0, p_handler);

		for (CefV8ValueList::const_iterator i = p_args.begin(); t_success && i != p_args.end(); i++)
		{
			CefRefPtr<CefV8Value> t_val;
			t_val = *i;

			t_success = MCCefV8ValueConvertToString(CefV8Context::GetCurrentContext(), t_val);
			if (t_success)
				t_success = t_args->SetString((i - p_args.begin()) + 1, t_val->GetStringValue());
		}
	}

	if (t_success)
		t_success = p_browser->SendProcessMessage(PID_BROWSER, t_message);
	
	return t_success;
}

class MCCefLCFuncHandler : public CefV8Handler
{
private:
	CefString m_name;

public:
	MCCefLCFuncHandler(const CefString &p_name)
	{
		m_name = p_name;
	}

	virtual bool Execute(const CefString &p_name, CefRefPtr<CefV8Value> p_object, const CefV8ValueList &p_args, CefRefPtr<CefV8Value> &r_retval, CefString &r_exception) OVERRIDE
	{
		if (p_name == m_name)
		{
			/* UNCHECKED */ MCCefSendHandlerMessage(CefV8Context::GetCurrentContext()->GetBrowser(), m_name, p_args);

			r_retval = CefV8Value::CreateNull();

			return true;
		}

		return false;
	}

	IMPLEMENT_REFCOUNTING(MCCefLCFuncHandler);
};

class MCCefRenderApp : public CefApp, CefRenderProcessHandler
{
private:
	bool GetV8Context(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefV8Context> &r_context)
	{
		CefRefPtr<CefFrame> t_frame;
		t_frame = p_browser->GetMainFrame();
		
		if (t_frame == nil)
			return false;
		
		CefRefPtr<CefV8Context> t_context;
		t_context = t_frame->GetV8Context();
		
		if (t_context == nil)
			return false;
		
		r_context = t_context;
		
		return true;
	}
	
	bool GetLiveCodeGlobalObj(CefRefPtr<CefV8Context> p_context, CefRefPtr<CefV8Value> &r_global_obj)
	{
		CefString t_obj_name("liveCode");
		
		if (!p_context->Enter())
			return false;
		
		bool t_success;
		t_success = true;
		
		CefRefPtr<CefV8Value> t_global;
		t_global = p_context->GetGlobal();
		
		t_success = t_global != nil;
		
		CefRefPtr<CefV8Value> t_obj;
		
		if (t_success)
		{
			if (t_global->HasValue(t_obj_name))
			{
				t_obj = t_global->GetValue(t_obj_name);
				t_success = t_obj != nil;
			}
			else
			{
				t_obj = CefV8Value::CreateObject(nullptr, nullptr);
				t_success = t_obj != nil;
				
				if (t_success)
					t_success = t_global->SetValue(t_obj_name, t_obj, V8_PROPERTY_ATTRIBUTE_READONLY);
			}
		}
		
		if (t_success)
			r_global_obj = t_obj;
		
		p_context->Exit();
		
		return t_success;
	}
	
	// IM-2014-03-13: [[ revBrowserCEF ]] Add the named handler to the liveCode object browser's JavaScript context
	bool AddLiveCodeHandler(CefRefPtr<CefBrowser> p_browser, const CefString &p_name)
	{
		bool t_success;
		t_success = true;
		
		bool t_entered;
		t_entered = false;
		
		CefRefPtr<CefV8Context> t_context;
		t_success = GetV8Context(p_browser, t_context);
		
		if (t_success)
			t_success = t_entered = t_context->Enter();
		
		CefRefPtr<CefV8Value> t_livecode_obj;
		if (t_success)
			t_success = GetLiveCodeGlobalObj(t_context, t_livecode_obj);
		
		if (t_success)
		{
			if (!t_livecode_obj->HasValue(p_name))
			{
				CefRefPtr<CefV8Handler> t_handler;
				t_success = nil != (t_handler = new (nothrow) MCCefLCFuncHandler(p_name));
				
				CefRefPtr<CefV8Value> t_func;
				if (t_success)
					t_success = nil != (t_func = CefV8Value::CreateFunction(p_name, t_handler));
				
				if (t_success)
					t_success = t_livecode_obj->SetValue(p_name, t_func, V8_PROPERTY_ATTRIBUTE_NONE);
			}
		}
		
		if (t_entered)
			t_context->Exit();
		
		return t_success;
	}
	
	// IM-2014-03-13: [[ revBrowserCEF ]] Remove the named handler from the liveCode object browser's JavaScript context
	bool RemoveLiveCodeHandler(CefRefPtr<CefBrowser> p_browser, const CefString &p_name)
	{
		bool t_success;
		t_success = true;
		
		bool t_entered;
		t_entered = false;
		
		CefRefPtr<CefV8Context> t_context;
		t_success = GetV8Context(p_browser, t_context);
		
		if (t_success)
			t_success = t_entered = t_context->Enter();
		
		CefRefPtr<CefV8Value> t_livecode_obj;
		if (t_success)
			t_success = GetLiveCodeGlobalObj(t_context, t_livecode_obj);
		
		if (t_success)
		{
			if (t_livecode_obj->HasValue(p_name))
				t_success = t_livecode_obj->DeleteValue(p_name);
		}
		
		if (t_entered)
			t_context->Exit();
		
		return t_success;
	}

public:
	virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() OVERRIDE { return this; }

	// RenderProcessHandler interface
	virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> p_browser, CefProcessId p_source_process, CefRefPtr<CefProcessMessage> p_message) OVERRIDE
	{
		CefString t_message_name;
		t_message_name = p_message->GetName();

		if (t_message_name == MC_CEFMSG_EXECUTE_SCRIPT)
		{
			bool t_success;
			CefRefPtr<CefV8Value> t_return_value;

			t_success = MCCefHandleExecuteScript(p_browser, p_message->GetArgumentList()->GetString(0), t_return_value);

			if (t_success && t_return_value->IsInt())
			{
				/* UNCHECKED */ MCCefSendIntResult(p_browser, t_success, t_return_value->GetIntValue());
				return true;
			}

			CefString t_return_string;
			if (t_success)
				t_success = MCCefV8ValueConvertToString(p_browser->GetMainFrame()->GetV8Context(), t_return_value);

			if (t_success)
				t_return_string = t_return_value->GetStringValue();
			/* UNCHECKED */ MCCefSendStringResult(p_browser, t_success, t_return_string);

			return true;
		}
		else if (t_message_name == MC_CEFMSG_CALL_SCRIPT)
		{
			bool t_success;
			CefString t_return_value;

			CefRefPtr<CefListValue> t_args_list;
			t_args_list = p_message->GetArgumentList();
			t_success = MCCefHandleCallScript(p_browser, t_args_list->GetString(0), t_args_list->GetList(1), t_return_value);

			/* UNCHECKED */ MCCefSendStringResult(p_browser, t_success, t_return_value);

			return true;
		}
		else if (t_message_name == MC_CEFMSG_GET_SELECTED_TEXT)
		{
			bool t_success;
			CefString t_return_value;

			t_success = MCCefHandleGetSelectedText(p_browser, t_return_value);

			/* UNCHECKED */ MCCefSendStringResult(p_browser, t_success, t_return_value);

			return true;
		}
		else if (t_message_name == MC_CEFMSG_GET_TITLE)
		{
			bool t_success;
			CefString t_return_value;

			t_success = MCCefHandleGetTitle(p_browser, t_return_value);

			/* UNCHECKED */ MCCefSendStringResult(p_browser, t_success, t_return_value);

			return true;
		}
		else if (t_message_name == MC_CEFMSG_ENABLE_JS_HANDLER)
		{
			bool t_success;

			CefString t_handler;
			t_handler = p_message->GetArgumentList()->GetString(0);

			bool t_enable;
			t_enable = p_message->GetArgumentList()->GetBool(1);

			if (t_enable)
				t_success = AddLiveCodeHandler(p_browser, t_handler);
			else
				t_success = RemoveLiveCodeHandler(p_browser, t_handler);

			///* UNCHECKED */ MCCefSendIntResult(p_browser, t_success, 0);

			return true;
		}
		else
			return CefRenderProcessHandler::OnProcessMessageReceived(p_browser, p_source_process, p_message);
	}

	IMPLEMENT_REFCOUNTING(MCCefRenderApp);
};

////////////////////////////////////////////////////////////////////////////////

// IM-2014-03-13: [[ revBrowserCEF ]] create the app handler
bool MCCefCreateApp(CefRefPtr<CefApp> &r_app)
{
	MCCefRenderApp *t_app;
	t_app = new (nothrow) MCCefRenderApp();
	
	if (t_app == nil)
	{
		//MCLog("failed to create app", nil);
		return false;
	}
	
	r_app = t_app;
	
	return true;
}