#pragma once

#include "Components.hpp"
#include "Entity.hpp"
#include "GameContext.hpp"

#include <algorithm>
#include <memory>
#include <vector>

void UpdateAllSystems(std::vector<std::shared_ptr<Entity>> &entities, GameContext &context,
                      float deltaTime) {
    context.entities = &entities;
    context.worldEntity = (entities.size() > 0 && entities[0]) ? entities[0].get() : nullptr;
    context.wellEntity = (entities.size() > 1 && entities[1]) ? entities[1].get() : nullptr;
    context.probeEntity = (entities.size() > 2 && entities[2]) ? entities[2].get() : nullptr;
    context.hudEntity = (!entities.empty() && entities.back()) ? entities.back().get() : nullptr;

    for (auto &entity : entities) {
        if (!entity) {
            continue;
        }

        if (entity->context != &context) {
            entity->SetContext(&context);
        }

        entity->Update(deltaTime);
    }

    for (size_t i = 0; i < entities.size(); ++i) {
        auto &a = entities[i];
        if (!a) {
            continue;
        }

        auto aTransform = a->GetComponent<TransformComponent>();
        auto aCollider = a->GetComponent<ColliderComponent>();
        if (!aTransform || !aCollider) {
            continue;
        }

        for (size_t j = i + 1; j < entities.size(); ++j) {
            auto &b = entities[j];
            if (!b) {
                continue;
            }

            auto bTransform = b->GetComponent<TransformComponent>();
            auto bCollider = b->GetComponent<ColliderComponent>();
            if (!bTransform || !bCollider) {
                continue;
            }

            const float dx = aTransform->get().x - bTransform->get().x;
            const float dy = aTransform->get().y - bTransform->get().y;
            const float r = aCollider->get().radius + bCollider->get().radius;
            if ((dx * dx + dy * dy) <= (r * r)) {
                aCollider->get().EmitCollision(*b);
                bCollider->get().EmitCollision(*a);
            }
        }
    }

    auto remover = [](const std::shared_ptr<Entity> &entity) {
        if (!entity) {
            return true;
        }

        if (entity->queuedForFree) {
            entity->Cleanup();
            return true;
        }

        return false;
    };

    entities.erase(std::remove_if(entities.begin(), entities.end(), remover), entities.end());
}