import {
    act,
    fireEvent,
    render,
    screen,
    waitFor,
} from '@testing-library/react';
import dayjs from 'dayjs';
import ProductDetails from '../product-details';
import type { ProductDetailsProps } from '../product-details';

jest.mock('@theorchard/suite-frontend', () => ({
    useAppConfig: jest.fn(() => ({
        userFeatureFlags: {},
    })),
}));

import * as suiteConfigModule from '@theorchard/suite-frontend';

describe('<ProductDetails>', () => {
    const saleStartDate = dayjs('2023-02-21').toDate();
    const releaseDate = dayjs('2021-01-01').toDate();
    const preorderDate = dayjs('2000-01-01').toDate();

    beforeAll(() => {
        (suiteConfigModule.useAppConfig as jest.Mock).mockReturnValue({
            userFeatureFlags: {},
        });
    });

    const product = {
        productId: '2958087',
        productName: 'Vanishing Point',
        contextType: 'digital',
        releaseDate,
        saleStartDate,
        preorderDate,
        releaseSchedule: {
            timed: [],
            staggered: [],
            unsupportedTimed: [],
        },
    };

    const preorderType = 'specific-date';

    const editable = true;

    const defaultProps: ProductDetailsProps = {
        product,
        preorderType,
        editable,
        errors: { preorderDate: false },
        onModalOpen: jest.fn(),
        onProductChange: jest.fn(),
        setPreorderType: jest.fn(),
    };

    const renderWrapper = (props: Partial<ProductDetailsProps> = {}) =>
        render(<ProductDetails {...defaultProps} {...props} />);

    describe('saleStartDate', () => {
        describe('timed releases', () => {
            describe('exist', () => {
                describe('.ProductDetails-warning', () => {
                    test('renders', () => {
                        const { queryByTestId } = renderWrapper({
                            product: {
                                ...product,
                                releaseSchedule: {
                                    staggered: [],
                                    timed: [
                                        {
                                            deliveryStore: {
                                                id: '1',
                                                name: 'iTunes/Apple',
                                            },
                                            saleDateTime:
                                                '2023-03-16T09:08:17Z',
                                        },
                                    ],
                                    unsupportedTimed: [],
                                },
                            },
                        });
                        expect(
                            queryByTestId('salesStartDate-warning')
                        ).toBeVisible();
                    });

                    test('does not render', () => {
                        const saleDate = dayjs.utc('2023-03-15');
                        const { queryByTestId } = renderWrapper({
                            product: {
                                ...product,
                                saleStartDate: saleDate.toDate(),
                                releaseSchedule: {
                                    staggered: [],
                                    timed: [
                                        {
                                            deliveryStore: {
                                                id: '1',
                                                name: 'iTunes/Apple',
                                            },
                                            saleDateTime:
                                                '2023-03-16T09:08:17Z',
                                        },
                                    ],
                                    unsupportedTimed: [
                                        {
                                            deliveryStore: {
                                                id: '286',
                                                name: 'Spotify',
                                            },
                                            saleDateTime:
                                                '2023-03-16T09:08:17Z',
                                            timeOffset: '01:00',
                                        },
                                    ],
                                },
                            },
                        });
                        expect(
                            queryByTestId('salesStartDate-warning')
                        ).toBeNull();
                        expect(
                            queryByTestId('salesStartDate-info')
                        ).toBeVisible();
                    });
                });
            });

            describe('do not exist', () => {
                describe('.ProductDetails-warning', () => {
                    test('does not render', () => {
                        const { queryByTestId } = renderWrapper();
                        expect(
                            queryByTestId('salesStartDate-warning')
                        ).toBeNull();
                    });
                });
            });

            describe('feature flag: ccm_timed_releases_workstation', () => {
                afterEach(() => {
                    (suiteConfigModule.useAppConfig as jest.Mock).mockReset();
                    (
                        suiteConfigModule.useAppConfig as jest.Mock
                    ).mockReturnValue({ userFeatureFlags: {} });
                });

                describe('enabled', () => {
                    describe('.ProductDetails-info', () => {
                        test('renders instead of warning', () => {
                            (
                                suiteConfigModule.useAppConfig as jest.Mock
                            ).mockReturnValue({
                                userFeatureFlags: {
                                    ccm_timed_releases_workstation: true,
                                },
                            });

                            const { queryByTestId } = renderWrapper({
                                product: {
                                    ...product,
                                    releaseSchedule: {
                                        staggered: [],
                                        timed: [
                                            {
                                                deliveryStore: {
                                                    id: '1',
                                                    name: 'iTunes/Apple',
                                                },
                                                saleDateTime:
                                                    '2023-03-16T09:08:17Z',
                                            },
                                        ],
                                        unsupportedTimed: [],
                                    },
                                },
                            });

                            expect(
                                queryByTestId('salesStartDate-warning')
                            ).toBeNull();
                            expect(
                                queryByTestId('salesStartDate-info')
                            ).toBeVisible();
                        });
                    });

                    describe('when date also spans two days', () => {
                        test('renders both info messages', () => {
                            (
                                suiteConfigModule.useAppConfig as jest.Mock
                            ).mockReturnValue({
                                userFeatureFlags: {
                                    ccm_timed_releases_workstation: true,
                                },
                            });

                            const saleDate = dayjs.utc('2023-03-15');
                            const { getByTestId } = renderWrapper({
                                product: {
                                    ...product,
                                    saleStartDate: saleDate.toDate(),
                                    releaseSchedule: {
                                        staggered: [],
                                        timed: [
                                            {
                                                deliveryStore: {
                                                    id: '1',
                                                    name: 'iTunes/Apple',
                                                },
                                                saleDateTime:
                                                    '2023-03-16T09:08:17Z',
                                            },
                                        ],
                                        unsupportedTimed: [
                                            {
                                                deliveryStore: {
                                                    id: '286',
                                                    name: 'Spotify',
                                                },
                                                saleDateTime:
                                                    '2023-03-16T09:08:17Z',
                                                timeOffset: '01:00',
                                            },
                                        ],
                                    },
                                },
                            });

                            const infoElement = getByTestId(
                                'salesStartDate-info'
                            );
                            expect(infoElement).toBeVisible();
                            expect(infoElement.textContent).toContain(
                                '1 day before'
                            );
                            expect(infoElement.textContent).toContain(
                                'does not need to be padded'
                            );
                        });
                    });
                });

                describe('disabled', () => {
                    describe('.ProductDetails-warning', () => {
                        test('renders when timed releases exist', () => {
                            (
                                suiteConfigModule.useAppConfig as jest.Mock
                            ).mockReturnValue({
                                userFeatureFlags: {
                                    ccm_timed_releases_workstation: false,
                                },
                            });

                            const { queryByTestId } = renderWrapper({
                                product: {
                                    ...product,
                                    releaseSchedule: {
                                        staggered: [],
                                        timed: [
                                            {
                                                deliveryStore: {
                                                    id: '1',
                                                    name: 'iTunes/Apple',
                                                },
                                                saleDateTime:
                                                    '2023-03-16T09:08:17Z',
                                            },
                                        ],
                                        unsupportedTimed: [],
                                    },
                                },
                            });

                            expect(
                                queryByTestId('salesStartDate-warning')
                            ).toBeVisible();
                            expect(
                                queryByTestId('salesStartDate-info')
                            ).toBeNull();
                        });
                    });
                });
            });
        });

        describe('unsupported timed releases', () => {
            describe('exists', () => {
                describe('.ProductDetails-info', () => {
                    describe('renders', () => {
                        test('schedule already processed', () => {
                            const saleDate = dayjs.utc('2023-03-15');
                            const { queryByTestId } = renderWrapper({
                                product: {
                                    ...product,
                                    saleStartDate: saleDate.toDate(),
                                    releaseSchedule: {
                                        staggered: [],
                                        timed: [],
                                        unsupportedTimed: [
                                            {
                                                deliveryStore: {
                                                    id: '1',
                                                    name: 'iTunes/Apple',
                                                },
                                                saleDateTime:
                                                    '2023-03-16T09:08:17Z',
                                                timeOffset: '01:00',
                                            },
                                        ],
                                    },
                                },
                            });
                            expect(
                                queryByTestId('salesStartDate-info')
                            ).toBeVisible();
                        });
                    });

                    describe('does not render', () => {
                        test('schedule is in the future', () => {
                            const today = dayjs.utc();
                            const past = today.subtract(1, 'year');
                            const { queryByTestId } = renderWrapper({
                                product: {
                                    ...product,
                                    saleStartDate: past.toDate(),
                                    releaseSchedule: {
                                        staggered: [],
                                        timed: [],
                                        unsupportedTimed: [
                                            {
                                                deliveryStore: {
                                                    id: '1',
                                                    name: 'iTunes/Apple',
                                                },
                                                saleDateTime: today.format(
                                                    'YYYY-MM-DDTHH:mm:ssZ'
                                                ),
                                                timeOffset: '01:00',
                                            },
                                        ],
                                    },
                                },
                            });
                            expect(
                                queryByTestId('salesStartDate-info')
                            ).toBeNull();
                        });
                    });
                });
            });

            describe('do not exist', () => {
                describe('.ProductDetails-info', () => {
                    test('does not render', () => {
                        const { queryByTestId } = renderWrapper();
                        expect(queryByTestId('salesStartDate-info')).toBeNull();
                    });
                });
            });
        });

        describe('value changed', () => {
            const newSalesStartDate = '2003-06-25';

            test('calls onProductChange with updated saleStartDate', () => {
                const onProductChange = jest.fn();
                const { getByTestId } = renderWrapper({ onProductChange });

                const container = getByTestId('salesStartDate');
                const calendar = container.querySelector(
                    '.SuiteDatePicker-indicator-calendar'
                );
                if (calendar) fireEvent.click(calendar);

                const input = container.querySelector(
                    '.DateSelect-input-controls input'
                );
                input &&
                    fireEvent.change(input, {
                        target: { value: newSalesStartDate },
                    });

                expect(onProductChange).toHaveBeenCalledWith({
                    ...product,
                    saleStartDate: dayjs(newSalesStartDate).toDate(),
                });
            });
        });
    });

    describe('releaseDate', () => {
        describe('value changed', () => {
            const newReleaseDate = '2003-06-25';

            test('calls onProductChange with updated releaseDate', () => {
                const onProductChange = jest.fn();
                const { getByTestId } = renderWrapper({ onProductChange });

                const container = getByTestId('releaseDate');
                const calendar = container.querySelector(
                    '.SuiteDatePicker-indicator-calendar'
                );
                if (calendar) fireEvent.click(calendar);

                const input = container.querySelector(
                    '.DateSelect-input-controls input'
                );
                input &&
                    fireEvent.change(input, {
                        target: { value: newReleaseDate },
                    });

                expect(onProductChange).toHaveBeenCalledWith({
                    ...product,
                    releaseDate: dayjs(newReleaseDate).toDate(),
                });
            });
        });
    });

    describe('preorderDate', () => {
        describe('value changed', () => {
            describe('specific-date', () => {
                const newPreorderDate = '2003-06-25';

                describe('calls onProductChange with updated preorderDate', () => {
                    test('existing preorderDate is set to new date', () => {
                        const onProductChange = jest.fn();
                        const { getByTestId } = renderWrapper({
                            onProductChange,
                        });

                        const container = getByTestId('preorderType');
                        const calendar = container.querySelector(
                            '.SuiteDatePicker-indicator-calendar'
                        );
                        if (calendar) fireEvent.click(calendar);

                        const input = container.querySelector(
                            '.DateSelect-input-controls input'
                        );

                        input &&
                            fireEvent.change(input, {
                                target: { value: newPreorderDate },
                            });
                        expect(onProductChange).toHaveBeenCalledWith({
                            ...product,
                            preorderDate: dayjs(newPreorderDate).toDate(),
                        });
                    });

                    test('null preorderDate is set to new date', () => {
                        const onProductChange = jest.fn();
                        const { getByTestId } = renderWrapper({
                            onProductChange,
                            product: {
                                ...product,
                                preorderDate: null,
                            },
                        });
                        const container = getByTestId('preorderType');
                        const calendar = container.querySelector(
                            '.SuiteDatePicker-indicator-calendar'
                        );
                        if (calendar) fireEvent.click(calendar);

                        const input = container.querySelector(
                            '.DateSelect-input-controls input'
                        );

                        input &&
                            fireEvent.change(input, {
                                target: { value: newPreorderDate },
                            });
                        expect(onProductChange).toHaveBeenCalledWith({
                            ...product,
                            previewable: 'no',
                            preorderDate: dayjs(newPreorderDate).toDate(),
                        });
                    });
                });
            });

            describe('immediate', () => {
                describe('calls onProductChange with updated preorderDate', () => {
                    test('existing preorderDate is set to new date', () => {
                        const onProductChange = jest.fn();
                        const setPreorderType = jest.fn();
                        const { getByTestId, getByText } = renderWrapper({
                            onProductChange,
                            setPreorderType,
                        });
                        const input = getByTestId(
                            'preorderTypeDropdown'
                        ).querySelector('input');
                        input && fireEvent.mouseDown(input);

                        getByText('Immediate').click();
                        expect(onProductChange).toHaveBeenCalledWith({
                            ...product,
                            preorderDate: dayjs('1900-01-01').toDate(),
                        });
                        expect(setPreorderType).toHaveBeenCalledWith(
                            'immediate'
                        );
                    });

                    test('null preorderDate is set to immediate', () => {
                        const onProductChange = jest.fn();
                        const setPreorderType = jest.fn();
                        const { getByTestId, getByText } = renderWrapper({
                            onProductChange,
                            setPreorderType,
                            product: {
                                ...product,
                                preorderDate: null,
                            },
                        });
                        const input = getByTestId(
                            'preorderTypeDropdown'
                        ).querySelector('input');
                        input && fireEvent.mouseDown(input);

                        getByText('Immediate').click();
                        expect(onProductChange).toHaveBeenCalledWith({
                            ...product,
                            previewable: 'no',
                            preorderDate: dayjs('1900-01-01').toDate(),
                        });
                        expect(setPreorderType).toHaveBeenCalledWith(
                            'immediate'
                        );
                    });
                });
            });
        });

        describe('value unset', () => {
            test('calls onProductChange with updated preorderDate', () => {
                const onProductChange = jest.fn();
                const setPreorderType = jest.fn();
                const { getByTestId, getByText } = renderWrapper({
                    preorderType: 'specific-date',
                    onProductChange,
                    setPreorderType,
                });
                const input = getByTestId('preorderTypeDropdown').querySelector(
                    'input'
                );
                input && fireEvent.mouseDown(input);

                getByText('No Pre-Order').click();
                expect(onProductChange).toHaveBeenCalledWith({
                    ...product,
                    previewable: null,
                    preorderDate: null,
                });
                expect(setPreorderType).toHaveBeenCalledWith('no-preorder');
            });
        });

        describe('has preorderType error', () => {
            describe('.ProductDetails-error', () => {
                test('preorderDate null when specific-date type', () => {
                    const { queryByTestId, getByText } = renderWrapper({
                        preorderType: 'specific-date',
                        product: { ...product, preorderDate: null },
                        errors: {
                            preorderDate: true,
                        },
                    });
                    const errorAlert = queryByTestId('preorderType-error');
                    expect(errorAlert).toBeInTheDocument();
                    expect(
                        getByText(
                            $t(
                                'releaseScheduler.productDetails.preorderSpecificDateError'
                            )
                        )
                    ).toBeInTheDocument();
                });

                test('preorderDate comes after saleStartDate', () => {
                    const { queryByTestId, getByText } = renderWrapper({
                        preorderType: 'specific-date',
                        product: {
                            ...product,
                            preorderDate: dayjs('2023-02-26').toDate(),
                        },
                        errors: {
                            preorderDate: true,
                        },
                    });
                    const errorAlert = queryByTestId('preorderType-error');
                    expect(errorAlert).toBeInTheDocument();
                    expect(
                        getByText(
                            $t(
                                'releaseScheduler.productDetails.preorderAfterSalesDateError'
                            )
                        )
                    ).toBeInTheDocument();
                });
            });
        });

        describe('has no preorderDate error', () => {
            describe('.ProductDetails-error', () => {
                test('does not render', () => {
                    const { queryByTestId } = renderWrapper({
                        errors: {
                            preorderDate: false,
                        },
                    });
                    expect(
                        queryByTestId('preorderType-error')
                    ).not.toBeInTheDocument();
                });
            });
        });
    });

    describe('release schedule help tooltips', () => {
        describe('timed release help tooltip', () => {
            test('tooltip trigger renders', () => {
                const { getByTestId } = renderWrapper();
                const tooltipTrigger = getByTestId(
                    'timed-release-help-tooltip'
                );
                const infoGlyph =
                    tooltipTrigger.getElementsByClassName('InfoGlyphIcon')[0];
                expect(tooltipTrigger).toBeInTheDocument();
                expect(infoGlyph).toBeInTheDocument();
            });

            test('tooltip text renders', async () => {
                const { container, getByTestId } = renderWrapper();
                const tooltipTrigger = getByTestId(
                    'timed-release-help-tooltip'
                );

                await act(async () => {
                    await fireEvent.mouseOver(tooltipTrigger);
                });

                await waitFor(
                    async () =>
                        await screen.findByText(
                            $t(
                                'releaseScheduler.productDetails.timedReleaseTooltip'
                            )
                        )
                );
                const tooltip = container.getElementsByClassName('tooltip')[0];
                expect(tooltip).toBeInTheDocument();
            });
        });

        describe('staggered release help tooltip', () => {
            test('tooltip trigger renders', () => {
                const { getByTestId } = renderWrapper();
                const tooltipTrigger = getByTestId(
                    'staggered-release-help-tooltip'
                );
                const infoGlyph =
                    tooltipTrigger.getElementsByClassName('InfoGlyphIcon')[0];
                expect(tooltipTrigger).toBeInTheDocument();
                expect(infoGlyph).toBeInTheDocument();
            });

            test('tooltip text renders', async () => {
                const { container, getByTestId } = renderWrapper();
                const tooltipTrigger = getByTestId(
                    'staggered-release-help-tooltip'
                );
                await act(async () => {
                    await fireEvent.mouseOver(tooltipTrigger);
                });

                await waitFor(
                    async () =>
                        await screen.findByText(
                            $t(
                                'releaseScheduler.productDetails.staggeredReleaseTooltip'
                            )
                        )
                );
                const tooltip = container.getElementsByClassName('tooltip')[0];
                expect(tooltip).toBeInTheDocument();
            });
        });
    });

    describe('renders with scheduling tables', () => {
        test('matches snapshot', () => {
            const { container } = renderWrapper();
            expect(container).toMatchSnapshot();
        });

        test('tables are rendered', () => {
            const { queryAllByTestId } = renderWrapper();
            const tables = queryAllByTestId('release-schedule-table');
            expect(tables).toHaveLength(2);
        });
    });

    describe('renders without scheduling tables', () => {
        test('matches snapshot', () => {
            const { container } = renderWrapper({
                product: { ...product, contextType: 'physical' },
            });
            expect(container).toMatchSnapshot();
        });

        test('tables are not rendered', () => {
            const { queryByTestId } = renderWrapper({
                product: { ...product, contextType: 'physical' },
            });
            const tables = queryByTestId('release-schedule-table');
            expect(tables).toBeNull();
        });
    });

    describe('scheduling tables manage buttons', () => {
        describe('when schedule is empty', () => {
            describe('manage timed release button', () => {
                describe('clicked', () => {
                    test('calls onModalOpen', () => {
                        const onModalOpen = jest.fn();
                        const { getByTestId } = renderWrapper({ onModalOpen });
                        const button = getByTestId('manage-timed-releases');
                        fireEvent.click(button);
                        expect(onModalOpen).toHaveBeenCalledWith('timed');
                    });
                });
            });

            describe('manage staggered release button', () => {
                describe('clicked', () => {
                    test('calls onModalOpen', () => {
                        const onModalOpen = jest.fn();
                        const { getByTestId } = renderWrapper({ onModalOpen });
                        const button = getByTestId('manage-staggered-releases');
                        fireEvent.click(button);
                        expect(onModalOpen).toHaveBeenCalledWith('staggered');
                    });
                });
            });
        });

        describe('when schedule is populated', () => {
            describe('manage timed release button', () => {
                describe('clicked', () => {
                    test('calls onModalOpen', () => {
                        const onModalOpen = jest.fn();
                        const { getByTestId } = renderWrapper({
                            product: {
                                ...product,
                                releaseSchedule: {
                                    timed: [
                                        {
                                            deliveryStore: {
                                                id: '286',
                                                name: 'Spotify',
                                            },
                                            saleDateTime:
                                                '2023-01-01T00:00:00Z',
                                        },
                                    ],
                                    staggered: [],
                                    unsupportedTimed: [],
                                },
                            },
                            onModalOpen,
                        });
                        const button = getByTestId('manage-timed-releases');
                        fireEvent.click(button);
                        expect(onModalOpen).toHaveBeenCalledWith('timed');
                    });
                });
            });

            describe('manage staggered release button', () => {
                describe('clicked', () => {
                    test('calls onModalOpen', () => {
                        const onModalOpen = jest.fn();
                        const { getByTestId } = renderWrapper({
                            product: {
                                ...product,
                                releaseSchedule: {
                                    timed: [],
                                    staggered: [
                                        {
                                            deliveryStore: {
                                                id: '286',
                                                name: 'Spotify',
                                            },
                                            saleDate: '2023-01-01',
                                        },
                                    ],
                                    unsupportedTimed: [],
                                },
                            },
                            onModalOpen,
                        });
                        const button = getByTestId('manage-staggered-releases');
                        fireEvent.click(button);
                        expect(onModalOpen).toHaveBeenCalledWith('staggered');
                    });
                });
            });
        });
    });

    describe('timed release schedule', () => {
        test('only timed release supported', () => {
            const { queryByTestId } = renderWrapper({
                product: {
                    ...product,
                    releaseSchedule: {
                        timed: [
                            {
                                deliveryStore: {
                                    id: '286',
                                    name: 'Spotify',
                                    supportsTimedRelease: true,
                                },
                                saleDateTime: '2023-01-01T00:00:00Z',
                            },
                        ],
                        staggered: [],
                        unsupportedTimed: [],
                    },
                },
            });
            const supportedTable = queryByTestId('timed-supported-table');
            const unsupportedAlert = queryByTestId('timed-unsupported-alert');
            const unsupportedTable = queryByTestId('timed-unsupported-table');
            expect(supportedTable).toBeInTheDocument();
            expect(unsupportedAlert).toBeNull();
            expect(unsupportedTable).toBeNull();
        });

        test('only timed release unsupported', () => {
            const { queryByTestId } = renderWrapper({
                product: {
                    ...product,
                    releaseSchedule: {
                        timed: [],
                        staggered: [],
                        unsupportedTimed: [
                            {
                                deliveryStore: {
                                    id: '286',
                                    name: 'Spotify',
                                    supportsTimedRelease: false,
                                },
                                saleDateTime: '2023-01-01T00:00:00Z',
                                timeOffset: '01:00',
                            },
                        ],
                    },
                },
            });
            const expectedProcessAtDate = '11:00pm GMT on 31 Dec 2022';

            const supportedTable = queryByTestId('timed-supported-table');
            const unsupportedAlert = queryByTestId('timed-unsupported-alert');
            const unsupportedTable = queryByTestId('timed-unsupported-table');
            expect(supportedTable).toBeNull();
            expect(unsupportedAlert).toBeInTheDocument();
            expect(unsupportedAlert).toHaveTextContent(expectedProcessAtDate);
            expect(unsupportedTable).toBeInTheDocument();
        });

        test('both timed release supported and unsupported', () => {
            const { queryByTestId } = renderWrapper({
                product: {
                    ...product,
                    releaseSchedule: {
                        timed: [
                            {
                                deliveryStore: {
                                    id: '286',
                                    name: 'Spotify',
                                },
                                saleDateTime: '2023-01-01T00:00:00Z',
                            },
                        ],
                        staggered: [],
                        unsupportedTimed: [
                            {
                                deliveryStore: {
                                    id: '712',
                                    name: 'Apple',
                                },
                                saleDateTime: '2023-01-01T00:00:00Z',
                                timeOffset: '00:45',
                            },
                        ],
                    },
                },
            });
            const expectedProcessAtDate = '11:15pm GMT on 31 Dec 2022';

            const supportedTable = queryByTestId('timed-supported-table');
            const unsupportedAlert = queryByTestId('timed-unsupported-alert');
            const unsupportedTable = queryByTestId('timed-unsupported-table');
            expect(supportedTable).toBeInTheDocument();
            expect(unsupportedAlert).toBeInTheDocument();
            expect(unsupportedAlert).toHaveTextContent(expectedProcessAtDate);
            expect(unsupportedTable).toBeInTheDocument();
        });
    });

    describe('feature flag: ccm_physical_supplychaininfo_oa', () => {
        afterEach(() => {
            (suiteConfigModule.useAppConfig as jest.Mock).mockReset();
            (suiteConfigModule.useAppConfig as jest.Mock).mockReturnValue({
                userFeatureFlags: {},
            });
        });

        describe('.ProductDetails-info', () => {
            test('renders when enabled, product is physical and saleStartDate is changed', () => {
                (suiteConfigModule.useAppConfig as jest.Mock).mockReturnValue({
                    userFeatureFlags: {
                        ccm_physical_supplychaininfo_oa: true,
                    },
                });

                const onProductChange = jest.fn();
                const { getByTestId, queryByTestId } = renderWrapper({
                    product: { ...product, contextType: 'physical' },
                    onProductChange,
                });

                expect(queryByTestId('salesStartDate-info')).toBeNull();

                const container = getByTestId('salesStartDate');
                const calendar = container.querySelector(
                    '.SuiteDatePicker-indicator-calendar'
                );
                if (calendar) fireEvent.click(calendar);

                const input = container.querySelector(
                    '.DateSelect-input-controls input'
                );
                input &&
                    fireEvent.change(input, {
                        target: { value: '2003-06-25' },
                    });

                expect(
                    queryByTestId('salesStartDate-info')
                ).toBeInTheDocument();
                expect(queryByTestId('salesStartDate-info')).toHaveTextContent(
                    $t(
                        'releaseScheduler.productDetails.saleStartDateInfoForPhysical'
                    )
                );
            });

            test('does not render when feature flag is disabled', () => {
                (suiteConfigModule.useAppConfig as jest.Mock).mockReturnValue({
                    userFeatureFlags: {
                        ccm_physical_supplychaininfo_oa: false,
                    },
                });

                const { getByTestId, queryByTestId } = renderWrapper({
                    product: { ...product, contextType: 'physical' },
                });

                const container = getByTestId('salesStartDate');
                const calendar = container.querySelector(
                    '.SuiteDatePicker-indicator-calendar'
                );
                if (calendar) fireEvent.click(calendar);

                const input = container.querySelector(
                    '.DateSelect-input-controls input'
                );
                input &&
                    fireEvent.change(input, {
                        target: { value: '2003-06-25' },
                    });

                expect(queryByTestId('salesStartDate-info')).toBeNull();
            });

            test('does not render when product is digital', () => {
                (suiteConfigModule.useAppConfig as jest.Mock).mockReturnValue({
                    userFeatureFlags: {
                        ccm_physical_supplychaininfo_oa: true,
                    },
                });

                const { getByTestId, queryByTestId } = renderWrapper({
                    product: { ...product, contextType: 'digital' },
                });

                const container = getByTestId('salesStartDate');
                const calendar = container.querySelector(
                    '.SuiteDatePicker-indicator-calendar'
                );
                if (calendar) fireEvent.click(calendar);

                const input = container.querySelector(
                    '.DateSelect-input-controls input'
                );
                input &&
                    fireEvent.change(input, {
                        target: { value: '2003-06-25' },
                    });

                expect(queryByTestId('salesStartDate-info')).toBeNull();
            });
        });
    });
});