// Copyright © 2013 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 "Stdafx.h"

#include "include\cef_app.h"
#include "include\cef_scheme.h"

#include "CefSettingsBase.h"
#include "CefSchemeHandlerFactoryAdapter.h"
#include "Internals\CefSchemeRegistrarWrapper.h"

using namespace CefSharp::Core;

namespace CefSharp
{
    namespace Internals
    {
        private class CefSharpApp : public CefApp,
            public CefBrowserProcessHandler
        {
            gcroot<IEnumerable<CefCustomScheme^>^> _customSchemes;
            gcroot<CommandLineArgDictionary^> _commandLineArgs;
            gcroot<IApp^> _app;
            bool _commandLineDisabled;
            bool _hasCustomScheme;
            gcroot<String^> _customSchemeArg;

        public:
            CefSharpApp(bool externalMessagePump, bool commandLineDisabled, CommandLineArgDictionary^ commandLineArgs, IEnumerable<CefCustomScheme^>^ customSchemes, IApp^ app) :
                _commandLineDisabled(commandLineDisabled),
                _commandLineArgs(commandLineArgs),
                _customSchemes(customSchemes),
                _app(app),
                _hasCustomScheme(false)
            {
                auto isMissingHandler = Object::ReferenceEquals(app, nullptr) || Object::ReferenceEquals(app->BrowserProcessHandler, nullptr);
                if (externalMessagePump && isMissingHandler)
                {
                    throw gcnew Exception("browserProcessHandler cannot be null when using cefSettings.ExternalMessagePump");
                }

                if (System::Linq::Enumerable::Count(customSchemes) > 0)
                {
                    String^ argument = "=";
                    auto registeredSchemes = gcnew List<String^>();

                    for each (CefCustomScheme ^ scheme in customSchemes)
                    {
                        //We don't need to register http or https in the render process
                        if (scheme->SchemeName == "http" ||
                            scheme->SchemeName == "https")
                        {
                            continue;
                        }

                        //We've already registered this scheme name
                        if (registeredSchemes->Contains(scheme->SchemeName))
                        {
                            continue;
                        }

                        _hasCustomScheme = true;

                        registeredSchemes->Add(scheme->SchemeName);

                        argument += scheme->SchemeName + "|";
                        argument += ((int)scheme->Options).ToString() + ";";
                    }

                    if (_hasCustomScheme)
                    {
                        _customSchemeArg = argument->TrimEnd(';');
                    }
                }
            }

            ~CefSharpApp()
            {
                _customSchemes = nullptr;
                _commandLineArgs = nullptr;
                delete _app;
                _app = nullptr;
            }

            virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() override
            {
                return this;
            }

            virtual void OnContextInitialized() override
            {
                auto customSchemes = (IEnumerable<CefCustomScheme^>^)_customSchemes;

                //CefRegisterSchemeHandlerFactory requires access to the Global CefRequestContext
                for each (CefCustomScheme^ cefCustomScheme in customSchemes)
                {
                    if (!Object::ReferenceEquals(cefCustomScheme->SchemeHandlerFactory, nullptr))
                    {
                        auto domainName = cefCustomScheme->DomainName ? cefCustomScheme->DomainName : String::Empty;

                        CefRefPtr<CefSchemeHandlerFactory> wrapper = new CefSchemeHandlerFactoryAdapter(cefCustomScheme->SchemeHandlerFactory);
                        CefRegisterSchemeHandlerFactory(StringUtils::ToNative(cefCustomScheme->SchemeName), StringUtils::ToNative(domainName), wrapper);
                    }
                }

                CefSharp::Internals::GlobalContextInitialized::SetResult(true);

                if (!Object::ReferenceEquals(_app, nullptr) && !Object::ReferenceEquals(_app->BrowserProcessHandler, nullptr))
                {
                    _app->BrowserProcessHandler->OnContextInitialized();
                }
            }

            virtual void OnScheduleMessagePumpWork(int64_t delay_ms)  override
            {
                //We rely on previous checks to make sure _app and _app->BrowserProcessHandler aren't null
                _app->BrowserProcessHandler->OnScheduleMessagePumpWork(delay_ms);
            }

            virtual bool OnAlreadyRunningAppRelaunch(CefRefPtr<CefCommandLine> commandLine, const CefString& currentDirectory) override
            {
                if (Object::ReferenceEquals(_app, nullptr) || Object::ReferenceEquals(_app->BrowserProcessHandler, nullptr))
                {
                    return false;
                }

                auto managedArgs = gcnew Dictionary<String^, String^>();

                CefCommandLine::ArgumentList args;
                commandLine->GetArguments(args);

                for (auto arg : args)
                {
                    managedArgs->Add(StringUtils::ToClr(arg), String::Empty);
                }

                CefCommandLine::SwitchMap switches;
                commandLine->GetSwitches(switches);

                for (auto s : switches)
                {
                    managedArgs->Add(StringUtils::ToClr(s.first), StringUtils::ToClr(s.second));
                }

                auto readOnlyArgs = gcnew System::Collections::ObjectModel::ReadOnlyDictionary<String^, String^>(managedArgs);

                return _app->BrowserProcessHandler->OnAlreadyRunningAppRelaunch(readOnlyArgs, StringUtils::ToClr(currentDirectory));
            }

            virtual void OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> commandLine) override
            {
#ifndef NETCOREAPP
                if (CefSharpSettings::WcfEnabled)
                {
                    commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::WcfEnabledArgument));
                }
#endif

                if (CefSharpSettings::SubprocessExitIfParentProcessClosed)
                {
                    commandLine->AppendSwitch(StringUtils::ToNative(CefSharpArguments::ExitIfParentProcessClosed));
                }

                //ChannelId was removed in https://github.com/chromiumembedded/cef/issues/1912
                //We need to know the process Id to establish WCF communication and for monitoring of parent process exit
                commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::HostProcessIdArgument + "=" + Process::GetCurrentProcess()->Id));

                if (_hasCustomScheme)
                {
                    commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::CustomSchemeArgument + _customSchemeArg));
                }

                if (CefSharpSettings::FocusedNodeChangedEnabled)
                {
                    commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::FocusedNodeChangedEnabledArgument));
                }
            }

            virtual void OnBeforeCommandLineProcessing(const CefString& process_type, CefRefPtr<CefCommandLine> command_line) override
            {
                if (CefSharpSettings::Proxy != nullptr && !_commandLineDisabled)
                {
                    command_line->AppendSwitchWithValue("proxy-server", StringUtils::ToNative(CefSharpSettings::Proxy->IP + ":" + CefSharpSettings::Proxy->Port));

                    if (!String::IsNullOrEmpty(CefSharpSettings::Proxy->BypassList))
                    {
                        command_line->AppendSwitchWithValue("proxy-bypass-list", StringUtils::ToNative(CefSharpSettings::Proxy->BypassList));
                    }
                }

                if (_commandLineArgs->Count > 0)
                {
                    auto commandLine = command_line.get();

                    // Not clear what should happen if we 
                    // * already have some command line flags given (is this possible? Perhaps from globalCommandLine)
                    // * have no flags given (-> call SetProgramm() with first argument?)

                    auto args = (CommandLineArgDictionary^)_commandLineArgs;

                    for each(KeyValuePair<String^, String^>^ kvp in args)
                    {
                        CefString name = StringUtils::ToNative(kvp->Key);
                        CefString value = StringUtils::ToNative(kvp->Value);

                        if (kvp->Key == "disable-features" || kvp->Key == "enable-features")
                        {
                            //Temp workaround so we can set the disable-features/enable-features command line argument
                            // See https://github.com/cefsharp/CefSharp/issues/2408
                            commandLine->AppendSwitchWithValue(name, value);
                        }
                        // Right now the command line args handed to the application (global command line) have higher
                        // precedence than command line args provided by the app
                        else if (!commandLine->HasSwitch(name))
                        {
                            if (String::IsNullOrEmpty(kvp->Value))
                            {
                                commandLine->AppendSwitch(name);
                            }
                            else
                            {
                                commandLine->AppendSwitchWithValue(name, value);
                            }
                        }
                    }
                }
            }

            virtual void OnRegisterCustomSchemes(CefRawPtr<CefSchemeRegistrar> registrar) override
            {
                if (!Object::ReferenceEquals(_app, nullptr))
                {
                    CefSchemeRegistrarWrapper wrapper(registrar);

                    _app->OnRegisterCustomSchemes(%wrapper);
                }
            };

            IMPLEMENT_REFCOUNTINGM(CefSharpApp);
        };
    }
}