import { beforeEach, describe, expect, it } from "@jest/globals";
import { generateParkingStructures } from "../testHelpers/mockDataGenerators";
import { setupTestServerContext, setupTestServerHolder } from "../testHelpers/apolloTestServerHelpers";
import { InterchangeSystem } from "../../src/entities/InterchangeSystem";
import assert = require("node:assert");

describe("ParkingSystemResolver", () => {
  const holder = setupTestServerHolder();
  const context = setupTestServerContext();

  let mockSystem: InterchangeSystem;

  beforeEach(async () => {
    mockSystem = context.systems[0];
  });

  async function getResponseFromQueryNeedingSystemId(query: string) {
    return await holder.testServer.executeOperation({
      query,
      variables: {
        systemId: mockSystem.id,
      },
    }, {
      contextValue: context,
    });
  }

  describe("parkingStructures", () => {
    const query = `
    query GetParkingStructuresBySystem($systemId: ID!) {
      system(id: $systemId) {
        parkingSystem {
          parkingStructures {
            name
            id
            capacity
            spotsAvailable
            coordinates {
              latitude
              longitude
            }
            address
            updatedTime
          }
        }
      }
    }
    `

    it("gets parking structures associated with the system id", async () => {
      const expectedParkingStructures = generateParkingStructures();
      await Promise.all(expectedParkingStructures.map(async (structure) => {
        await context.systems[0].parkingRepository?.addOrUpdateParkingStructure(structure);
      }));

      const response = await getResponseFromQueryNeedingSystemId(query);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();

      const parkingStructures = (response.body.singleResult.data as any).system.parkingSystem.parkingStructures;
      const transformedParkingStructures = parkingStructures.map((structure: any) => {
        const newStructure = { ...structure, updatedTimeMs: structure.updatedTime };
        delete newStructure.updatedTime;
        return newStructure;
      });

      expect(transformedParkingStructures).toEqual(expectedParkingStructures);
    });

    it("returns a blank array if there are no parking structures", async () => {
      const response = await getResponseFromQueryNeedingSystemId(query);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();

      const parkingStructures = (response.body.singleResult.data as any).system.parkingSystem.parkingStructures;

      expect(parkingStructures).toHaveLength(0);
    });
  });


  describe("parkingStructure", () => {
    async function getResponseForParkingStructureQuery(parkingStructureId: string) {
      const query = `
      query GetParkingStructureBySystem($systemId: ID!, $parkingStructureId: ID!) {
        system(id: $systemId) {
          parkingSystem {
            parkingStructure(id: $parkingStructureId) {
              name
              id
              capacity
              spotsAvailable
              coordinates {
                latitude
                longitude
              }
              address
              updatedTime
            }
          }
        }
      }
      `;

      return await holder.testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          parkingStructureId,
        }
      }, {
        contextValue: context

      });
    }

    it("returns the correct parking structure given the id", async () => {
      const generatedParkingStructures = generateParkingStructures();
      await Promise.all(generatedParkingStructures.map(async (structure) => {
        await context.systems[0].parkingRepository?.addOrUpdateParkingStructure(structure);
      }));
      const expectedParkingStructure = generatedParkingStructures[1];

      const response = await getResponseForParkingStructureQuery(expectedParkingStructure.id);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();

      const parkingStructure = (response.body.singleResult.data as any).system.parkingSystem.parkingStructure;
      parkingStructure.updatedTimeMs = parkingStructure.updatedTime;
      delete parkingStructure.updatedTime;
      expect(parkingStructure).toEqual(expectedParkingStructure);
    });

    it("returns null if there is no matching parking structure", async () => {
      const generatedParkingStructures = generateParkingStructures();
      await Promise.all(generatedParkingStructures.map(async (structure) => {
        await context.systems[0].parkingRepository?.addOrUpdateParkingStructure(structure);
      }));

      const nonexistentId = generatedParkingStructures[0].id + "12345";

      const response = await getResponseForParkingStructureQuery(nonexistentId);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();

      const parkingStructure = (response.body.singleResult.data as any).system.parkingSystem.parkingStructure;
      expect(parkingStructure).toBeNull();
    });
  });
});