// Copyright © 2019 The CefSharp Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

#pragma once

#include "include/cef_v8.h"
#include "RegisterBoundObjectRegistry.h"
#include "..\CefSharp.Core\Internals\Messaging\Messages.h"
#include "..\CefSharp.Core\Internals\Serialization\Primitives.h"

using namespace System;
using namespace CefSharp::Internals::Messaging;
using namespace CefSharp::Internals::Serialization;

namespace CefSharp
{
    const CefString kBindObjectAsync = CefString("BindObjectAsync");
    const CefString kBindObjectAsyncCamelCase = CefString("bindObjectAsync");

    private class BindObjectAsyncHandler : public CefV8Handler
    {
    private:
        gcroot<RegisterBoundObjectRegistry^> _callbackRegistry;
        gcroot<Dictionary<String^, JavascriptObject^>^> _javascriptObjects;
        gcroot<CefBrowserWrapper^> _browserWrapper;

    public:
        BindObjectAsyncHandler(RegisterBoundObjectRegistry^ callbackRegistery, Dictionary<String^, JavascriptObject^>^ javascriptObjects, CefBrowserWrapper^ browserWrapper)
        {
            _callbackRegistry = callbackRegistery;
            _javascriptObjects = javascriptObjects;
            _browserWrapper = browserWrapper;
        }

        ~BindObjectAsyncHandler()
        {
            _callbackRegistry = nullptr;
            _javascriptObjects = nullptr;
            _browserWrapper = nullptr;
        }

        bool Execute(const CefString& name, CefRefPtr<CefV8Value> object, const CefV8ValueList& arguments, CefRefPtr<CefV8Value>& retval, CefString& exception) OVERRIDE
        {
            auto context = CefV8Context::GetCurrentContext();

            if (context.get() && context->Enter())
            {
                try
                {
                    auto params = CefListValue::Create();

                    auto boundObjectRequired = false;
                    auto notifyIfAlreadyBound = false;
                    auto ignoreCache = false;
                    auto cachedObjects = gcnew List<JavascriptObject^>();
                    //TODO: Create object to represent this information
                    auto objectNamesWithBoundStatus = gcnew List<Tuple<String^, bool, bool>^>();
                    auto objectCount = 0;

                    if (arguments.size() > 0)
                    {
                        objectCount = (int)arguments.size();

                        //If first argument is an object, we'll see if it contains config values
                        if (arguments[0]->IsObject())
                        {
                            //Upper and camelcase options are supported
                            notifyIfAlreadyBound = GetV8BoolValue(arguments[0], "NotifyIfAlreadyBound", "notifyIfAlreadyBound");
                            ignoreCache = GetV8BoolValue(arguments[0], "IgnoreCache", "ignoreCache");

                            //If we have a config object then we remove that from the count
                            objectCount = objectCount - 1;
                        }

                        auto global = context->GetGlobal();

                        //Loop through all arguments and ignore anything that's not a string
                        for (auto i = 0; i < arguments.size(); i++)
                        {
                            //Validate arg as being a string
                            if (arguments[i]->IsString())
                            {
                                auto objectName = arguments[i]->GetStringValue();
                                auto managedObjectName = StringUtils::ToClr(objectName);
                                auto alreadyBound = global->HasValue(objectName);
                                auto cached = false;

                                //Check if the object has already been bound
                                if (alreadyBound)
                                {
                                    cached = _javascriptObjects->ContainsKey(managedObjectName);
                                }
                                else
                                {
                                    //If no matching object found then we'll add the object name to the list
                                    boundObjectRequired = true;
                                    params->SetString(i, objectName);

                                    JavascriptObject^ obj;
                                    if (_javascriptObjects->TryGetValue(managedObjectName, obj))
                                    {
                                        cachedObjects->Add(obj);

                                        cached = true;
                                    }
                                }

                                objectNamesWithBoundStatus->Add(Tuple::Create(managedObjectName, alreadyBound, cached));
                            }
                        }
                    }
                    else
                    {
                        //No objects names were specified so we default to makeing the request
                        boundObjectRequired = true;
                    }

                    auto frame = context->GetFrame();

                    if (frame.get() && frame->IsValid())
                    {
                        if (boundObjectRequired || ignoreCache)
                        {
                            //If the number of cached objects matches the number of args
                            //(we have a cached copy of all requested objects)
                            //then we'll immediately bind the cached objects
                            if (cachedObjects->Count == objectCount && ignoreCache == false)
                            {
                                if (Object::ReferenceEquals(_browserWrapper, nullptr))
                                {
                                    exception = "BindObjectAsyncHandler::Execute - Browser wrapper null, unable to bind objects";

                                    return true;
                                }

                                auto browser = context->GetBrowser();

                                auto rootObjectWrappers = _browserWrapper->JavascriptRootObjectWrappers;

                                JavascriptRootObjectWrapper^ rootObject;
                                if (!rootObjectWrappers->TryGetValue(frame->GetIdentifier(), rootObject))
                                {
                                    rootObject = gcnew JavascriptRootObjectWrapper(browser->GetIdentifier(), _browserWrapper->BrowserProcess);
                                    rootObjectWrappers->TryAdd(frame->GetIdentifier(), rootObject);
                                }

                                //Cached objects only contains a list of objects not already bound
                                rootObject->Bind(cachedObjects, context->GetGlobal());

                                //Objects already bound or ignore cache
                                CefRefPtr<CefV8Value> promiseResolve;
                                CefRefPtr<CefV8Exception> promiseException;

                                auto promiseResolveScript = StringUtils::ToNative("Promise.resolve({Success:true, Count:" + cachedObjects->Count + ", Message:'OK'});");

                                if (context->Eval(promiseResolveScript, CefString(), 0, promiseResolve, promiseException))
                                {
                                    retval = promiseResolve;
                                }
                                else
                                {
                                    exception = promiseException->GetMessage();

                                    return true;
                                }

                                NotifyObjectBound(frame, objectNamesWithBoundStatus);
                            }
                            else
                            {
                                CefRefPtr<CefV8Value> promiseData;
                                CefRefPtr<CefV8Exception> promiseException;
                                //this will create a promise and give us the reject/resolve functions {p: Promise, res: resolve(), rej: reject()}
                                if (!context->Eval(CefAppUnmanagedWrapper::kPromiseCreatorScript, CefString(), 0, promiseData, promiseException))
                                {
                                    exception = promiseException->GetMessage();

                                    return true;
                                }

                                //when refreshing the browser this is sometimes null, in this case return true and log message
                                //https://github.com/cefsharp/CefSharp/pull/2446
                                if (promiseData == NULL)
                                {
                                    LOG(WARNING) << "BindObjectAsyncHandler::Execute promiseData returned NULL";

                                    return true;
                                }

                                //return the promose
                                retval = promiseData->GetValue("p");

                                //References to the promise resolve and reject methods
                                auto resolve = promiseData->GetValue("res");
                                auto reject = promiseData->GetValue("rej");

                                auto callback = gcnew JavascriptAsyncMethodCallback(context, resolve, reject);

                                auto request = CefProcessMessage::Create(kJavascriptRootObjectRequest);
                                auto argList = request->GetArgumentList();

                                //Obtain a callbackId then send off the Request for objects
                                auto callbackId = _callbackRegistry->SaveMethodCallback(callback);

                                SetInt64(argList, 0, callbackId);
                                argList->SetList(1, params);

                                frame->SendProcessMessage(CefProcessId::PID_BROWSER, request);
                            }
                        }
                        else
                        {
                            //Objects already bound or ignore cache
                            CefRefPtr<CefV8Value> promiseResolve;
                            CefRefPtr<CefV8Exception> promiseException;

                            auto promiseResolveScript = CefString("Promise.resolve({Success:false, Count:0, Message:'Object(s) already bound'});");

                            if (context->Eval(promiseResolveScript, CefString(), 0, promiseResolve, promiseException))
                            {
                                retval = promiseResolve;

                                if (notifyIfAlreadyBound)
                                {
                                    NotifyObjectBound(frame, objectNamesWithBoundStatus);
                                }
                            }
                            else
                            {
                                exception = promiseException->GetMessage();
                            }
                        }
                    }
                    else
                    {
                        exception = "BindObjectAsyncHandler::Execute - Frame is invalid.";
                    }
                }
                finally
                {
                    context->Exit();
                }
            }
            else
            {
                exception = "BindObjectAsyncHandler::Execute - Unable to Get or Enter Context";
            }


            return true;
        }

    private:
        void NotifyObjectBound(const CefRefPtr<CefFrame> frame, List<Tuple<String^, bool, bool>^>^ objectNamesWithBoundStatus)
        {
            //Send message notifying Browser Process of which objects were bound
            //We do this after the objects have been created in the V8Context to gurantee
            //they are accessible.
            auto msg = CefProcessMessage::Create(kJavascriptObjectsBoundInJavascript);
            auto args = msg->GetArgumentList();

            auto boundObjects = CefListValue::Create();
            auto index = 0;

            for each(auto obj in objectNamesWithBoundStatus)
            {
                auto dict = CefDictionaryValue::Create();

                auto name = obj->Item1;
                auto alreadyBound = obj->Item2;
                auto isCached = obj->Item3;
                dict->SetString("Name", StringUtils::ToNative(name));
                dict->SetBool("IsCached", isCached);
                dict->SetBool("AlreadyBound", alreadyBound);

                boundObjects->SetDictionary(index++, dict);
            }

            args->SetList(0, boundObjects);

            frame->SendProcessMessage(CefProcessId::PID_BROWSER, msg);
        }

        bool GetV8BoolValue(const CefRefPtr<CefV8Value> val, const CefString key, const CefString camelCaseKey)
        {
            if (val->HasValue(key))
            {
                auto obj = val->GetValue(key);
                if (obj->IsBool())
                {
                    return obj->GetBoolValue();
                }
            }

            if (val->HasValue(camelCaseKey))
            {
                auto obj = val->GetValue(camelCaseKey);
                if (obj->IsBool())
                {
                    return obj->GetBoolValue();
                }
            }

            return false;
        }


        IMPLEMENT_REFCOUNTING(BindObjectAsyncHandler);
    };
}