#include <gtest/gtest.h>

#include <XCEngine/Scripting/Mono/MonoScriptRuntime.h>

#include <algorithm>
#include <filesystem>
#include <memory>
#include <string>
#include <vector>

using namespace XCEngine::Scripting;

namespace {

MonoScriptRuntime::Settings CreateProjectMonoSettings() {
    MonoScriptRuntime::Settings settings;
    settings.assemblyDirectory = XCENGINE_TEST_PROJECT_MANAGED_OUTPUT_DIR;
    settings.corlibDirectory = XCENGINE_TEST_PROJECT_MANAGED_OUTPUT_DIR;
    settings.coreAssemblyPath = XCENGINE_TEST_PROJECT_SCRIPT_CORE_DLL;
    settings.appAssemblyPath = XCENGINE_TEST_PROJECT_GAME_SCRIPTS_DLL;
    return settings;
}

class ProjectScriptAssemblyTest : public ::testing::Test {
protected:
    void SetUp() override {
        ASSERT_TRUE(std::filesystem::exists(XCENGINE_TEST_PROJECT_SCRIPT_CORE_DLL));
        ASSERT_TRUE(std::filesystem::exists(XCENGINE_TEST_PROJECT_GAME_SCRIPTS_DLL));

        runtime = std::make_unique<MonoScriptRuntime>(CreateProjectMonoSettings());
        ASSERT_TRUE(runtime->Initialize()) << runtime->GetLastError();
    }

    std::unique_ptr<MonoScriptRuntime> runtime;
};

TEST_F(ProjectScriptAssemblyTest, InitializesFromProjectScriptAssemblyDirectory) {
    EXPECT_TRUE(runtime->IsInitialized());
    EXPECT_EQ(runtime->GetSettings().assemblyDirectory, std::filesystem::path(XCENGINE_TEST_PROJECT_MANAGED_OUTPUT_DIR));
    EXPECT_EQ(runtime->GetSettings().appAssemblyPath, std::filesystem::path(XCENGINE_TEST_PROJECT_GAME_SCRIPTS_DLL));
}

TEST_F(ProjectScriptAssemblyTest, DiscoversProjectAssetMonoBehaviourClassesAndFieldMetadata) {
    const std::vector<std::string> classNames = runtime->GetScriptClassNames("GameScripts");
    std::vector<ScriptClassDescriptor> classDescriptors;
    ASSERT_TRUE(runtime->TryGetAvailableScriptClasses(classDescriptors));

    EXPECT_TRUE(runtime->IsClassAvailable("GameScripts", "ProjectScripts", "ProjectScriptProbe"));
    EXPECT_NE(
        std::find(classNames.begin(), classNames.end(), "ProjectScripts.ProjectScriptProbe"),
        classNames.end());
    EXPECT_NE(
        std::find(
            classDescriptors.begin(),
            classDescriptors.end(),
            ScriptClassDescriptor{"GameScripts", "ProjectScripts", "ProjectScriptProbe"}),
        classDescriptors.end());

    std::vector<ScriptFieldMetadata> fields;
    ASSERT_TRUE(runtime->TryGetClassFieldMetadata("GameScripts", "ProjectScripts", "ProjectScriptProbe", fields));

    const std::vector<ScriptFieldMetadata> expectedFields = {
        {"EnabledOnBoot", ScriptFieldType::Bool},
        {"Label", ScriptFieldType::String},
        {"Speed", ScriptFieldType::Float},
    };

    EXPECT_EQ(fields, expectedFields);

    std::vector<ScriptFieldDefaultValue> defaultValues;
    ASSERT_TRUE(runtime->TryGetClassFieldDefaultValues("GameScripts", "ProjectScripts", "ProjectScriptProbe", defaultValues));
    ASSERT_EQ(defaultValues.size(), 3u);

    EXPECT_EQ(defaultValues[0].fieldName, "EnabledOnBoot");
    EXPECT_EQ(defaultValues[0].type, ScriptFieldType::Bool);
    EXPECT_EQ(std::get<bool>(defaultValues[0].value), true);

    EXPECT_EQ(defaultValues[1].fieldName, "Label");
    EXPECT_EQ(defaultValues[1].type, ScriptFieldType::String);
    EXPECT_EQ(std::get<std::string>(defaultValues[1].value), "ProjectScriptProbe");

    EXPECT_EQ(defaultValues[2].fieldName, "Speed");
    EXPECT_EQ(defaultValues[2].type, ScriptFieldType::Float);
    EXPECT_FLOAT_EQ(std::get<float>(defaultValues[2].value), 2.5f);
}

} // namespace