#include <Data/World.h>

#include <Core/Common/CoreUtils.h>
#include <Core/Common/serialization.h>
#include <Core/HAL/Filesystem/Filesystem.h>
#include <Core/HAL/IO/IOStream.h>
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
#include <Core/Thread/ThreadContext.h>
#include <Entity/EntityManager.h>
#include <Graphics/MeshRenderer.h>

#ifdef JULIET_ENABLE_IMGUI
#include <dcimgui.h>
#endif

void InitWorld(World* world, Arena* arena)
{
    Assert(world != NULL);
    Assert(arena != NULL);
    world->WorldArena = arena;
}

void ShutdownWorld(World* world)
{
    Assert(world != NULL);
    world->WorldArena = NULL;
}

void AddToWorld(World* world, Entity* entity)
{
    (void)world;
    (void)entity;
}

void RemoveWorldEntity(World* world, size_t index)
{
    (void)world;
    (void)index;
}

void SerializeWorld(Archive* ar, World* world, String filename)
{
    (void)world;
    Assert(ar != NULL);
    Assert(IsValidString(filename));

    EntityManager* entityManager = GetEntityManager();

    if (ar->loading)
    {
        // Load
        ByteBuffer fileBuffer = LoadFile(ar->arena, filename);

        // TEST SERIALIZATION
        ParsedArchive archive = tokenize_archive(ar->arena, fileBuffer);
#if JULIET_DEBUG
        audit_unconsumed_properties(&archive, ConstString("World"));
#else
        (void)archive;
#endif
    }
    else
    {
        // Save
        IOStream* stream = IOFromFile(ar->arena, filename, WrapString("wb"));

        index_t beginPos = ArenaPos(ar->arena);

        // Headers
        WorldFileHeader* header = ArenaPushStruct(ar->arena, WorldFileHeader);
        header->Magic           = kWorldMagic;

        // TODO : Move to a one file per entity model
        for (uint8 i = 0; i < ENTITY(Count); ++i)
        {
            typed_entity_array* type = &entityManager->by_type[i];
            serialize_elem(ar, type->count);
            if (type->count > 0 && type->array != NULL)
            {
                EntityTemplate* element    = type->array;
                uint8*          rawElement = (uint8*)element;
                size_t          stride     = element->base->derived_kind->size_of;
                for (index_t idx = 0; idx < type->count; ++idx)
                {
                    Entity* entity = ((EntityTemplate*)(rawElement + (idx * stride)))->base;
                    serialize_entity(ar, entity);
                }
            }
        }

        // Write
        index_t    endPos      = ArenaPos(ar->arena);
        ByteBuffer writeBuffer = { .Data = (Byte*)header, .Size = endPos - beginPos };

        size_t written = IOWrite(stream, writeBuffer);

        Assert(writeBuffer.Size == written);

        IOClose(stream);
    }
}

bool8 LoadWorld(World* world, String filename)
{
    (void)world;
    Assert(IsValidString(filename));
    return true;
}

#ifdef JULIET_EDITOR
void RenderWorldEditorUI(World* world)
{
    Assert(world != NULL);

    if (ImGui_Begin("World Editor", NULL, ImGuiWindowFlags_None))
    {
        TempArena   temp               = scratch_begin(NULL, 0);
        static char worldFilePath[256] = "/world.bin";
        ImGui_InputText("World File", worldFilePath, sizeof(worldFilePath));

        Path path = GetAssetPath(temp.Arena, AssetType_JAsset, WrapString(worldFilePath));

        if (ImGui_Button("Save World"))
        {
            Archive data = { .arena = temp.Arena, .loading = false };
            SerializeWorld(&data, world, path.FullPath);
        }
        ImGui_SameLine(0.0f, -1.0f);
        if (ImGui_Button("Load World"))
        {
            Archive data = { .arena = temp.Arena, .loading = true };
            SerializeWorld(&data, world, path.FullPath);
        }

        scratch_end(temp);
    }
    ImGui_End();
}
#endif