#include "Debug/Debug.hpp"
using namespace Debug;

namespace Debug_Tests {
    class DebuggingTest {
    public:
        void runAllTests() {
            _w();
            _w(_testBasicLogging());
            _w(_testMessageCustomization());
            _w(_testAssertAndThrow());
            _w(_testCallStackTracing());
            _w(_testCombinedFormatting());
            std::cout << "All tests completed successfully." << std::endl;
        }
    private:
        void _testBasicLogging() {
            _w();
            DEBUG::Log("This is a standard log message.") << "qwe";
            DEBUG::Warning("This is a warning message.") << "";
            DEBUG::Error("This is an error message.");
        }
        void _testMessageCustomization() {
            _w();
            DEBUG::Message(
                LogStream::Message("Custom message with sub title and other color.")
                    .SetTitle("[SUB_TITLE]")
                    .SetColor(Colors::TEXT_COLOR_CYAN_SOFT)
                    .ToString()
            );
            DEBUG::Message(
                LogStream::Message("Message without a title.")
                    .NoTitle()
                    .ToString()
            ).NoTitle();
        }
        void _testAssertAndThrow() {
            _w();
            DEBUG::Assert(true, "This assert should pass.");
        }
        void _testCallStackTracing() { _w(); _innerFunction(); }
        void _innerFunction() {
            _w();
            DEBUG::Log("Call stack tracing test: inside inner function.");
        }
        void _testCombinedFormatting() {
            _w();
            int p_score = 100; std::string p_player = "Player_One"; float p_speed = 15.5f;
            DEBUG::Log("Player: ", p_player, ", Score: ", p_score, ", Speed: ", p_speed);
            DEBUG::Log("Game_State: ") << "Running" << ", Level: " << 5 << ", Time: " << 120.5f;
            DEBUG::Log("Combined Log. Level: ", 5) << " and " << "Score: " << 200;
        }
    };
}

Library(ECS default
        SOURCES src/**/*.cpp
        PUBLIC_DIRS ./include
        PUBLIC_LIBS tp::entt
        DI:SHARED Debug:SHARED Utils:SHARED)

Library(ECS Godot
        SOURCES src/**/*.cpp
        PUBLIC_DIRS ./include
        PUBLIC_LIBS tp::entt
        DI:STATIC Debug:STATIC Utils:STATIC)

Executable(ECS_Tests default
        SOURCES tests/Tests.cpp
        PUBLIC_DIRS
        PRIVATE_LIBS ECS:SHARED)

#include "Jobs/JobSystem.hpp"
#include "Jobs/JobHandle.hpp"

class MyJob : public Jobs::iJob {
public:
    void Execute() override {}
    std::vector<Jobs::JobHandle> GetDependencies() override { return {}; }
};

void runMassiveJobSchedulingExample() {
    auto& jobSystem = Jobs::JobSystem::GetInstance();
    std::vector<Jobs::JobHandle> handles; handles.reserve(100000);
    for (int i = 0; i < 100000; ++i) {
        auto job = std::make_unique<MyJob>();
        handles.push_back(jobSystem.Schedule(std::move(job)));
    }
    for (const auto& h : handles) { h.Complete(); }
}

void testDeepDependencyChain(int depth) {
    Jobs::JobHandle lastHandle;
    for (int i = 0; i < depth; ++i) {
        auto job = std::make_unique<MyJob>();
        lastHandle = Jobs::JobSystem::GetInstance().Schedule(std::move(job), lastHandle);
    }
    lastHandle.Complete();
}

class MyParallelForJob : public Jobs::iJobParallelFor {
public:
    std::vector<int> data; MyParallelForJob(size_t size) : data(size) {}
    void Execute(int p_index) override { data[p_index] = p_index * 2; }
};

void runParallelForExample() {
    auto job = std::make_unique<MyParallelForJob>(100000);
    auto& js = Jobs::JobSystem::GetInstance();
    Jobs::JobHandle h = js.Schedule(std::move(job));
    h.Complete();
}

class SpinSystem : public iSystem<
            Sorting<UpdateInGroup<DrawRenderSystemGroup>, UpdateAfter<RenderSystem>>,
            Filter<With<AngularVelocity, Rotation>>,
            Fps<30>> {
public:
    void Update(double dt, const SystemState& s, Entity e,
                const AngularVelocity& av, Rotation& r) {
        Math::quat dq = Math::quat(av.value * static_cast<float>(dt));
        r.value = glm::normalize(r.value * dq);
    }
};

class SpinSystem extends iSystem(
    Sorting(UpdateInGroup(DrawRenderSystemGroup), UpdateAfter(RenderSystem)),
    Filter(With(AngularVelocity, Rotation)),
    Fps(30)
) {
  override Update(dt: number, s: SystemState, e: Entity,
                  av: AngularVelocity, r: Rotation): void {
    const delta = glm.quat.create();
    const axis = glm.vec3.create();
    glm.vec3.normalize(axis, av.value);
    const angle = glm.vec3.length(av.value) * dt;
    glm.quat.setAxisAngle(delta, axis, angle);
    glm.quat.multiply(r.value, r.value, delta);
    glm.quat.normalize(r.value, r.value);
  }
}

const BAR_CONTAINER_ID = 'unit-bar-container';
export class UnitBarsSystem extends iSystem(
  Sorting(UpdateInGroup(UISystemGroup)),
  Filter(With()),
  Frequency(30)
) {
  private m_barsMap = new Map<Entity, HTMLElement>();
  private m_container: HTMLElement | null = null;
  private m_entityBarsQueryFilter: EntityQueryFilter | null = null;
  override OnCreate(systemState: SystemState): void {
    this.m_container = document.getElementById(BAR_CONTAINER_ID);
    this.m_entityBarsQueryFilter = new EntityQuery().With(ScreenPosition).Build();
  }
  override Update(deltaTime: number, systemState: SystemState): void {
    const view = new EntityView(systemState.entityManager, this.m_entityBarsQueryFilter!);
    const it: EntityIterator = view.getIterator();
    const active = new Set<Entity>();
    while (it.next()) {
      const id = it.entity; active.add(id);
      if (!this.m_barsMap.has(id)) {
        const bar = document.createElement('div');
        bar.className = 'unit-bar';
        this.m_container?.appendChild(bar);
        this.m_barsMap.set(id, bar);
      }
      const bar = this.m_barsMap.get(id)!;
      const screenPos = it.components[0];
      bar.style.transform = `translate(${screenPos.x}px, ${screenPos.y}px)`;
    }
    for (const [id, bar] of this.m_barsMap.entries()) {
      if (!active.has(id)) { bar.remove(); this.m_barsMap.delete(id); }
    }
  }
  override OnDestroy(): void {
    if (this.m_container) this.m_container.innerHTML = '';
    this.m_barsMap.clear();
  }
}