import { beforeEach, describe, expect, it } from "@jest/globals";
import { ApolloServer } from "@apollo/server";
import { ServerContext } from "../../src/ServerContext";
import { readFileSync } from "fs";
import { MergedResolvers } from "../../src/MergedResolvers";
import { UnoptimizedInMemoryRepository } from "../../src/repositories/UnoptimizedInMemoryRepository";
import { generateMockSystems } from "../generators";
import assert = require("node:assert");

// See Apollo documentation for integration test guide
// https://www.apollographql.com/docs/apollo-server/testing/testing

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

  beforeEach(async () => {
    const typeDefs = readFileSync("./schema.graphqls", "utf8");
    testServer = new ApolloServer<ServerContext>({
      typeDefs,
      resolvers: MergedResolvers,
    });

    repository = new UnoptimizedInMemoryRepository();
  });

  describe("systems", () => {
    it("returns systems from the repository", async () => {
      const systems = generateMockSystems();
      await Promise.all(systems.map(async (system) => {
        await repository.addOrUpdateSystem(system);
      }));

      const query = `
      query GetSystems
      {
        systems {
          name
        }
      }
      `

      const response = await testServer.executeOperation({
        query,
      }, {
        contextValue: {
          repository,
        },
      });

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect(response.body.singleResult.data?.systems).toHaveLength(systems.length);
    });
  });

  describe("system", () => {
    it("returns a system for an ID from the repository", async () => {

    });

    it("returns null if no id provided", async () => {

    });

    it("returns null if there is no system", async () => {

    });
  });
});