import { beforeEach, describe, expect, it } from "@jest/globals";
import { generateMockEtas, generateMockRoutes } from "../testHelpers/mockDataGenerators";
import { IShuttle, ISystem } from "../../src/entities/entities";
import { setupTestServerContext } from "../testHelpers/apolloTestServerHelpers";
import { addMockShuttleToRepository, addMockSystemToRepository } from "../testHelpers/repositorySetupHelpers";
import assert = require("node:assert");


describe("ShuttleResolvers", () => {
  const context = setupTestServerContext();

  let mockSystem: ISystem;
  let mockShuttle: IShuttle;

  beforeEach(async () => {
    mockSystem = await addMockSystemToRepository(context.repository);
    mockShuttle = await addMockShuttleToRepository(context.repository,
      mockSystem.id);
  });


  async function addMockEtas(shuttleId: string) {
    const etas = generateMockEtas();
    await Promise.all(etas.map(async (eta) => {
      eta.shuttleId = shuttleId;
      await context.repository.addOrUpdateEta(eta);
    }));
    return etas;
  }

  describe("eta", () => {
    const query = `
    query GetShuttleETAs($systemId: ID!, $shuttleId: ID!, $stopId: ID!)
    {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          eta(forStopId: $stopId) {
            secondsRemaining
          }
        }
      }
    }
    `
    it("returns ETA data for stop ID if exists", async () => {
      const etas = await addMockEtas(mockShuttle.id);

      const mockEta = etas[1];

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

      // Assert
      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as
        any).system.shuttle.eta.secondsRemaining).toEqual(mockEta.secondsRemaining);
    });

    it("returns null if it doesn't exist", async () => {
      const response = await context.testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
          stopId: "nonexistent-stop",
        }
      }, {
        contextValue: {
          repository: context.repository,
        }
      });

      // Assert
      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as
        any).system.shuttle.eta).toBeNull();
    });
  });

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

    it("returns associated ETAs if they exist for the shuttle", async () => {
      const etas = await addMockEtas(mockShuttle.id);

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

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

    it("returns empty array if no ETAs exist", async () => {
      const response = await context.testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
        },
      }, {
        contextValue: {
          repository: context.repository,
        }
      });

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

    });
  });
  describe("route", () => {
    const query = `
    query GetShuttleRoute($systemId: ID!, $shuttleId: ID!) {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          route {
             color
             id
             name
             polylineCoordinates {
               latitude
               longitude
             }
          }
        }
      }
    }
    `

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

    it("returns the route if it exists", async () => {
      const mockRoute = generateMockRoutes()[0];
      await context.repository.addOrUpdateRoute(mockRoute);

      const response = await getResponseForQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.route.id).toEqual(mockRoute.id);
    });

    it("returns null if there is no route", async () => {
      const response = await getResponseForQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.route).toBeNull();
    });

  });
});