import { beforeEach, describe, expect, it } from "@jest/globals";
import { setupTestServerContext, setupTestServerHolder } from "../../../testHelpers/apolloTestServerHelpers";
import {
  addMockRouteToRepository,
  addMockStopToRepository
} from "../../../testHelpers/repositorySetupHelpers";
import { generateMockOrderedStops, generateMockShuttles } from "../../../testHelpers/mockDataGenerators";
import { IRoute, IStop } from "../../entities/ShuttleRepositoryEntities";
import assert = require("node:assert");
import { InterchangeSystem } from "../../entities/InterchangeSystem";

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

  let mockSystem: InterchangeSystem;
  let mockRoute: IRoute;
  let mockStop: IStop;

  beforeEach(async () => {
    mockSystem = context.systems[0];
    const systemId = mockSystem.id;

    mockRoute = await addMockRouteToRepository(context.systems[0].shuttleRepository, systemId);
    mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, systemId);
  });


  describe("shuttles", () => {
    async function getResponseForShuttlesQuery() {
      const query = `
      query GetRouteShuttles($systemId: ID!, $routeId: ID!) {
        system(id: $systemId) {
          route(id: $routeId) {
            shuttles {
              id
              name
            }
          }
        }
      }
      `;

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

      });
    }

    it("returns shuttle array if there are shuttles", async () => {
      const expectedShuttles = generateMockShuttles();
      const expectedShuttle = expectedShuttles[0];
      expectedShuttle.systemId = mockSystem.id;
      expectedShuttle.routeId = mockRoute.id;
      await context.systems[0].shuttleRepository.addOrUpdateShuttle(expectedShuttle);

      const response = await getResponseForShuttlesQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined()
      const shuttle = (response.body.singleResult.data as
        any).system.route.shuttles[0];
      expect(shuttle.id).toEqual(expectedShuttle.id);
      expect(shuttle.name).toEqual(expectedShuttle.name);
    });

    it("returns empty array if there are no shuttles", async () => {
      const response = await getResponseForShuttlesQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined()
      const shuttles = (response.body.singleResult.data as
        any).system.route.shuttles;
      expect(shuttles.length).toEqual(0);
    });

    it("returns shuttles sorted by name", async () => {
      const shuttles = generateMockShuttles();
      // use two shuttles for determinism
      const s1 = { ...shuttles[0], name: "Zed" };
      const s2 = { ...shuttles[1], name: "Alpha" };
      s1.systemId = mockSystem.id;
      s1.routeId = mockRoute.id;
      s2.systemId = mockSystem.id;
      s2.routeId = mockRoute.id;

      await context.systems[0].shuttleRepository.addOrUpdateShuttle(s1);
      await context.systems[0].shuttleRepository.addOrUpdateShuttle(s2);

      const response = await getResponseForShuttlesQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined()
      const names = (response.body.singleResult.data as any).system.route.shuttles.map((s: any) => s.name);
      expect(names).toEqual(["Alpha", "Zed"]);
    });
  });

  describe("orderedStop", () => {
    async function getResponseForOrderedStopQuery() {
      const query = `
      query GetRouteOrderedStop($systemId: ID!, $routeId: ID!, $stopId: ID!) {
        system(id: $systemId) {
          route(id: $routeId) {
            orderedStop(forStopId: $stopId) {
              stopId
            }
          }
        }
      }
      `;

      return await holder.testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          routeId: mockRoute.id,
          stopId: mockStop.id,
        }
      }, {
        contextValue: context

      });
    }

    it("returns ordered stop using provided data", async () => {
      const orderedStops = generateMockOrderedStops();
      const expectedOrderedStop = orderedStops[0];
      expectedOrderedStop.stopId = mockStop.id;
      expectedOrderedStop.routeId = mockRoute.id;
      await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(expectedOrderedStop);

      const response = await getResponseForOrderedStopQuery();

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

      const orderedStop = (response.body.singleResult.data as
        any).system.route.orderedStop;
      expect(orderedStop.stopId).toEqual(expectedOrderedStop.stopId);
    });

    it("returns null if the stop doesn't exist", async () => {
      const orderedStops = generateMockOrderedStops();
      const expectedOrderedStop = orderedStops[0];
      expectedOrderedStop.stopId = mockStop.id;
      expectedOrderedStop.routeId = mockRoute.id;
      await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(expectedOrderedStop);

      await context.systems[0].shuttleRepository.removeStopIfExists(mockStop.id);

      const response = await getResponseForOrderedStopQuery();

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

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

  describe("orderedStops", () => {
    async function getResponseForOrderedStopsQuery() {
      const query = `
      query GetRouteOrderedStop($systemId: ID!, $routeId: ID!) {
        system(id: $systemId) {
          route(id: $routeId) {
            orderedStops {
              stopId
            }
          }
        }
      }
      `;

      return await holder.testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          routeId: mockRoute.id,
        },
      }, {
        contextValue: context,
      });
    }

    it("returns ordered stops using provided data", async () => {
      let orderedStops = generateMockOrderedStops();
      orderedStops = orderedStops.filter((stop) => stop.routeId === orderedStops[0].routeId);

      await Promise.all(orderedStops.map(async (stop) => {
        await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(stop);
      }))

      const response = await getResponseForOrderedStopsQuery();

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

      const retrievedOrderedStops = (response.body.singleResult.data as any).system.route.orderedStops;
      expect(retrievedOrderedStops).toHaveLength(orderedStops.length);
      retrievedOrderedStops.map((retrievedStop: any) => {
        expect(orderedStops.find((originalStop) => originalStop.stopId === retrievedStop.stopId)).not.toBeUndefined();
      });
    });

    it("returns empty array if there are no ordered stops", async () => {
      const response = await getResponseForOrderedStopsQuery();

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

      const retrievedOrderedStops = (response.body.singleResult.data as any).system.route.orderedStops;
      expect(retrievedOrderedStops).toHaveLength(0);
    });

    it("returns ordered stops sorted by position", async () => {
      const stops = generateMockOrderedStops().slice(0, 3).map((s) => ({ ...s }));
      // Force same routeId and distinct positions out of order
      stops[0].routeId = mockRoute.id; stops[0].position = 3; stops[0].stopId = "stA";
      stops[1].routeId = mockRoute.id; stops[1].position = 1; stops[1].stopId = "stB";
      stops[2].routeId = mockRoute.id; stops[2].position = 2; stops[2].stopId = "stC";
      await Promise.all(stops.map(s => context.systems[0].shuttleRepository.addOrUpdateOrderedStop(s)));

      const response = await getResponseForOrderedStopsQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      const stopIds = (response.body.singleResult.data as any).system.route.orderedStops.map((s: any) => s.stopId);
      const expectedOrder = [...stops].sort((a, b) => a.position - b.position).map(s => s.stopId);
      expect(stopIds).toEqual(expectedOrder);
    });
  });
});