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

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

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

  let mockSystem: ISystem;
  let mockShuttle: IShuttle;
  let mockStop: IStop;
  let expectedEta: IEta;

  beforeEach(async () => {
    mockSystem = await addMockSystemToRepository(repository);

    const mockShuttles = generateMockShuttles();
    mockShuttle = mockShuttles[0];
    mockShuttle.systemId = mockSystem.id;
    await repository.addOrUpdateShuttle(mockShuttle);

    const mockStops = generateMockStops();
    mockStop = mockStops[0];
    mockStop.systemId = mockSystem.id;
    await repository.addOrUpdateStop(mockStop);

    const etas = generateMockEtas();
    expectedEta = etas[0];
    expectedEta.stopId = mockStop.id;
    expectedEta.shuttleId = mockShuttle.id;
    await repository.addOrUpdateEta(expectedEta);
  });

  async function getResponseForEtaQuery(query: string) {
    const response = await testServer.executeOperation({
      query,
      variables: {
        systemId: mockSystem.id,
        shuttleId: mockShuttle.id,
      },
    }, {
      contextValue: {
        repository,
      }
    });
    return response;
  }

  describe("stop", () => {
    const query = `
    query GetETAStop($systemId: ID!, $shuttleId: ID!) {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          etas {
            stop {
              id
            }
          }
        }
      }
    }
    `;

    it("returns the associated stop if it exists", async () => {
      const response = await getResponseForEtaQuery(query);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      const eta = (response.body.singleResult.data?.system as any).shuttle.etas[0];
      expect(eta.stop.id).toEqual(expectedEta.stopId);
    });
  });

  describe("shuttle", () => {
    const query = `
    query GetETAShuttle($systemId: ID!, $shuttleId: ID!) {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          etas {
            shuttle {
              id
            }
          }
        }
      }
    }
    `;

    it("returns the associated shuttle if it exists", async () => {
      const response = await getResponseForEtaQuery(query);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      const eta = (response.body.singleResult.data?.system as any).shuttle.etas[0];
      expect(eta.shuttle.id).toEqual(expectedEta.shuttleId);
    });
  });
});