import { assertEquals } from "@std/assert";
import { isAgentAwake, isAgentAsleep } from "./sleepWakeHelpers.ts";

// Normal Schedule Tests (wake=8, sleep=22)
// Agent should be awake from 8am to 10pm

Deno.test("Normal schedule - should be asleep before wake time (7am)", () => {
  assertEquals(isAgentAwake(7, 8, 22), false);
  assertEquals(isAgentAsleep(7, 8, 22), true);
});

Deno.test("Normal schedule - should be awake at wake time (8am)", () => {
  assertEquals(isAgentAwake(8, 8, 22), true);
  assertEquals(isAgentAsleep(8, 8, 22), false);
});

Deno.test("Normal schedule - should be awake during day (12pm)", () => {
  assertEquals(isAgentAwake(12, 8, 22), true);
  assertEquals(isAgentAsleep(12, 8, 22), false);
});

Deno.test("Normal schedule - should be awake before sleep time (9pm)", () => {
  assertEquals(isAgentAwake(21, 8, 22), true);
  assertEquals(isAgentAsleep(21, 8, 22), false);
});

Deno.test("Normal schedule - should be asleep at sleep time (10pm)", () => {
  assertEquals(isAgentAwake(22, 8, 22), false);
  assertEquals(isAgentAsleep(22, 8, 22), true);
});

Deno.test("Normal schedule - should be asleep late night (11pm)", () => {
  assertEquals(isAgentAwake(23, 8, 22), false);
  assertEquals(isAgentAsleep(23, 8, 22), true);
});

Deno.test("Normal schedule - should be asleep at midnight", () => {
  assertEquals(isAgentAwake(0, 8, 22), false);
  assertEquals(isAgentAsleep(0, 8, 22), true);
});

// Cross-Midnight Schedule Tests (wake=9, sleep=2)
// Agent should be awake from 9am to 2am (next day)

Deno.test("Cross-midnight schedule - should be awake at midnight", () => {
  assertEquals(isAgentAwake(0, 9, 2), true);
  assertEquals(isAgentAsleep(0, 9, 2), false);
});

Deno.test("Cross-midnight schedule - should be awake late night (1am)", () => {
  assertEquals(isAgentAwake(1, 9, 2), true);
  assertEquals(isAgentAsleep(1, 9, 2), false);
});

Deno.test("Cross-midnight schedule - should be asleep at sleep time (2am)", () => {
  assertEquals(isAgentAwake(2, 9, 2), false);
  assertEquals(isAgentAsleep(2, 9, 2), true);
});

Deno.test("Cross-midnight schedule - should be asleep early morning (3am)", () => {
  assertEquals(isAgentAwake(3, 9, 2), false);
  assertEquals(isAgentAsleep(3, 9, 2), true);
});

Deno.test("Cross-midnight schedule - should be asleep before wake (8am)", () => {
  assertEquals(isAgentAwake(8, 9, 2), false);
  assertEquals(isAgentAsleep(8, 9, 2), true);
});

Deno.test("Cross-midnight schedule - should be awake at wake time (9am)", () => {
  assertEquals(isAgentAwake(9, 9, 2), true);
  assertEquals(isAgentAsleep(9, 9, 2), false);
});

Deno.test("Cross-midnight schedule - should be awake during day (12pm)", () => {
  assertEquals(isAgentAwake(12, 9, 2), true);
  assertEquals(isAgentAsleep(12, 9, 2), false);
});

Deno.test("Cross-midnight schedule - should be awake late night (11pm)", () => {
  assertEquals(isAgentAwake(23, 9, 2), true);
  assertEquals(isAgentAsleep(23, 9, 2), false);
});

// Edge Case Tests

Deno.test("Edge case - equal wake/sleep times (midnight) should be asleep", () => {
  // When wake == sleep, the agent should be asleep at all hours
  assertEquals(isAgentAwake(0, 0, 0), false);
  assertEquals(isAgentAsleep(0, 0, 0), true);
  assertEquals(isAgentAwake(12, 0, 0), false);
  assertEquals(isAgentAsleep(12, 0, 0), true);
});

Deno.test("Edge case - nearly 24 hours awake (wake=1, sleep=0)", () => {
  // Asleep only from midnight to 1am
  assertEquals(isAgentAwake(0, 1, 0), false);
  assertEquals(isAgentAsleep(0, 1, 0), true);
  assertEquals(isAgentAwake(1, 1, 0), true);
  assertEquals(isAgentAsleep(1, 1, 0), false);
  assertEquals(isAgentAwake(23, 1, 0), true);
  assertEquals(isAgentAsleep(23, 1, 0), false);
});

Deno.test("Edge case - nearly 24 hours asleep (wake=0, sleep=23)", () => {
  // Awake only from midnight to 11pm
  assertEquals(isAgentAwake(0, 0, 23), true);
  assertEquals(isAgentAsleep(0, 0, 23), false);
  assertEquals(isAgentAwake(22, 0, 23), true);
  assertEquals(isAgentAsleep(22, 0, 23), false);
  assertEquals(isAgentAwake(23, 0, 23), false);
  assertEquals(isAgentAsleep(23, 0, 23), true);
});

Deno.test("Edge case - adjacent hours (wake=10, sleep=11)", () => {
  // Awake only from 10am to 11am
  assertEquals(isAgentAwake(9, 10, 11), false);
  assertEquals(isAgentAsleep(9, 10, 11), true);
  assertEquals(isAgentAwake(10, 10, 11), true);
  assertEquals(isAgentAsleep(10, 10, 11), false);
  assertEquals(isAgentAwake(11, 10, 11), false);
  assertEquals(isAgentAsleep(11, 10, 11), true);
  assertEquals(isAgentAwake(12, 10, 11), false);
  assertEquals(isAgentAsleep(12, 10, 11), true);
});

// Inverse Relationship Tests

Deno.test("Inverse relationship - awake and asleep are always opposite (normal schedule)", () => {
  const wakeTime = 8;
  const sleepTime = 22;

  // Test all 24 hours
  for (let hour = 0; hour < 24; hour++) {
    const awake = isAgentAwake(hour, wakeTime, sleepTime);
    const asleep = isAgentAsleep(hour, wakeTime, sleepTime);
    assertEquals(
      awake,
      !asleep,
      `Hour ${hour}: awake=${awake}, asleep=${asleep} should be opposite`,
    );
  }
});

Deno.test("Inverse relationship - awake and asleep are always opposite (cross-midnight)", () => {
  const wakeTime = 9;
  const sleepTime = 2;

  // Test all 24 hours
  for (let hour = 0; hour < 24; hour++) {
    const awake = isAgentAwake(hour, wakeTime, sleepTime);
    const asleep = isAgentAsleep(hour, wakeTime, sleepTime);
    assertEquals(
      awake,
      !asleep,
      `Hour ${hour}: awake=${awake}, asleep=${asleep} should be opposite`,
    );
  }
});

Deno.test("Inverse relationship - awake and asleep are always opposite (edge case)", () => {
  const wakeTime = 23;
  const sleepTime = 1;

  // Test all 24 hours
  for (let hour = 0; hour < 24; hour++) {
    const awake = isAgentAwake(hour, wakeTime, sleepTime);
    const asleep = isAgentAsleep(hour, wakeTime, sleepTime);
    assertEquals(
      awake,
      !asleep,
      `Hour ${hour}: awake=${awake}, asleep=${asleep} should be opposite`,
    );
  }
});