/**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

#include "dusktest.h"
#include "util/memory.h"
#include "time/time.h"
#include "scene/scene.h"
#include "entity/entitymanager.h"

static void countingUpdateCallback(
  const entityid_t entityId,
  const componentid_t componentId,
  void *user
) {
  uint32_t *counter = (uint32_t *)user;
  (*counter)++;
}

static void test_sceneCreateDestroy(void **state) {
  sceneInit();

  sceneid_t id = sceneCreate();
  assert_true(id != SCENE_ID_INVALID);
  assert_non_null(sceneGetEntities(id));

  sceneDestroy(id);
  assert_int_equal(sceneGetActive(), SCENE_ID_INVALID);

  sceneDispose();
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_sceneEntitiesAreIsolatedPerScene(void **state) {
  sceneInit();

  sceneid_t sceneA = sceneCreate();
  sceneid_t sceneB = sceneCreate();
  assert_true(sceneA != sceneB);

  entitymanager_t *entitiesA = sceneGetEntities(sceneA);
  entitymanager_t *entitiesB = sceneGetEntities(sceneB);
  assert_true(entitiesA != entitiesB);

  // Fill scene A completely; scene B must be entirely unaffected.
  for(entityid_t i = 0; i < ENTITY_COUNT_MAX; i++) {
    assert_true(entityManagerAdd(entitiesA) != ENTITY_ID_INVALID);
  }
  expect_assert_failure(entityManagerAdd(entitiesA));

  entityid_t entityB = entityManagerAdd(entitiesB);
  assert_true(entityB != ENTITY_ID_INVALID);

  sceneDispose();
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_sceneUpdateOnlyTicksActiveScene(void **state) {
  sceneInit();
  timeInit();
  TIME.dynamicUpdate = true;

  sceneid_t sceneA = sceneCreate();
  sceneid_t sceneB = sceneCreate();

  uint32_t counterA = 0;
  uint32_t counterB = 0;

  entitymanager_t *entitiesA = sceneGetEntities(sceneA);
  entityid_t entityA = entityManagerAdd(entitiesA);
  entityUpdateAdd(
    entitiesA, entityA, countingUpdateCallback, COMPONENT_ID_INVALID,
    &counterA
  );

  entitymanager_t *entitiesB = sceneGetEntities(sceneB);
  entityid_t entityB = entityManagerAdd(entitiesB);
  entityUpdateAdd(
    entitiesB, entityB, countingUpdateCallback, COMPONENT_ID_INVALID,
    &counterB
  );

  sceneSetActive(sceneA);
  sceneUpdate();

  assert_int_equal(counterA, 1);
  assert_int_equal(counterB, 0);

  sceneSetActive(sceneB);
  sceneUpdate();

  assert_int_equal(counterA, 1);
  assert_int_equal(counterB, 1);

  sceneDispose();
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_sceneDestroyClearsActive(void **state) {
  sceneInit();

  sceneid_t id = sceneCreate();
  sceneSetActive(id);
  assert_int_equal(sceneGetActive(), id);

  sceneDestroy(id);
  assert_int_equal(sceneGetActive(), SCENE_ID_INVALID);

  sceneDispose();
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

int main(int argc, char **argv) {
  const struct CMUnitTest tests[] = {
    cmocka_unit_test(test_sceneCreateDestroy),
    cmocka_unit_test(test_sceneEntitiesAreIsolatedPerScene),
    cmocka_unit_test(test_sceneUpdateOnlyTicksActiveScene),
    cmocka_unit_test(test_sceneDestroyClearsActive),
  };

  return cmocka_run_group_tests(tests, NULL, NULL);
}