import { beforeEach, describe, expect, it } from "@jest/globals";
import { ApolloServer } from "@apollo/server";
import { ServerContext } from "../../src/ServerContext";
import { UnoptimizedInMemoryRepository } from "../../src/repositories/UnoptimizedInMemoryRepository";
import { setUpTestServer } from "../testHelpers/apolloSetupHelpers";
import { generateMockOrderedStops, generateMockStops, generateMockSystems } from "../generators";
import { IStop, ISystem } from "../../src/entities/entities";
import assert = require("node:assert");

describe("StopResolvers", () => {
  let testServer: ApolloServer<ServerContext>;
  let repository: UnoptimizedInMemoryRepository;

  beforeEach(() => {
    testServer = setUpTestServer();
    repository = new UnoptimizedInMemoryRepository();
  });

  let mockStop: IStop;
  let mockSystem: ISystem;

  beforeEach(async () => {
    const mockSystems = generateMockSystems();
    mockSystem = mockSystems[0];
    mockSystem.id = "1";
    await repository.addOrUpdateSystem(mockSystem);

    const mockStops = generateMockStops();
    mockStop = mockStops[0];
    mockStop.id = "1";
    await repository.addOrUpdateStop(mockStop);
  })

  describe("orderedStops", () => {
    const query = `
    query GetOrderedStops($systemId: ID!, $stopId: ID!) {
      system(id: $systemId) {
        stop(id: $stopId) {
          orderedStops {
            routeId
            stopId
          }
        }
      }
    }
    `

    async function getResponseForQuery() {
      return await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          stopId: mockStop.id,
        },
      }, {
        contextValue: {
          repository,
        }
      });
    }

    it("returns ordered stops if they exist for the stop ID", async () => {
      let mockOrderedStops = generateMockOrderedStops();
      mockOrderedStops = mockOrderedStops.filter((orderedStop) => orderedStop.stopId === mockOrderedStops[0].stopId);
      await Promise.all(mockOrderedStops.map(async orderedStop => {
        orderedStop.stopId = mockStop.id;
        await repository.addOrUpdateOrderedStop(orderedStop);
      }));

      const response = await getResponseForQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.stop.orderedStops).toHaveLength(mockOrderedStops.length);
    });

    it("returns empty array if no ordered stops exist", async () => {
      const response = await getResponseForQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.stop.orderedStops).toHaveLength(0);
    });
  });

  describe("etas", () => {
    it("returns ETAs if they exist for the stop ID", async () => {

    });

    it("returns empty array if no ETAs exist", async () => {

    });
  });
});