import { beforeEach, describe, expect, it } from "@jest/globals";
import {
  setupTestServerContext,
  setupTestServerHolder
} from "../../../testHelpers/apolloTestServerHelpers";
import { generateMockEtas, generateMockOrderedStops } from "../../../testHelpers/mockDataGenerators";
import { IStop } from "../../entities/ShuttleRepositoryEntities";
import { addMockStopToRepository } from "../../../testHelpers/repositorySetupHelpers";
import { ExternalSourceETARepository } from "../../repositories/shuttle/eta/ExternalSourceETARepository";
import assert from "node:assert";

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

  let mockStop: IStop;

  beforeEach(async () => {
    mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, context.systems[0].id);
  })

  async function getResponseForQuery(query: string) {
    return await holder.testServer.executeOperation({
      query,
      variables: {
        systemId: context.systems[0].id,
        stopId: mockStop.id,
      },
    }, {
      contextValue: context,
    });
  }

  describe("orderedStops", () => {
    const query = `
    query GetOrderedStops($systemId: ID!, $stopId: ID!) {
      system(id: $systemId) {
        stop(id: $stopId) {
          orderedStops {
            routeId
            stopId
          }
        }
      }
    }
    `


    it("returns ordered stops if they exist for the stop ID", async () => {
      let mockOrderedStops = generateMockOrderedStops();
      mockOrderedStops = mockOrderedStops.filter((orderedStop) => orderedStop.stopId === mockOrderedStops[0].stopId);
      await Promise.all(mockOrderedStops.map(async orderedStop => {
        orderedStop.stopId = mockStop.id;
        await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStop);
      }));

      const response = await getResponseForQuery(query);

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

    it("returns empty array if no ordered stops exist", async () => {
      const response = await getResponseForQuery(query);

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

    it("returns ordered stops sorted by position", async () => {
      // Create three ordered stops with out-of-order positions and distinct routeIds
      const base = generateMockOrderedStops()[0];
      const o1 = { ...base, stopId: mockStop.id, routeId: "rA", position: 3 };
      const o2 = { ...base, stopId: mockStop.id, routeId: "rB", position: 1 };
      const o3 = { ...base, stopId: mockStop.id, routeId: "rC", position: 2 };
      await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(o1);
      await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(o2);
      await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(o3);

      const response = await getResponseForQuery(query);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      const routeIds = (response.body.singleResult.data as any).system.stop.orderedStops.map((s: any) => s.routeId);
      const expectedOrder = [o2, o3, o1].map(s => s.routeId);
      expect(routeIds).toEqual(expectedOrder);
    });
  });

  describe("etas", () => {
    const query = `
    query GetEtas($systemId: ID!, $stopId: ID!) {
      system(id: $systemId) {
        stop(id: $stopId) {
          etas {
            secondsRemaining
          }
        }
      }
    }
    `

    it("returns ETAs if they exist for the stop ID", async () => {
      let mockEtas = generateMockEtas();
      mockEtas = mockEtas.filter((eta) => eta.stopId === mockEtas[0].stopId);
      await Promise.all(mockEtas.map(async eta => {
        eta.stopId = mockStop.id;
        await (context.systems[0].etaRepository as ExternalSourceETARepository).addOrUpdateEtaFromExternalSource(eta);
      }));

      const response = await getResponseForQuery(query);

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

    it("returns empty array if no ETAs exist", async () => {
      const response = await getResponseForQuery(query);

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

    it("returns ETAs sorted by secondsRemaining", async () => {
      const e1 = { ...generateMockEtas()[0], stopId: mockStop.id, shuttleId: "shA", secondsRemaining: 240 };
      const e2 = { ...generateMockEtas()[0], stopId: mockStop.id, shuttleId: "shB", secondsRemaining: 60 };
      const e3 = { ...generateMockEtas()[0], stopId: mockStop.id, shuttleId: "shC", secondsRemaining: 120 };
      await (context.systems[0].etaRepository as ExternalSourceETARepository).addOrUpdateEtaFromExternalSource(e1);
      await (context.systems[0].etaRepository as ExternalSourceETARepository).addOrUpdateEtaFromExternalSource(e2);
      await (context.systems[0].etaRepository as ExternalSourceETARepository).addOrUpdateEtaFromExternalSource(e3);

      const response = await getResponseForQuery(query);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      const seconds = (response.body.singleResult.data as any).system.stop.etas.map((e: any) => e.secondsRemaining);
      expect(seconds).toEqual([60, 120, 240]);
    });
  });
});