import { afterEach, beforeAll, beforeEach, describe, expect, it, jest } from "@jest/globals";
import { TimedApiBasedShuttleRepositoryLoader } from "../../src/loaders/TimedApiBasedShuttleRepositoryLoader";
import { resetGlobalFetchMockJson } from "../testHelpers/fetchMockHelpers";
import { UnoptimizedInMemoryShuttleRepository } from "../../src/repositories/UnoptimizedInMemoryShuttleRepository";

describe("TimedApiBasedRepositoryLoader", () => {
  let loader: TimedApiBasedShuttleRepositoryLoader;
  let spies: any;

  beforeAll(() => {
    jest.useFakeTimers();
    jest.spyOn(global, "setTimeout");
  });

  beforeEach(() => {
    resetGlobalFetchMockJson();

    loader = new TimedApiBasedShuttleRepositoryLoader(new UnoptimizedInMemoryShuttleRepository());

    spies = {
      fetchAndUpdateSystemData: jest.spyOn(loader, 'fetchAndUpdateSystemData'),
      fetchAndUpdateRouteDataForExistingSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateRouteDataForExistingSystemsInRepository'),
      fetchAndUpdateStopAndPolylineDataForRoutesInExistingSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateStopAndPolylineDataForRoutesInExistingSystemsInRepository'),
      fetchAndUpdateShuttleDataForExistingSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateShuttleDataForExistingSystemsInRepository'),
      fetchAndUpdateEtaDataForExistingStopsForSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateEtaDataForExistingStopsForSystemsInRepository')
    };

    Object.values(spies).forEach((spy: any) => {
      spy.mockResolvedValue(undefined);
    });
  });

  afterEach(() => {
    jest.clearAllMocks();
    jest.clearAllTimers();
  })

  describe("start", () => {
    it("should update internal state, call data fetching methods, and start a timer", async () => {
      await loader.start();
      expect(loader["shouldBeRunning"]).toBe(true);

      Object.values(spies).forEach((spy: any) => {
        expect(spy).toHaveBeenCalled();
      });

      expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), loader.timeout);
      expect(loader.timeout).not.toBeUndefined();
    });

    it("does nothing if timer is already running", async () => {
      await loader.start();
      await loader.start();

      Object.values(spies).forEach((spy: any) => {
        expect(spy).toHaveBeenCalledTimes(1);
      });
    });
  });

  describe("stop", () => {
    it("should update internal state", async () => {
      loader.stop();
      expect(loader['shouldBeRunning']).toBe(false);
    });
  });
});