import { assert } from "chai";
import { describe, it, beforeEach, afterEach } from "node:test";
import * as m from "../index";
import * as config from "./config";
import mockModule from "./mock";

describe("StatusBeacon", function() {
  let models: m.BackendModels, mongoose: m.MongooseModule;
  let testItem: Partial<m.StatusBeacon>;
  beforeEach(async function() {
    const c = await m.connect(config.url);
    models = c.models;
    mongoose = c.mongoose;

    const mock = mockModule({ mongoose });
    testItem = mock.statusBeacon;
    await mock.beforeEach();
  });
  afterEach(async function() {
    await mongoose.disconnect();
  });

  it("is saved", async function() {
    const item = new models.StatusBeacon(testItem);
    const sut = await item.save();

    assert.isNotNull(sut._id);
    assert.equal(testItem.departmentId, sut.departmentId);
    assert.equal(testItem.integration, sut.integration);
    assert.equal(testItem.healthState, sut.healthState);
    assert.equal(testItem.triggerReason, sut.triggerReason);
    assert.equal(testItem.consecutiveFailures, sut.consecutiveFailures);
    assert.equal(testItem.consecutiveSuccesses, sut.consecutiveSuccesses);
    assert.equal(testItem.totalFailuresSinceLastHealthy, sut.totalFailuresSinceLastHealthy);
    assert.equal(testItem.pollCycle, sut.pollCycle);
    assert.equal(testItem.lastPollMs, sut.lastPollMs);
    assert.equal(testItem.activeIncidents, sut.activeIncidents);
    assert.equal(testItem.activeUnits, sut.activeUnits);
    assert.equal(testItem.incidentsDelta, sut.incidentsDelta);
    assert.equal(testItem.unitStatusDelta, sut.unitStatusDelta);
    assert.equal(testItem.tokenAgeSecs, sut.tokenAgeSecs);
    assert.equal(testItem.debugPushActive, sut.debugPushActive);
    assert.equal(testItem.lastConfigSaveFile, sut.lastConfigSaveFile);
    assert.equal(testItem.lastError, sut.lastError);
    assert.equal(testItem.interfaceVersion, sut.interfaceVersion);
    assert.equal(testItem.cadVersion, sut.cadVersion);
    assert.equal(testItem.unifiedVersion, sut.unifiedVersion);
    assert.isNotNull(sut.createdAt);
    assert.isNotNull(sut.updatedAt);
  });

  it("saves nested queueDepths", async function() {
    const item = new models.StatusBeacon(testItem);
    const sut = await item.save();

    assert.equal(testItem.queueDepths?.incident, sut.queueDepths.incident);
    assert.equal(testItem.queueDepths?.status, sut.queueDepths.status);
    assert.equal(testItem.queueDepths?.vehicle, sut.queueDepths.vehicle);
    assert.equal(testItem.queueDepths?.total, sut.queueDepths.total);
  });

  it("saves nested tCSend health", async function() {
    const item = new models.StatusBeacon(testItem);
    const sut = await item.save();

    assert.equal(testItem.tCSend?.sendFailuresDelta, sut.tCSend.sendFailuresDelta);
    assert.equal(testItem.tCSend?.lastSendError, sut.tCSend.lastSendError);
  });

  it("saves nested writeBack health", async function() {
    const item = new models.StatusBeacon(testItem);
    const sut = await item.save();

    assert.equal(testItem.writeBack?.attemptsDelta, sut.writeBack.attemptsDelta);
    assert.equal(testItem.writeBack?.failuresDelta, sut.writeBack.failuresDelta);
    assert.equal(testItem.writeBack?.lastError, sut.writeBack.lastError);
  });

  it("saves nested sync health", async function() {
    const item = new models.StatusBeacon(testItem);
    const sut = await item.save();

    assert.equal(testItem.sync?.cacheAgeSeconds, sut.sync.cacheAgeSeconds);
    assert.equal(testItem.sync?.consecutiveEmptyPolls, sut.sync.consecutiveEmptyPolls);
    assert.equal(testItem.sync?.lastPollChanges, sut.sync.lastPollChanges);
    assert.equal(testItem.sync?.incidentCacheGrowthDelta, sut.sync.incidentCacheGrowthDelta);
  });

  it("saves beacon 1.2 fields", async function() {
    const item = new models.StatusBeacon(testItem);
    const sut = await item.save();

    assert.equal(testItem.beaconVersion, sut.beaconVersion);
    assert.equal(testItem.keepAliveIntervalSecs, sut.keepAliveIntervalSecs);
    assert.equal(testItem.queueDroppedDelta, sut.queueDroppedDelta);
    assert.deepEqual(testItem.queueAges, sut.queueAges);
    assert.deepEqual(testItem.channels, sut.channels);
    assert.deepEqual(testItem.pollers, sut.pollers);
    assert.deepEqual(testItem.auth, sut.auth);
    assert.deepEqual(testItem.restartPoll, sut.restartPoll);
    assert.deepEqual(testItem.clockSync, sut.clockSync);
  });

  it("defaults beacon 1.2 fields when absent", async function() {
    const item = new models.StatusBeacon({ departmentId: testItem.departmentId, integration: "defaults-integration" });
    const sut = await item.save();

    assert.equal(sut.beaconVersion, "");
    assert.equal(sut.keepAliveIntervalSecs, 60);
    assert.equal(sut.queueDroppedDelta, 0);
    assert.deepEqual(sut.channels, {});
    assert.deepEqual(sut.pollers, {});
  });
});

describe("StatusBeaconTransition", function() {
  let models: m.BackendModels, mongoose: m.MongooseModule;
  let testItem: Partial<m.StatusBeaconTransition>;
  beforeEach(async function() {
    const c = await m.connect(config.url);
    models = c.models;
    mongoose = c.mongoose;

    const mock = mockModule({ mongoose });
    testItem = mock.statusBeaconTransition;
    await mock.beforeEach();
  });
  afterEach(async function() {
    await mongoose.disconnect();
  });

  it("is saved", async function() {
    const item = new models.StatusBeaconTransition(testItem);
    const sut = await item.save();

    assert.isNotNull(sut._id);
    assert.equal(testItem.departmentId, sut.departmentId);
    assert.equal(testItem.integration, sut.integration);
    assert.equal(testItem.triggerReason, sut.triggerReason);
    assert.equal(testItem.healthState, sut.healthState);
    assert.equal(testItem.consecutiveFailures, sut.consecutiveFailures);
    assert.equal(testItem.totalFailuresSinceLastHealthy, sut.totalFailuresSinceLastHealthy);
    assert.equal(testItem.lastError, sut.lastError);
    assert.isNotNull(sut.createdAt);
    assert.isNotNull(sut.updatedAt);
  });
});