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 { IShuttle, 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;

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

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

  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 stops = generateMockStops();
      const stop = stops[0];
      stop.systemId = mockSystem.id;

      const etas = generateMockEtas();
      await Promise.all(etas.map(async (eta) => {
        eta.stopId = stop.id;
        await repository.addOrUpdateEta(eta);
      }));
      const expectedEta = etas[0];

      await repository.addOrUpdateStop(stop);

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

      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 () => {

    });
  });
});