/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "scene_init.h"
#include "scene_adapter/scene_adapter.h"

#include "3d_widget_adapter_log.h"

#include "scene_adapter/scene_adapter.h"

#include <dlfcn.h>
#include <memory>
#include <string_view>

#include "napi/native_api.h"
#include "napi/native_node_api.h"

#include <base/containers/array_view.h>

#include <core/intf_engine.h>
#include <core/ecs/intf_system_graph_loader.h>
#include <core/engine_info.h>
#include <core/implementation_uids.h>
#include <core/io/intf_file_manager.h>
#include <core/namespace.h>
#include <core/os/intf_platform.h>
#include <core/plugin/intf_plugin_register.h>
#include <core/property/intf_property_handle.h>
#include <3d/implementation_uids.h>
#include <3d/intf_graphics_context.h>

#include <meta/interface/intf_meta_object_lib.h>
#include <meta/interface/intf_task_queue_registry.h>
#include <meta/interface/intf_task_queue.h>
#include <meta/interface/intf_object.h>
#include <meta/interface/intf_object_registry.h>
#include <meta/interface/intf_task_queue.h>
#include <meta/base/shared_ptr.h>
#include <meta/base/interface_macros.h>
#include <meta/api/make_callback.h>
#include <meta/ext/object.h>

#include <scene_plugin/namespace.h>
#include <scene_plugin/interface/intf_scene.h>
#include <scene_plugin/interface/intf_ecs_scene.h>
#include <scene_plugin/interface/intf_mesh.h>
#include <scene_plugin/interface/intf_material.h>
#include <scene_plugin/api/scene_uid.h>

#include "napi_base_context.h"

#include <render/implementation_uids.h>
#include <render/gles/intf_device_gles.h>
#include <render/intf_renderer.h>
#include <render/intf_render_context.h>

#include "3d_widget_adapter_log.h"
#include "widget_trace.h"
#include "ohos/texture_layer.h"

CORE_BEGIN_NAMESPACE()
/** Get plugin register */
IPluginRegister &(*GetPluginRegister)() = nullptr;

/** Setup the plugin register */
void (*CreatePluginRegistry)(const struct PlatformCreateInfo &platformCreateInfo) = nullptr;

/** Get whether engine is build in debug mode */
bool (*IsDebugBuild)() = nullptr;

/** Get version */
BASE_NS::string_view (*GetVersion)() = nullptr;
CORE_END_NAMESPACE()

namespace OHOS::FUZZ {

// class SceneInit : public ISceneInit {
class SceneInit : public ISceneInit {
public:
    SceneInit();
    
    bool LoadPluginsAndInit() override;
    
    std::shared_ptr<Render3D::TextureLayer> CreateTextureLayer() override;

    void OnWindowChange(const Render3D::WindowChangeInfo &windowChangeInfo) override;

    void RenderFrame(bool needsSyncPaint = false) override;

    EngineInstance& GetEngineInstance() override;

    void Deinit() override;

    bool NeedsRepaint() override
    {
        return false;
    }

    static void ShutdownPluginRegistry();
    static void DeinitRenderThread();

    ~SceneInit();

private:
    static bool LoadEngineLib();
    bool LoadPlugins(const CORE_NS::PlatformCreateInfo &platformCreateInfo);
    bool InitEngine(CORE_NS::PlatformCreateInfo platformCreateInfo);
    void AttachSwapchain(META_NS::IObject::Ptr camera, RENDER_NS::RenderHandleReference swapchain);
    void RenderFunction();
    void CreateRenderFunction();
    std::shared_ptr<ISceneAdapter> scene_;
};

Render3D::HapInfo GetHapInfo()
{
    return {};
}

using IntfPtr = META_NS::SharedPtrIInterface;
using IntfWeakPtr = META_NS::WeakPtrIInterface;

static EngineInstance engineInstance_;
static std::mutex mute;
static Render3D::HapInfo hapInfo_;
META_NS::ITaskQueue::Ptr engineThread;
META_NS::ITaskQueue::Ptr ioThread;
META_NS::ITaskQueue::Ptr releaseThread;
META_NS::ITaskQueue::Token renderTask{};

EngineInstance& SceneInit::GetEngineInstance() {
    return engineInstance_;
}

void LockCompositor()
{
    mute.lock();
}

void UnlockCompositor()
{
    mute.unlock();
}

static constexpr BASE_NS::Uid ENGINE_THREAD{"2070e705-d061-40e4-bfb7-90fad2c280af"};
static constexpr BASE_NS::Uid APP_THREAD{"b2e8cef3-453a-4651-b564-5190f8b5190d"};
static constexpr BASE_NS::Uid IO_QUEUE{"be88e9a0-9cd8-45ab-be48-937953dc258f"};
static constexpr BASE_NS::Uid JS_RELEASE_THREAD{"3784fa96-b25b-4e9c-bbf1-e897d36f73af"};

template <typename T>
bool LoadFunc(T &fn, const char *fName, void *handle)
{
    fn = reinterpret_cast<T>(dlsym(handle, fName));
    if (fn == nullptr) {
        WIDGET_LOGE("%s open %s", __func__, dlerror());
        return false;
    }
    return true;
}

SceneInit::SceneInit()
{
    WIDGET_LOGD("scene adapter Impl create");
}

bool SceneInit::LoadEngineLib()
{
    if (engineInstance_.libHandle_ != nullptr) {
        WIDGET_LOGD("%s, already loaded", __func__);
        return true;
    }

#define TO_STRING(name) #name
#define LIB_NAME(name) TO_STRING(name)
    constexpr std::string_view lib{LIB_NAME(LIB_ENGINE_CORE) ".so"};
    engineInstance_.libHandle_ = dlopen(lib.data(), RTLD_LAZY);

    if (engineInstance_.libHandle_ == nullptr) {
        WIDGET_LOGE("%s, open lib fail %s", __func__, dlerror());
    }
#undef TO_STRING
#undef LIB_NAME

#define LOAD_FUNC(fn, name) LoadFunc<decltype(fn)>(fn, name, engineInstance_.libHandle_)
    if (!(LOAD_FUNC(CORE_NS::CreatePluginRegistry, "_ZN4Core20CreatePluginRegistryERKNS_18PlatformCreateInfoE") &&
            LOAD_FUNC(CORE_NS::GetPluginRegister, "_ZN4Core17GetPluginRegisterEv") &&
            LOAD_FUNC(CORE_NS::IsDebugBuild, "_ZN4Core12IsDebugBuildEv") &&
            LOAD_FUNC(CORE_NS::GetVersion, "_ZN4Core13GetVersionRevEv"))) {
        return false;
    }
#undef LOAD_FUNC

    return true;
}

bool SceneInit::LoadPlugins(const CORE_NS::PlatformCreateInfo &platformCreateInfo)
{
    if (engineInstance_.libsLoaded_) {
        return true;
    }
    if (!LoadEngineLib()) {
        return false;
    }
    engineInstance_.libsLoaded_ = true;
    WIDGET_LOGD("load engine success!");

    return true;
}

bool SceneInit::InitEngine(CORE_NS::PlatformCreateInfo platformCreateInfo)
{
#ifdef SCENE_META_FUZZ
    auto &tr = META_NS::GetTaskQueueRegistry();
    auto &obr = META_NS::GetObjectRegistry();

    engineThread = tr.GetTaskQueue(ENGINE_THREAD);
    if (!engineThread) {
        engineThread = obr.Create<META_NS::ITaskQueue>(META_NS::ClassId::ThreadedTaskQueue);
        tr.RegisterTaskQueue(engineThread, ENGINE_THREAD);
    }
    ioThread = tr.GetTaskQueue(IO_QUEUE);
    if (!ioThread) {
        ioThread = obr.Create<META_NS::ITaskQueue>(META_NS::ClassId::ThreadedTaskQueue);
        tr.RegisterTaskQueue(ioThread, IO_QUEUE);
    }
    releaseThread = tr.GetTaskQueue(JS_RELEASE_THREAD);
    if (!releaseThread) {
        auto &obr = META_NS::GetObjectRegistry();
        releaseThread = obr.Create<META_NS::ITaskQueue>(META_NS::ClassId::ThreadedTaskQueue);
        tr.RegisterTaskQueue(releaseThread, JS_RELEASE_THREAD);
    }

    auto engineInit = META_NS::MakeCallback<META_NS::ITaskQueueTask>([platformCreateInfo]() {
#endif
    // Initialize lumeengine/render etc
#ifdef SCENE_META_FUZZ
        const BASE_NS::Uid DefaultPluginList[] { SCENE_NS::UID_SCENE_PLUGIN };
#else
        const BASE_NS::Uid DefaultPluginList[] { RENDER_NS::UID_RENDER_PLUGIN, CORE3D_NS::UID_3D_PLUGIN };
#endif
        CORE_NS::CreatePluginRegistry(platformCreateInfo);
        if (!CORE_NS::GetPluginRegister().LoadPlugins(DefaultPluginList)) {
            WIDGET_LOGE("fail to load scene widget plugin");
            return false;
        }
        WIDGET_LOGI("load plugin success");
        CORE_NS::EngineCreateInfo engineCreateInfo{platformCreateInfo, {}, {}};
        if (auto factory = CORE_NS::GetInstance<CORE_NS::IEngineFactory>(CORE_NS::UID_ENGINE_FACTORY)) {
            engineInstance_.engine_.reset(factory->Create(engineCreateInfo).get());
        }

        if (!engineInstance_.engine_) {
            WIDGET_LOGE("get engine fail");
            return false;
        }
        engineInstance_.engine_->Init();

        engineInstance_.renderContext_.reset(
            CORE_NS::CreateInstance<RENDER_NS::IRenderContext>(*engineInstance_.engine_, RENDER_NS::UID_RENDER_CONTEXT)
                .get());
        if (!engineInstance_.renderContext_) {
            WIDGET_LOGE("get render context fail");
            return false;
        }

        RENDER_NS::RenderCreateInfo renderCreateInfo;
        RENDER_NS::BackendExtraGLES glExtra;
        Render::DeviceCreateInfo deviceCreateInfo;
        // this context needs to be "not busy" (not selected current in any thread) for creation to succeed.
        // vulkan currently has no bloom
        std::string backendProp =
            "gles";  // Render3D::RenderConfig::GetInstance().renderBackend_ == "force_vulkan" ? "vulkan" : "gles";
        if (backendProp == "vulkan") {
        } else {
            glExtra.depthBits = 24; // 24 :bits size
            glExtra.sharedContext = EGL_NO_CONTEXT;
            deviceCreateInfo.backendType = RENDER_NS::DeviceBackendType::OPENGLES;
            deviceCreateInfo.backendConfiguration = &glExtra;
            renderCreateInfo.applicationInfo = {};
            renderCreateInfo.deviceCreateInfo = deviceCreateInfo;
        }

        auto rrc = engineInstance_.renderContext_->Init(renderCreateInfo);
        if (rrc != RENDER_NS::RenderResultCode::RENDER_SUCCESS) {
            WIDGET_LOGE("Failed to create render context");
            return false;
        }

        engineInstance_.graphicsContext_.reset(CORE_NS::CreateInstance<CORE3D_NS::IGraphicsContext>(
            *engineInstance_.renderContext_->GetInterface<CORE_NS::IClassFactory>(), CORE3D_NS::UID_GRAPHICS_CONTEXT)
                .get());
        if (!engineInstance_.graphicsContext_) {
            WIDGET_LOGE("create 3D context fail");
            return false;
        }
        engineInstance_.graphicsContext_->Init();

        WIDGET_LOGD("regester shader path");
        static constexpr const RENDER_NS::IShaderManager::ShaderFilePathDesc desc{"shaders://"};
        engineInstance_.engine_->GetFileManager().RegisterPath("shaders", "OhosRawFile://shaders", false);
        engineInstance_.renderContext_->GetDevice().GetShaderManager().LoadShaderFiles(desc);

        engineInstance_.engine_->GetFileManager().RegisterPath("appshaders", "OhosRawFile://shaders", false);
        static constexpr const RENDER_NS::IShaderManager::ShaderFilePathDesc desc1{"appshaders://"};
        engineInstance_.renderContext_->GetDevice().GetShaderManager().LoadShaderFiles(desc1);

        WIDGET_LOGI("init engine success");

#ifdef SCENE_META_FUZZ
        auto &obr = META_NS::GetObjectRegistry();
        // scene/meta
        // Save the stuff to the default object context.
        auto engineThread = META_NS::GetTaskQueueRegistry().GetTaskQueue(ENGINE_THREAD);
        // // this is the javascript thread...
        auto appThread = engineThread;
        auto doc = interface_cast<META_NS::IMetadata>(obr.GetDefaultObjectContext());
        if (doc == nullptr) {
            WIDGET_LOGE("nullptr from interface_cast");
            return false;
        }

        auto flags = META_NS::ObjectFlagBits::INTERNAL | META_NS::ObjectFlagBits::NATIVE;

        doc->AddProperty(META_NS::ConstructProperty<IntfPtr>("RenderContext", nullptr, flags));
        doc->AddProperty(META_NS::ConstructProperty<IntfPtr>("EngineQueue", nullptr, flags));
        doc->AddProperty(META_NS::ConstructProperty<IntfPtr>("AppQueue", nullptr, flags));
        doc->AddProperty(META_NS::ConstructArrayProperty<IntfWeakPtr>("Scenes", {}, flags));

        doc->GetPropertyByName<META_NS::SharedPtrIInterface>("EngineQueue")->SetValue(engineThread);
        doc->GetPropertyByName<META_NS::SharedPtrIInterface>("AppQueue")->SetValue(appThread);
        doc->GetPropertyByName<META_NS::SharedPtrIInterface>("RenderContext")->SetValue(engineInstance_.renderContext_);

        return false;
    });

    engineThread->AddTask(engineInit);
#endif
    return true;
}

void SceneInit::Deinit()
{
    engineInstance_.graphicsContext_.reset();

    engineInstance_.renderContext_->GetRenderer().RenderFrame({});

    engineInstance_.renderContext_->GetDevice().WaitForIdle();

    engineInstance_.renderContext_.reset();

#if SCENE_META_FUZZ
    const BASE_NS::Uid DefaultPluginList[]{SCENE_NS::UID_SCENE_PLUGIN};
#else
    const BASE_NS::Uid DefaultPluginList[]{RENDER_NS::UID_RENDER_PLUGIN, CORE3D_NS::UID_3D_PLUGIN};
#endif
    CORE_NS::GetPluginRegister().UnloadPlugins(DefaultPluginList);
}

SceneInit::~SceneInit()
{
    Deinit();
}

void SceneInit::DeinitRenderThread()
{
#if SCENE_META_FUZZ
    if (renderTask) {
        engineThread->CancelTask(renderTask);
        renderTask = nullptr;
    }
    auto engine_deinit = META_NS::MakeCallback<META_NS::ITaskQueueWaitableTask>([]() {
        // destroy all swapchains
        auto &obr = META_NS::GetObjectRegistry();
        auto doc = interface_cast<META_NS::IMetadata>(obr.GetDefaultObjectContext());
        if (doc == nullptr) {
            WIDGET_LOGE("nullptr from interface_cast");
            return META_NS::IAny::Ptr{};
        }
        // this is somewhat uncool
        {
            auto p3 = doc->GetPropertyByName<IntfPtr>("RenderContext");
            doc->RemoveProperty(p3);
            auto p2 = doc->GetPropertyByName<IntfPtr>("AppQueue");
            doc->RemoveProperty(p2);
            auto p1 = doc->GetPropertyByName<IntfPtr>("EngineQueue");
            doc->RemoveProperty(p1);
        }

        doc->GetArrayPropertyByName<IntfWeakPtr>("Scenes")->Reset();

        return META_NS::IAny::Ptr{};
    });
    auto dummy = META_NS::MakeCallback<META_NS::ITaskQueueWaitableTask>([]() { return META_NS::IAny::Ptr{}; });
    auto &tr = META_NS::GetTaskQueueRegistry();
    if (releaseThread) {
        releaseThread->AddWaitableTask(dummy)->Wait();
        tr.UnregisterTaskQueue(JS_RELEASE_THREAD);
        releaseThread.reset();
    }

    if (ioThread) {
        ioThread->AddWaitableTask(dummy)->Wait();
        tr.UnregisterTaskQueue(IO_QUEUE);
        ioThread.reset();
    }

    if (engineThread) {
        engineThread->AddWaitableTask(engine_deinit)->Wait();

        tr.UnregisterTaskQueue(ENGINE_THREAD);
        engineThread.reset();
    }
#endif
    CORE_LOG_E("unload E");
#if SCENE_META_FUZZ
    const BASE_NS::Uid DefaultPluginList[]{SCENE_NS::UID_SCENE_PLUGIN};
#else
    const BASE_NS::Uid DefaultPluginList[]{RENDER_NS::UID_RENDER_PLUGIN, CORE3D_NS::UID_3D_PLUGIN};
#endif
    CORE_NS::GetPluginRegister().UnloadPlugins(DefaultPluginList);
    CORE_LOG_E("unload X");
    engineInstance_.renderContext_.reset();
    engineInstance_.engine_.reset();
}

std::shared_ptr<Render3D::TextureLayer> SceneInit::CreateTextureLayer()
{
    return {};
}

bool SceneInit::LoadPluginsAndInit()
{
    LockCompositor(); // an APP_FREEZE here, so add lock just in case, but suspect others' error
    WIDGET_LOGI("scene adapter loadPlugins");

    if (hapInfo_.hapPath_ == "") {
        hapInfo_ = GetHapInfo();
    }

#define TO_STRING(name) #name
#define PLATFORM_PATH_NAME(name) TO_STRING(name)
    CORE_NS::PlatformCreateInfo platformCreateInfo {
        PLATFORM_PATH_NAME(PLATFORM_CORE_ROOT_PATH),
        PLATFORM_PATH_NAME(PLATFORM_APP_ROOT_PATH),
        PLATFORM_PATH_NAME(PLATFORM_APP_PLUGIN_PATH),
        hapInfo_.hapPath_.c_str(),
        hapInfo_.bundleName_.c_str(),
        hapInfo_.moduleName_.c_str()
    };
#undef TO_STRING
#undef PLATFORM_PATH_NAME
    if (!LoadPlugins(platformCreateInfo)) {
        WIDGET_LOGE("LoadPlugins failed");
        UnlockCompositor();
        return false;
    }

    if (!InitEngine(platformCreateInfo)) {
        WIDGET_LOGE("InitEngine failed");
        UnlockCompositor();
        return false;
    }

    CreateRenderFunction();
    UnlockCompositor();
    return true;
}

void SceneInit::OnWindowChange(const Render3D::WindowChangeInfo &windowChangeInfo)
{}

void SceneInit::CreateRenderFunction()
{}

void SceneInit::ShutdownPluginRegistry()
{
    if (engineInstance_.libHandle_ == nullptr) {
        return ;
    }

    CORE_NS::GetPluginRegister = nullptr;
    CORE_NS::CreatePluginRegistry = nullptr;
    CORE_NS::IsDebugBuild = nullptr;
    CORE_NS::GetVersion = nullptr;
}

void SceneInit::RenderFunction()
{}

void SceneInit::RenderFrame(bool needsSyncPaint)
{}

std::shared_ptr<ISceneInit> CreateFuzzScene()
{
    return std::make_shared<SceneInit>();
}
} // namespace OHOS::FUZZ