/**
 * @jest-environment jsdom
 */
import { timer, of } from "rxjs";
import { map, delayWhen } from "rxjs/operators";
import { renderHook, act } from "@testing-library/react";
import { DeviceModelId } from "@ledgerhq/devices";
import { DisconnectedDevice, LockedDeviceError, UnexpectedBootloader } from "@ledgerhq/errors";
import { useOnboardingStatePolling } from "./useOnboardingStatePolling";
import { OnboardingStep } from "../../hw/extractOnboardingState";
import { SeedPhraseType } from "@ledgerhq/types-live";
import { getOnboardingStatePolling } from "../../hw/getOnboardingStatePolling";
jest.mock("../../hw/getOnboardingStatePolling");
jest.useFakeTimers();
const aDevice = {
    deviceId: "DEVICE_ID_A",
    deviceName: "DEVICE_NAME_A",
    modelId: DeviceModelId.stax,
    wired: false,
};
const pollingPeriodMs = 1000;
const mockedGetOnboardingStatePolling = jest.mocked(getOnboardingStatePolling);
describe("useOnboardingStatePolling", () => {
    let anOnboardingState;
    let aSecondOnboardingState;
    beforeEach(() => {
        anOnboardingState = {
            isOnboarded: false,
            isInRecoveryMode: false,
            seedPhraseType: SeedPhraseType.TwentyFour,
            currentSeedWordIndex: 0,
            currentOnboardingStep: OnboardingStep.NewDevice,
            charonSupported: false,
            charonStatus: null,
        };
        aSecondOnboardingState = {
            ...anOnboardingState,
            currentOnboardingStep: OnboardingStep.NewDeviceConfirming,
        };
    });
    afterEach(() => {
        mockedGetOnboardingStatePolling.mockClear();
    });
    describe("When polling returns a correct device state", () => {
        beforeEach(() => {
            mockedGetOnboardingStatePolling.mockReturnValue(of({
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                onboardingState: { ...aSecondOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                // During the third polling, it gets the same onboarding state
                onboardingState: { ...aSecondOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }).pipe(delayWhen((_, index) => {
                // "delay" or "delayWhen" piped to a streaming source, for ex the "of" operator, will not block the next
                // Observable to be streamed. They return an Observable that delays the emission of the source Observable,
                // but do not create a delay in-between each emission. That's why the delay is increased by multiplying by "index".
                // "concatMap" could have been used to wait for the previous Observable to complete, but
                // the "index" arg given to "delayWhen" would always be 0
                return timer(index * pollingPeriodMs);
            })));
        });
        it("should update the onboarding state returned to the consumer", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(1);
            });
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
        });
        it("should fetch again the state at a defined frequency and only update the onboarding state returned to the consumer if it different than the previous one", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(1);
            });
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            // Next polling
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(aSecondOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            // To compare with the result of the third polling
            const prevOnboardingState = result.current.onboardingState;
            // Third polling
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            // It should not have been updated
            // toBe matcher checks referential identity of object instances
            expect(result.current.onboardingState).toBe(prevOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
        });
        describe("and when the hook consumer stops the polling", () => {
            it("should stop the polling and stop fetching the device onboarding state", async () => {
                const device = aDevice;
                let stopPolling = false;
                const { result, rerender } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs, stopPolling }));
                await act(async () => {
                    jest.advanceTimersByTime(1);
                });
                // Everything is normal on the first run
                expect(mockedGetOnboardingStatePolling).toHaveBeenCalledTimes(1);
                expect(result.current.fatalError).toBeNull();
                expect(result.current.allowedError).toBeNull();
                expect(result.current.onboardingState).toEqual(anOnboardingState);
                expect(result.current.lockedDevice).toBe(false);
                // The consumer stops the polling
                stopPolling = true;
                rerender({ device, pollingPeriodMs, stopPolling });
                await act(async () => {
                    // Waits as long as we want
                    jest.advanceTimersByTime(10 * pollingPeriodMs);
                });
                // While the hook was rerendered, it did not call a new time getOnboardingStatePolling
                expect(mockedGetOnboardingStatePolling).toHaveBeenCalledTimes(1);
                // And the state should stay the same (and not be aSecondOnboardingState)
                expect(result.current.fatalError).toBeNull();
                expect(result.current.allowedError).toBeNull();
                expect(result.current.onboardingState).toEqual(anOnboardingState);
                expect(result.current.lockedDevice).toBe(false);
            });
        });
    });
    describe("When an allowed error occurs while polling the device state", () => {
        beforeEach(() => {
            mockedGetOnboardingStatePolling.mockReturnValue(of({
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                onboardingState: null,
                allowedError: new DisconnectedDevice("An allowed error"),
                lockedDevice: false,
            }, {
                onboardingState: null,
                // During the third polling, it gets the same allowed error
                allowedError: new DisconnectedDevice("An allowed error"),
                lockedDevice: false,
            }, {
                onboardingState: { ...aSecondOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }).pipe(delayWhen((_, index) => {
                return timer(index * pollingPeriodMs);
            })));
        });
        it("should update the allowed error returned to the consumer if different than the previous one, update the fatal error to null and keep the previous onboarding state", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(1);
            });
            // Everything is ok on the first run
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            expect(result.current.allowedError).toBeInstanceOf(DisconnectedDevice);
            expect(result.current.fatalError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            // To compare with the result of the third polling
            const prevAllowedError = result.current.allowedError;
            // Third polling
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            expect(result.current.fatalError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            // It should not have been updated
            // toBe matcher checks referential identity of object instances
            expect(result.current.allowedError).toBe(prevAllowedError);
            expect(result.current.lockedDevice).toBe(false);
        });
        it("should be able to recover once the allowed error is fixed and the onboarding state is updated", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs + 1);
            });
            // Allowed error occured
            expect(result.current.allowedError).toBeInstanceOf(DisconnectedDevice);
            expect(result.current.fatalError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(2 * pollingPeriodMs);
            });
            // Everything is ok on the next run
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(aSecondOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
        });
    });
    describe("When a locked device error occurs while polling the device state", () => {
        beforeEach(() => {
            mockedGetOnboardingStatePolling.mockReturnValue(of({
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                onboardingState: null,
                allowedError: new LockedDeviceError("An allowed error"),
                lockedDevice: true,
            }, {
                onboardingState: null,
                // During the third polling, it gets the same allowed error
                allowedError: new LockedDeviceError("An allowed error"),
                lockedDevice: true,
            }, {
                onboardingState: { ...aSecondOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }).pipe(delayWhen((_, index) => {
                return timer(index * pollingPeriodMs);
            })));
        });
        it("should update the lockedDevice, only update the allowed error returned to the consumer if different than the previous one, update the fatal error to null and keep the previous onboarding state", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(1);
            });
            // Everything is ok on the first run
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            expect(result.current.lockedDevice).toBe(true);
            expect(result.current.allowedError).toBeInstanceOf(LockedDeviceError);
            expect(result.current.fatalError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            // To compare with the result of the third polling
            const prevAllowedError = result.current.allowedError;
            // Third polling
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            expect(result.current.lockedDevice).toBe(true);
            // It should not have been updated
            // toBe matcher checks referential identity of object instances
            expect(result.current.allowedError).toBe(prevAllowedError);
            expect(result.current.fatalError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
        });
        it("should be able to recover once the allowed error is fixed and the onboarding state is updated", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs + 1);
            });
            // Allowed error occured
            expect(result.current.allowedError).toBeInstanceOf(LockedDeviceError);
            expect(result.current.lockedDevice).toBe(true);
            expect(result.current.fatalError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            await act(async () => {
                jest.advanceTimersByTime(2 * pollingPeriodMs);
            });
            // Everything is ok on the next run
            expect(result.current.allowedError).toBeNull();
            expect(result.current.lockedDevice).toBe(false);
            expect(result.current.onboardingState).toEqual(aSecondOnboardingState);
            expect(result.current.fatalError).toBeNull();
        });
    });
    describe("When a (fatal) error is thrown while polling the device state", () => {
        const anOnboardingStateThatShouldNeverBeReached = {
            ...aSecondOnboardingState,
        };
        beforeEach(() => {
            mockedGetOnboardingStatePolling.mockReturnValue(of({
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                // It should never be reached
                onboardingState: { ...anOnboardingStateThatShouldNeverBeReached },
                allowedError: null,
                lockedDevice: false,
            }).pipe(delayWhen((_, index) => {
                return timer(index * pollingPeriodMs);
            }), map((value, index) => {
                // Throws an error the second time
                if (index === 1) {
                    throw new Error("An unallowed error");
                }
                return value;
            })));
        });
        it("should update the fatal error returned to the consumer, update the allowed error to null, keep the previous onboarding state and stop the polling", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(1);
            });
            // Everything is ok on the first run
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            // Fatal error on the second run
            expect(result.current.allowedError).toBeNull();
            expect(result.current.fatalError).toBeInstanceOf(Error);
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            // The polling should have been stopped, and we never update the onboardingState
            expect(result.current.allowedError).toBeNull();
            expect(result.current.fatalError).toBeInstanceOf(Error);
            expect(result.current.onboardingState).not.toEqual(anOnboardingStateThatShouldNeverBeReached);
            expect(result.current.lockedDevice).toBe(false);
        });
    });
    describe("When the device is in bootloader mode while polling the device state", () => {
        const anOnboardingStateThatShouldNeverBeReached = {
            ...aSecondOnboardingState,
        };
        beforeEach(() => {
            mockedGetOnboardingStatePolling.mockReturnValue(of({
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                onboardingState: { ...anOnboardingState },
                allowedError: null,
                lockedDevice: false,
            }, {
                // It should never be reached
                onboardingState: { ...anOnboardingStateThatShouldNeverBeReached },
                allowedError: null,
                lockedDevice: false,
            }).pipe(delayWhen((_, index) => {
                return timer(index * pollingPeriodMs);
            }), map((value, index) => {
                // Throws an "unexpected bootloader" error the second time
                if (index === 1) {
                    throw new UnexpectedBootloader("Device in bootloader during the polling");
                }
                return value;
            })));
        });
        it("should be considered a fatal error, and it should update the allowed error to null, keep the previous onboarding state and stop the polling", async () => {
            const device = aDevice;
            const { result } = renderHook(() => useOnboardingStatePolling({ device, pollingPeriodMs }));
            await act(async () => {
                jest.advanceTimersByTime(1);
            });
            // Everything is ok on the first run
            expect(result.current.fatalError).toBeNull();
            expect(result.current.allowedError).toBeNull();
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            // Unexpected bootloader fatal error on the second run
            expect(result.current.allowedError).toBeNull();
            expect(result.current.fatalError).toBeInstanceOf(UnexpectedBootloader);
            expect(result.current.onboardingState).toEqual(anOnboardingState);
            expect(result.current.lockedDevice).toBe(false);
            await act(async () => {
                jest.advanceTimersByTime(pollingPeriodMs);
            });
            // The polling should have been stopped, and we never update the onboardingState
            expect(result.current.allowedError).toBeNull();
            expect(result.current.fatalError).toBeInstanceOf(Error);
            expect(result.current.onboardingState).not.toEqual(anOnboardingStateThatShouldNeverBeReached);
            expect(result.current.lockedDevice).toBe(false);
        });
    });
});
//# sourceMappingURL=useOnboardingStatePolling.test.js.map