import { describe, test, expect, beforeAll } from "bun:test";
import { waitForService, baseUrl, doorName, buzzerNumber, key, buzzerUrl } from "./testCommon";
import { DoorStatus } from "../src/types/DoorStatus";
import { StatusResponse } from "../src/functions/api/door/status";
import { sleep } from "bun";

// these tests should only run locally
if (process.env.STAGE === 'staging') {
  process.exit(0);
}

beforeAll(async () => {
  await waitForService(baseUrl);
});

describe("info path works", () => {
  test("info works from UI", async () => {
    const resp = await fetch(baseUrl + `/api/door/info?door=${doorName}`).then(res => res.json()) as any;

    expect(resp.id as string).toBe(doorName);
    expect(resp.buzzer).toBe(buzzerNumber);
  });

  test("info works from client", async () => {
    const resp = await fetch(baseUrl + `/api/door/info?buzzer=${buzzerNumber}`).then(res => res.json()) as any;

    // TODO: why is this different?
    expect(resp.door as string).toBe(doorName);
    expect(resp.buzzer).toBe(buzzerNumber);
  });
});

describe("unlock path works", () => {
  test("auth updates info and status relocks auth", async () => {
    // run status first, to make sure we are closed    
    const statusReset = await fetch(baseUrl + `/api/door/status?door=${doorName}`).then(res => res.json()) as StatusResponse;

    const resp = await fetch(baseUrl + `/api/door/info?door=${doorName}`).then(res => res.json()) as any;

    expect(resp.id).toBe(doorName);
    expect(resp.status).toBe(DoorStatus.CLOSED);

    // unlock door with wrong code should be 401
    const badAuthResp = await fetch(baseUrl + `/api/door/auth?door=${doorName}&key=thisisthewrongkey`);
    expect(badAuthResp.status).toBe(401);
    
    // unlock door with correct code should be 200
    const authResp = await fetch(baseUrl + `/api/door/auth?door=${doorName}&key=${key}`);
    expect(authResp.status).toBe(200);

    // door should be unlocked on info route
    const infoOpen = await fetch(baseUrl + `/api/door/info?door=${doorName}`).then(res => res.json()) as any;
    expect(infoOpen.status).toBe(DoorStatus.OPEN);

    // calling status should unlock and close the door
    const statusOpen = await fetch(baseUrl + `/api/door/status?door=${doorName}`).then(res => res.json()) as StatusResponse;
    expect(statusOpen.status).toBe(DoorStatus.OPEN);

    const infoClosed = await fetch(baseUrl + `/api/door/info?door=${doorName}`).then(res => res.json()) as any;
    expect(infoClosed.status).toBe(DoorStatus.CLOSED);
  });

  test("auth works for timeout", async () => {
    // run status first, to make sure we are closed
    const statusReset = await fetch(baseUrl + `/api/door/status?door=${doorName}`).then(res => res.json()) as StatusResponse;
    
    // run auth with timeout specified
    const authResp = await fetch(baseUrl + `/api/door/auth?door=${doorName}&key=${key}&timeout=1`);
    
    // sleep 1s
    await sleep(1_000);
    
    // we should be closed, because we passed the timeout
    const infoClosed = await fetch(baseUrl + `/api/door/info?door=${doorName}`).then(res => res.json()) as any;
    expect(infoClosed.status).toBe(DoorStatus.CLOSED);        
  });
});