import '@testing-library/jest-dom';
import { act, render, screen, waitFor } from '@testing-library/react';
import { FC, Fragment, useState } from 'react';
import { bundleState } from '../bundle-state';
import { DatadogProvider, Options } from '../datadog-provider';
import type { RumUser } from '../set-user';
import { setUser } from '../set-user';

jest.mock('../set-user');
jest.mock('../hash-routing', () => mockComponent('HashRouting'));

function mockComponent(name: string) {
    return {
        [name]: ({ children }: any) => (
            <Fragment>
                <div>{`<${name} />`}</div>
                {children}
            </Fragment>
        ),
    };
}

describe(`[datadog-rum] ${DatadogProvider.name}`, () => {
    const initialUser: RumUser = { id: '1' };

    let isEnabled: boolean;
    let options: Options;
    let updateUser: (user?: RumUser) => void;

    beforeEach(() => {
        jest.clearAllMocks();
        isEnabled = true;
        options = {};
        bundleState.isSdkInitializer = false;
    });

    const subject = () => {
        const Component: FC = () => {
            const [user, setUserInner] = useState<RumUser | undefined>(initialUser);
            updateUser = setUserInner;
            return <DatadogProvider isEnabled={isEnabled} user={user} options={options} />;
        };
        return render(<Component />);
    };

    function itRendersHashRoutingWhenEnabled() {
        test('does not render <HashRouting />', async () => {
            subject();

            await waitFor(() =>
                expect(screen.queryByText('<HashRouting />')).not.toBeInTheDocument()
            );
        });

        describe('with options.hashRouting=true', () => {
            beforeEach(() => {
                options.hashRouting = true;
            });

            test('renders <HashRouting />', async () => {
                subject();

                await waitFor(() =>
                    expect(screen.queryByText('<HashRouting />')).toBeInTheDocument()
                );
            });
        });
    }

    function itCallsSetUser() {
        test('calls setUser', () => {
            subject();

            expect(setUser).toHaveBeenCalledWith(initialUser);
        });
    }

    itCallsSetUser();

    itRendersHashRoutingWhenEnabled();

    describe('when the user is changed', () => {
        const nextUser: RumUser = { id: '2' };

        beforeEach(() => {
            subject();
            act(() => {
                updateUser(nextUser);
            });
        });

        test('calls setUser with the new user', () => {
            expect(setUser).toHaveBeenCalledWith(nextUser);
        });

        describe('when the user is then unset', () => {
            beforeEach(() => {
                jest.clearAllMocks();
                act(() => {
                    updateUser(undefined);
                });
            });

            test('does not call setUser', () => {
                expect(setUser).not.toHaveBeenCalled();
            });
        });
    });

    describe('with isEnabled=false', () => {
        beforeEach(() => {
            isEnabled = false;
        });

        test('does not call setUser', () => {
            subject();

            expect(setUser).not.toHaveBeenCalled();
        });

        describe('with options.hashRouting=true', () => {
            beforeEach(() => {
                options.hashRouting = true;
            });

            test('does not render <HashRouting />', async () => {
                subject();

                await waitFor(() =>
                    expect(screen.queryByText('<HashRouting />')).not.toBeInTheDocument()
                );
            });
        });

        describe('when the bundle is the SDK initializer', () => {
            beforeEach(() => {
                bundleState.isSdkInitializer = true;
            });

            itCallsSetUser();

            itRendersHashRoutingWhenEnabled();
        });
    });
});