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("1", new UnoptimizedInMemoryShuttleRepository());

    spies = {
      fetchAndUpdateRouteDataForSystem: jest.spyOn(loader, 'fetchAndUpdateRouteDataForSystem'),
      fetchAndUpdateStopAndPolylineDataForRoutesInSystem: jest.spyOn(loader, 'fetchAndUpdateStopAndPolylineDataForRoutesInSystem'),
      fetchAndUpdateShuttleDataForSystem: jest.spyOn(loader, 'fetchAndUpdateShuttleDataForSystem'),
      fetchAndUpdateEtaDataForExistingStopsForSystem: jest.spyOn(loader, 'fetchAndUpdateEtaDataForExistingStopsForSystem')
    };

    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);
    });
  });
});