ReportTest.ts

/* eslint-disable @typescript-eslint/naming-convention */
import {afterEach, beforeAll, beforeEach, describe, expect, it} from '@jest/globals';
import {renderHook} from '@testing-library/react-native';

import type {SearchQueryJSON} from '@components/Search/types';
import type handleWalletStatementNavigationDefault from '@components/WalletStatementModal/walletNavigationUtils';

import useAncestors from '@hooks/useAncestors';

import markAllMessagesAsRead from '@libs/actions/Report/MarkAllMessageAsRead';
import {CONCIERGE_RESPONSE_DELAY_MS, resolveSuggestedFollowup} from '@libs/actions/Report/SuggestedFollowup';
import {getOnboardingMessages} from '@libs/actions/Welcome/OnboardingFlow';
import * as API from '@libs/API';
import {WRITE_COMMANDS} from '@libs/API/types';
import HttpUtils from '@libs/HttpUtils';
import Navigation from '@libs/Navigation/Navigation';
import {buildNextStepNew} from '@libs/NextStepUtils';
import {getAccountIDsByLogins} from '@libs/PersonalDetailsUtils';
import {getOriginalMessage, isDeletedAction} from '@libs/ReportActionsUtils';
import playSound, {SOUNDS} from '@libs/Sound';

import {toggleEmojiReaction} from '@userActions/EmojiReactions';

import CONST from '@src/CONST';
import OnyxUpdateManager from '@src/libs/actions/OnyxUpdateManager';
import * as PersistedRequests from '@src/libs/actions/PersistedRequests';
import {initReconnect} from '@src/libs/actions/Reconnect';
import * as Report from '@src/libs/actions/Report';
import * as User from '@src/libs/actions/User';
import DateUtils from '@src/libs/DateUtils';
import Log from '@src/libs/Log';
import * as SequentialQueue from '@src/libs/Network/SequentialQueue';
import {setHasRadio} from '@src/libs/NetworkState';
import * as ReportUtils from '@src/libs/ReportUtils';
import type * as SearchQueryUtilsType from '@src/libs/SearchQueryUtils';
import ONYXKEYS from '@src/ONYXKEYS';
import ROUTES from '@src/ROUTES';
import type * as OnyxTypes from '@src/types/onyx';
import type {Message} from '@src/types/onyx/ReportAction';

import type {OnyxCollection, OnyxEntry, OnyxUpdate} from 'react-native-onyx';

import {addSeconds, format, subMinutes} from 'date-fns';
import {toZonedTime} from 'date-fns-tz';
import Onyx from 'react-native-onyx';
import OnyxUtils from 'react-native-onyx/dist/OnyxUtils';

import type {MockFetch} from '../utils/TestHelper';

import createCollection from '../utils/collections/createCollection';
import createRandomPolicy from '../utils/collections/policies';
import createRandomReportAction from '../utils/collections/reportActions';
import {createRandomReport} from '../utils/collections/reports';
import createRandomTransaction from '../utils/collections/transaction';
import createMock from '../utils/createMock';
import getIsUsingFakeTimers from '../utils/getIsUsingFakeTimers';
import getOnyxValue from '../utils/getOnyxValue';
import PusherHelper from '../utils/PusherHelper';
import * as TestHelper from '../utils/TestHelper';
import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
import waitForNetworkPromises from '../utils/waitForNetworkPromises';

jest.mock('@libs/NextStepUtils', () => ({
    buildNextStepNew: jest.fn(),
    buildOptimisticNextStep: jest.fn(),
}));

const MOCKED_POLICY_EXPENSE_CHAT_REPORT_ID = '1234';

/* eslint-disable @typescript-eslint/no-unsafe-assignment */
jest.mock('@libs/ReportUtils', () => {
    const actual = jest.requireActual<typeof ReportUtils>('@libs/ReportUtils');
    const mockGenerateReportID = jest.fn().mockReturnValue('9876');
    return {
        ...actual,
        generateReportID: mockGenerateReportID,
        buildOptimisticChatReport: jest.fn().mockImplementation((params: Record<string, unknown>) => {
            const optimisticReportID = typeof params.optimisticReportID === 'string' ? params.optimisticReportID : undefined;
            const mockReportID = optimisticReportID ?? mockGenerateReportID();
            return {
                reportID: mockReportID,
                type: 'chat',
                participants: {},
            };
        }),
        getPolicyExpenseChat: jest.fn().mockImplementation(() => ({reportID: MOCKED_POLICY_EXPENSE_CHAT_REPORT_ID, hasOutstandingChildRequest: false})),
    };
});
/* eslint-enable @typescript-eslint/no-unsafe-assignment */

const currentHash = 12345;
jest.mock('@src/libs/SearchQueryUtils', () => {
    const originalSearchQueryModule = jest.requireActual<typeof SearchQueryUtilsType>('@src/libs/SearchQueryUtils');
    return {
        ...originalSearchQueryModule,
        getCurrentSearchQueryJSON: jest.fn().mockImplementation(() => ({
            hash: currentHash,
            query: 'test',
            type: 'expense',
            status: '',
            flatFilters: [],
        })),
    };
});

const UTC = 'UTC';
jest.mock('@src/libs/actions/Report', () => {
    const originalModule = jest.requireActual<Report>('@src/libs/actions/Report');

    return {
        ...originalModule,
        showReportActionNotification: jest.fn(),
    };
});

jest.mock('@hooks/useScreenWrapperTransitionStatus', () => ({
    default: () => ({
        didScreenTransitionEnd: true,
    }),
}));

jest.mock('@libs/Sound', () => ({
    __esModule: true,
    default: jest.fn(),
    SOUNDS: {DONE: 'DONE'},
}));

jest.mock('@hooks/useCardFeedsForDisplay', () => jest.fn(() => ({defaultCardFeed: null, cardFeedsByPolicy: {}})));

jest.mock('@libs/Navigation/Navigation', () => ({
    navigate: jest.fn((_route: string, options?: {afterTransition?: () => void}) => {
        options?.afterTransition?.();
    }),
    getActiveRoute: jest.fn().mockReturnValue(''),
    getActiveRouteWithoutParams: jest.fn(() => ''),
    dismissModalWithReport: jest.fn(),
    dismissModal: jest.fn(),
    dismissToSuperWideRHP: jest.fn(),
    isNavigationReady: jest.fn(() => Promise.resolve()),
    isActiveRoute: jest.fn(() => false),
    getTopmostReportId: jest.fn(() => undefined),
    getTopmostSuperWideRHPReportID: jest.fn(() => undefined),
    getTopmostSearchReportRouteParams: jest.fn(() => undefined),
    goBack: jest.fn(),
    popToSidebar: jest.fn(),
    navigationRef: {
        getRootState: jest.fn(() => ({routes: []})),
        isReady: jest.fn(() => true),
        current: {
            getRootState: jest.fn(() => ({routes: []})),
        },
    },
}));

// eslint-disable-next-line @typescript-eslint/no-unsafe-return
jest.mock('@libs/actions/Welcome', () => ({
    ...jest.requireActual('@libs/actions/Welcome'),
    onServerDataReady: jest.fn(() => Promise.resolve()),
}));

jest.mock('react-native-fs', () => ({
    DocumentDirectoryPath: '/mock/documents',
    copyFile: jest.fn(() => Promise.resolve()),
    exists: jest.fn(() => Promise.resolve(true)),
    unlink: jest.fn(() => Promise.resolve()),
}));

jest.mock('react-native-blob-util', () => ({
    config: jest.fn((data: {path?: string} | undefined) => {
        const filePath: string = data?.path ?? '/mock/documents/file';
        return {
            fetch: jest.fn(() =>
                Promise.resolve({
                    path: jest.fn((): string => filePath),
                }),
            ),
        };
    }),
    fs: {
        dirs: {
            DocumentDir: '/mock/documents',
        },
    },
    fetch: jest.fn(() =>
        Promise.resolve({
            path: jest.fn((): string => '/mock/documents/file'),
        }),
    ),
}));

const originalXHR = HttpUtils.xhr;
OnyxUpdateManager();
initReconnect();

// Define introSelected to use across all openReport tests
const TEST_INTRO_SELECTED: OnyxTypes.IntroSelected = {
    choice: CONST.ONBOARDING_CHOICES.SUBMIT,
    isInviteOnboardingComplete: false,
};

const getMockFetch = (fetch: typeof global.fetch) => fetch as MockFetch;

type APIWriteSpy = jest.SpiedFunction<typeof API.write>;

describe('actions/Report', () => {
    let apiWriteSpy: APIWriteSpy;

    beforeAll(() => {
        PusherHelper.setup();
        Onyx.init({
            keys: ONYXKEYS,
        });
    });

    beforeEach(() => {
        HttpUtils.xhr = originalXHR;
        setHasRadio(true);
        const promise = Onyx.clear().then(() => {
            jest.useRealTimers();
            waitForBatchedUpdates();
        });

        if (getIsUsingFakeTimers()) {
            // flushing pending timers
            // Onyx.clear() promise is resolved in batch which happens after the current microtasks cycle
            setImmediate(jest.runOnlyPendingTimers);
        }
        global.fetch = TestHelper.getGlobalFetchMock();
        apiWriteSpy = jest.spyOn(API, 'write');

        // Clear the queue before each test to avoid test pollution
        SequentialQueue.resetQueue();

        return promise;
    });

    afterEach(() => {
        apiWriteSpy.mockRestore();
        jest.clearAllMocks();
        PusherHelper.teardown();
    });

    it('should store a new report action in Onyx when onyxApiUpdate event is handled via Pusher', () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@test.com';
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        let reportActionID: string | undefined;
        const REPORT_ACTION = {
            actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
            actorAccountID: TEST_USER_ACCOUNT_ID,
            automatic: false,
            avatar: 'https://d2k5nsl2zxldvw.cloudfront.net/images/avatars/avatar_3.png',
            message: [{type: 'COMMENT', html: 'Testing a comment', text: 'Testing a comment', translationKey: ''}],
            person: [{type: 'TEXT', style: 'strong', text: 'Test User'}],
            shouldShow: true,
        };

        let reportActions: OnyxEntry<OnyxTypes.ReportActions>;
        Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (val) => (reportActions = val),
        });

        // Set up Onyx with some test user data
        return TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN)
            .then(() => {
                User.subscribeToUserEvents(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN, () => {}, undefined);
                return waitForBatchedUpdates();
            })
            .then(() => TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID))
            .then(() => {
                // This is a fire and forget response, but once it completes we should be able to verify that we
                // have an "optimistic" report action in Onyx.
                Report.addComment({
                    report: REPORT,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Testing a comment',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: TEST_USER_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });
                return waitForBatchedUpdates();
            })
            .then(() => {
                const resultAction: OnyxEntry<OnyxTypes.ReportAction> = Object.values(reportActions ?? {}).at(0);
                reportActionID = resultAction?.reportActionID;

                expect(reportActionID).not.toBeUndefined();
                expect(resultAction?.message).toEqual(REPORT_ACTION.message);
                expect(resultAction?.person).toEqual(REPORT_ACTION.person);
                expect(resultAction?.pendingAction).toBeUndefined();

                if (!reportActionID) {
                    return;
                }

                // We subscribed to the Pusher channel above and now we need to simulate a reportComment action
                // Pusher event so we can verify that action was handled correctly and merged into the reportActions.
                PusherHelper.emitOnyxUpdate([
                    {
                        onyxMethod: Onyx.METHOD.MERGE,
                        key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`,
                        value: {
                            reportID: REPORT_ID,
                            participants: {
                                [TEST_USER_ACCOUNT_ID]: {
                                    notificationPreference: 'always',
                                },
                            },
                            lastVisibleActionCreated: '2022-11-22 03:48:27.267',
                            lastMessageText: 'Testing a comment',
                            lastActorAccountID: TEST_USER_ACCOUNT_ID,
                        },
                    },
                    {
                        onyxMethod: Onyx.METHOD.MERGE,
                        key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                        value: {
                            [reportActionID]: {pendingAction: null},
                        },
                    },
                ]);

                // Once a reportComment event is emitted to the Pusher channel we should see the comment get processed
                // by the Pusher callback and added to the storage so we must wait for promises to resolve again and
                // then verify the data is in Onyx.
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Verify there is only one action and our optimistic comment has been removed
                expect(Object.keys(reportActions ?? {}).length).toBe(1);

                const resultAction = reportActionID ? reportActions?.[reportActionID] : undefined;

                // Verify that our action is no longer in the loading state
                expect(resultAction?.pendingAction).toBeUndefined();
            });
    });

    it('clearCreateChatError should not delete the report if it is not optimistic report', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT: OnyxTypes.Report = {...createRandomReport(1, undefined), errorFields: {createChat: {error: 'error'}}};
        const REPORT_METADATA: OnyxTypes.ReportMetadata = {isOptimisticReport: false};
        const CONCIERGE_REPORT_ID = '123456';

        Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`, REPORT);
        Onyx.set(`${ONYXKEYS.COLLECTION.REPORT_METADATA}${REPORT.reportID}`, REPORT_METADATA);

        return waitForBatchedUpdates()
            .then(() => {
                Report.clearCreateChatError(
                    REPORT,
                    CONCIERGE_REPORT_ID,
                    {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM},
                    TEST_USER_ACCOUNT_ID,
                    undefined,
                    false,
                    undefined,
                    undefined,
                    undefined,
                );
                return waitForBatchedUpdates();
            })
            .then(
                () =>
                    new Promise<void>((resolve) => {
                        const connection = Onyx.connect({
                            key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`,
                            callback: (report) => {
                                Onyx.disconnect(connection);
                                resolve();

                                // The report should exist but the create chat error field should be cleared.
                                expect(report?.reportID).toBeDefined();
                                expect(report?.errorFields?.createChat).toBeUndefined();
                            },
                        });
                    }),
            );
    });

    it('clearCreateChatError should pass introSelected when navigating to concierge for optimistic report', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT: OnyxTypes.Report = {...createRandomReport(1, undefined), errorFields: {createChat: {error: 'error'}}};
        const REPORT_METADATA: OnyxTypes.ReportMetadata = {isOptimisticReport: true};
        const CONCIERGE_REPORT_ID = '123456';
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`, REPORT);
        Onyx.set(`${ONYXKEYS.COLLECTION.REPORT_METADATA}${REPORT.reportID}`, REPORT_METADATA);

        return waitForBatchedUpdates()
            .then(() => {
                Report.clearCreateChatError(REPORT, CONCIERGE_REPORT_ID, INTRO_SELECTED, TEST_USER_ACCOUNT_ID, undefined, false, undefined, undefined, undefined);
                return waitForBatchedUpdates();
            })
            .then(
                () =>
                    new Promise<void>((resolve) => {
                        const connection = Onyx.connect({
                            key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`,
                            callback: (report) => {
                                Onyx.disconnect(connection);
                                resolve();

                                // The optimistic report should be deleted (null) since it had createChat error
                                expect(report).toBeUndefined();
                            },
                        });
                    }),
            );
    });

    it('clearCreateChatError should not delete the report with introSelected if it is not optimistic report', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT: OnyxTypes.Report = {...createRandomReport(1, undefined), errorFields: {createChat: {error: 'error'}}};
        const REPORT_METADATA: OnyxTypes.ReportMetadata = {isOptimisticReport: false};
        const CONCIERGE_REPORT_ID = '123456';
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`, REPORT);
        Onyx.set(`${ONYXKEYS.COLLECTION.REPORT_METADATA}${REPORT.reportID}`, REPORT_METADATA);

        return waitForBatchedUpdates()
            .then(() => {
                Report.clearCreateChatError(REPORT, CONCIERGE_REPORT_ID, INTRO_SELECTED, TEST_USER_ACCOUNT_ID, undefined, false, undefined, undefined, undefined);
                return waitForBatchedUpdates();
            })
            .then(
                () =>
                    new Promise<void>((resolve) => {
                        const connection = Onyx.connect({
                            key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`,
                            callback: (report) => {
                                Onyx.disconnect(connection);
                                resolve();

                                // The report should exist but the create chat error field should be cleared.
                                expect(report?.reportID).toBeDefined();
                                expect(report?.errorFields?.createChat).toBeUndefined();
                            },
                        });
                    }),
            );
    });

    it.each<[string, OnyxTypes.Beta[] | undefined]>([
        ['with betas', [CONST.BETAS.ALL]],
        ['without betas', undefined],
    ])('clearCreateChatError should call openReport when deleting optimistic report %s', async (_label, betas) => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@user.com';
        const REPORT: OnyxTypes.Report = {...createRandomReport(1, undefined), errorFields: {createChat: {error: 'error'}}};
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
        await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
        await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
            [CONST.ACCOUNT_ID.CONCIERGE]: {
                accountID: CONST.ACCOUNT_ID.CONCIERGE,
                login: CONST.EMAIL.CONCIERGE,
                displayName: 'Concierge',
            },
        });
        await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT.reportID}`, REPORT);
        await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_METADATA}${REPORT.reportID}`, {isOptimisticReport: true});
        await waitForBatchedUpdates();

        Report.clearCreateChatError(REPORT, undefined, INTRO_SELECTED, TEST_USER_ACCOUNT_ID, betas, false, undefined, undefined, undefined);
        await waitForBatchedUpdates();

        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
    });

    it('should update pins in Onyx when togglePinned is called', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@test.com';
        const REPORT_ID = '1';

        let reportIsPinned: boolean;
        Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`,
            callback: (val) => (reportIsPinned = val?.isPinned ?? false),
        });

        // Set up Onyx with some test user data
        return TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN)
            .then(() => {
                Report.togglePinnedState(REPORT_ID, false);
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Test that Onyx immediately updated the report pin state.
                expect(reportIsPinned).toEqual(true);
            });
    });

    it('Should not leave duplicate comments when logger sends packet because of calling process queue while processing the queue', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@test.com';
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const LOGGER_MAX_LOG_LINES = 50;

        // GIVEN a test user with initial data
        return TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN)
            .then(() => TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID))
            .then(() => {
                global.fetch = TestHelper.getGlobalFetchMock();

                // WHEN we add enough logs to send a packet
                for (let i = 0; i <= LOGGER_MAX_LOG_LINES; i++) {
                    Log.info('Test log info');
                }

                // And leave a comment on a report
                Report.addComment({
                    report: REPORT,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Testing a comment',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: TEST_USER_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });

                // Then we should expect that there is on persisted request
                expect(PersistedRequests.getAll().length).toBe(1);

                // When we wait for the queue to run
                return waitForBatchedUpdates();
            })
            .then(() => {
                // THEN only ONE call to AddComment will happen
                const URL_ARGUMENT_INDEX = 0;
                const addCommentCalls = (global.fetch as jest.Mock).mock.calls.filter((callArguments: string[]) => callArguments.at(URL_ARGUMENT_INDEX)?.includes('AddComment'));
                expect(addCommentCalls.length).toBe(1);
            });
    });

    it('should be updated correctly when new comments are added, deleted or marked as unread', () => {
        global.fetch = TestHelper.getGlobalFetchMock();
        const REPORT_ID = '1';
        let report: OnyxEntry<OnyxTypes.Report>;
        let reportActionCreatedDate: string;
        let currentTime: string;
        Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`,
            callback: (val) => (report = val),
        });

        let reportActions: OnyxTypes.ReportActions;
        Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (val) => (reportActions = val ?? {}),
        });

        const {result: ancestors, rerender} = renderHook(() => useAncestors(report));

        const USER_1_LOGIN = 'user@test.com';
        const USER_1_ACCOUNT_ID = 1;
        const USER_2_ACCOUNT_ID = 2;
        const setPromise = Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, {reportName: 'Test', reportID: REPORT_ID})
            .then(() => TestHelper.signInWithTestUser(USER_1_ACCOUNT_ID, USER_1_LOGIN))
            .then(waitForNetworkPromises)
            .then(() => {
                // Given a test user that is subscribed to Pusher events
                User.subscribeToUserEvents(USER_1_ACCOUNT_ID, USER_1_LOGIN, () => {}, undefined);
                return waitForBatchedUpdates();
            })
            .then(() => TestHelper.setPersonalDetails(USER_1_LOGIN, USER_1_ACCOUNT_ID))
            .then(() => {
                // When a Pusher event is handled for a new report comment that includes a mention of the current user
                reportActionCreatedDate = DateUtils.getDBTime();
                PusherHelper.emitOnyxUpdate([
                    {
                        onyxMethod: Onyx.METHOD.MERGE,
                        key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`,
                        value: {
                            reportID: REPORT_ID,
                            participants: {
                                [USER_1_ACCOUNT_ID]: {
                                    notificationPreference: 'always',
                                },
                            },
                            lastMessageText: 'Comment 1',
                            lastActorAccountID: USER_2_ACCOUNT_ID,
                            lastVisibleActionCreated: reportActionCreatedDate,
                            lastMentionedTime: reportActionCreatedDate,
                            lastReadTime: DateUtils.subtractMillisecondsFromDateTime(reportActionCreatedDate, 1),
                        },
                    },
                    {
                        onyxMethod: Onyx.METHOD.MERGE,
                        key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                        value: {
                            1: {
                                actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                                actorAccountID: USER_2_ACCOUNT_ID,
                                automatic: false,
                                avatar: 'https://d2k5nsl2zxldvw.cloudfront.net/images/avatars/avatar_3.png',
                                message: [{type: 'COMMENT', html: 'Comment 1', text: 'Comment 1'}],
                                person: [{type: 'TEXT', style: 'strong', text: 'Test User'}],
                                shouldShow: true,
                                created: reportActionCreatedDate,
                                reportActionID: '1',
                            },
                        },
                    },
                ]);
                return waitForNetworkPromises();
            })
            .then(() => {
                // Then the report will be unread
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(true);

                // And show a green dot for unread mentions in the LHN
                expect(ReportUtils.isUnreadWithMention(report)).toBe(true);

                // When the user visits the report
                currentTime = DateUtils.getDBTime();
                Report.openReport({hasReportActions: true, reportID: REPORT_ID, introSelected: TEST_INTRO_SELECTED, betas: undefined, currentUserAccountID: USER_1_ACCOUNT_ID});
                Report.readNewestAction(REPORT_ID, true);
                waitForBatchedUpdates();
                return waitForBatchedUpdates();
            })
            .then(() => {
                // The report will be read
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(false);
                expect(toZonedTime(report?.lastReadTime ?? '', UTC).getTime()).toBeGreaterThanOrEqual(toZonedTime(currentTime, UTC).getTime());

                // And no longer show the green dot for unread mentions in the LHN
                expect(ReportUtils.isUnreadWithMention(report)).toBe(false);

                // When the user manually marks a message as "unread"
                Report.markCommentAsUnread(REPORT_ID, reportActions, reportActions['1'], USER_1_ACCOUNT_ID, false);
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Then the report will be unread and show the green dot for unread mentions in LHN
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(true);
                expect(ReportUtils.isUnreadWithMention(report)).toBe(true);
                expect(report?.lastReadTime).toBe(DateUtils.subtractMillisecondsFromDateTime(reportActionCreatedDate, 1));

                // When a new comment is added by the current user

                currentTime = DateUtils.getDBTime();
                Report.addComment({
                    report,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Current User Comment 1',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: USER_1_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });
                return waitForBatchedUpdates();
            })
            .then(() => {
                // The report will be read, the green dot for unread mentions will go away, and the lastReadTime updated
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(false);
                expect(ReportUtils.isUnreadWithMention(report)).toBe(false);
                expect(toZonedTime(report?.lastReadTime ?? '', UTC).getTime()).toBeGreaterThanOrEqual(toZonedTime(currentTime, UTC).getTime());
                expect(report?.lastMessageText).toBe('Current User Comment 1');

                // When another comment is added by the current user
                currentTime = DateUtils.getDBTime();
                Report.addComment({
                    report,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Current User Comment 2',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: USER_1_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });
                return waitForBatchedUpdates();
            })
            .then(() => {
                // The report will be read and the lastReadTime updated
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(false);
                expect(toZonedTime(report?.lastReadTime ?? '', UTC).getTime()).toBeGreaterThanOrEqual(toZonedTime(currentTime, UTC).getTime());
                expect(report?.lastMessageText).toBe('Current User Comment 2');

                // When another comment is added by the current user
                currentTime = DateUtils.getDBTime();
                Report.addComment({
                    report,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Current User Comment 3',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: USER_1_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });
                return waitForBatchedUpdates();
            })
            .then(() => {
                // The report will be read and the lastReadTime updated
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(false);
                expect(toZonedTime(report?.lastReadTime ?? '', UTC).getTime()).toBeGreaterThanOrEqual(toZonedTime(currentTime, UTC).getTime());
                expect(report?.lastMessageText).toBe('Current User Comment 3');

                const USER_1_BASE_ACTION = {
                    actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                    actorAccountID: USER_1_ACCOUNT_ID,
                    automatic: false,
                    avatar: 'https://d2k5nsl2zxldvw.cloudfront.net/images/avatars/avatar_3.png',
                    person: [{type: 'TEXT', style: 'strong', text: 'Test User'}],
                    shouldShow: true,
                    created: DateUtils.getDBTime(Date.now() - 3),
                    reportID: REPORT_ID,
                };

                const optimisticReportActions: OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS> = {
                    onyxMethod: Onyx.METHOD.MERGE,
                    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                    value: {
                        200: {
                            ...USER_1_BASE_ACTION,
                            message: [{type: 'COMMENT', html: 'Current User Comment 1', text: 'Current User Comment 1'}],
                            created: DateUtils.getDBTime(Date.now() - 2),
                            reportActionID: '200',
                        },

                        300: {
                            ...USER_1_BASE_ACTION,
                            message: [{type: 'COMMENT', html: 'Current User Comment 2', text: 'Current User Comment 2'}],
                            created: DateUtils.getDBTime(Date.now() - 1),
                            reportActionID: '300',
                        },

                        400: {
                            ...USER_1_BASE_ACTION,
                            message: [{type: 'COMMENT', html: 'Current User Comment 3', text: 'Current User Comment 3'}],
                            created: DateUtils.getDBTime(),
                            reportActionID: '400',
                        },
                    },
                };

                reportActionCreatedDate = DateUtils.getDBTime();

                const optimisticReportActionsValue = optimisticReportActions.value as Record<string, OnyxTypes.ReportAction>;

                if (optimisticReportActionsValue?.[400]) {
                    optimisticReportActionsValue[400].created = reportActionCreatedDate;
                }

                // When we emit the events for these pending created actions to update them to not pending
                PusherHelper.emitOnyxUpdate([
                    {
                        onyxMethod: Onyx.METHOD.MERGE,
                        key: `${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`,
                        value: {
                            reportID: REPORT_ID,
                            participants: {
                                [USER_1_ACCOUNT_ID]: {
                                    notificationPreference: 'always',
                                },
                            },
                            lastMessageText: 'Current User Comment 3',
                            lastActorAccountID: 1,
                            lastVisibleActionCreated: reportActionCreatedDate,
                            lastReadTime: reportActionCreatedDate,
                        },
                    },
                    optimisticReportActions,
                ]);

                return waitForNetworkPromises();
            })
            .then(() => {
                rerender(report);
                // If the user deletes a comment that is before the last read
                Report.deleteReportComment(report, {...reportActions[200]}, undefined, ancestors.current, undefined, undefined, USER_1_LOGIN);
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Then no change will occur
                expect(report?.lastReadTime).toBe(reportActionCreatedDate);
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(false);

                // When the user manually marks a message as "unread"
                Report.markCommentAsUnread(REPORT_ID, reportActions, reportActions[400], USER_1_ACCOUNT_ID, false);
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Then we should expect the report to be to be unread
                expect(ReportUtils.isUnread(report, undefined, undefined)).toBe(true);
                expect(report?.lastReadTime).toBe(DateUtils.subtractMillisecondsFromDateTime(reportActions[400].created, 1));

                rerender(report);
                // If the user deletes the last comment after the lastReadTime the lastMessageText will reflect the new last comment
                Report.deleteReportComment(report, {...reportActions[400]}, undefined, ancestors.current, undefined, undefined, USER_1_LOGIN);
                return waitForBatchedUpdates();
            })
            .then(() => getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const))
            .then((updatedReport) => {
                expect(ReportUtils.isUnread(updatedReport, undefined, undefined)).toBe(false);
                expect(updatedReport?.lastMessageText).toBe('Current User Comment 2');
            });
        waitForBatchedUpdates(); // flushing onyx.set as it will be batched
        return setPromise;
    });

    it('Should properly update comment with links', async () => {
        /* This tests a variety of scenarios when a user edits a comment.
         * We should generate a link when editing a message unless the link was
         * already in the comment and the user deleted it on purpose.
         */

        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_LOGIN = 'test@expensify.com';

        // User edits comment to add link
        // We should generate link
        let originalCommentMarkdown = 'Original Comment';
        let afterEditCommentText = 'Original Comment www.google.com';
        let newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        let expectedOutput = 'Original Comment <a href="https://www.google.com" target="_blank" rel="noreferrer noopener">www.google.com</a>';
        expect(newCommentHTML).toBe(expectedOutput);

        // User deletes www.google.com link from comment but keeps link text
        // We should not generate link
        originalCommentMarkdown = 'Comment [www.google.com](https://www.google.com)';
        afterEditCommentText = 'Comment www.google.com';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = 'Comment www.google.com';
        expect(newCommentHTML).toBe(expectedOutput);

        // User Delete only () part of link but leaves the []
        // We should not generate link
        originalCommentMarkdown = 'Comment [www.google.com](https://www.google.com)';
        afterEditCommentText = 'Comment [www.google.com]';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = 'Comment [www.google.com]';
        expect(newCommentHTML).toBe(expectedOutput);

        // User Generates multiple links in one edit
        // We should generate both links
        originalCommentMarkdown = 'Comment';
        afterEditCommentText = 'Comment www.google.com www.facebook.com';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput =
            'Comment <a href="https://www.google.com" target="_blank" rel="noreferrer noopener">www.google.com</a> ' +
            '<a href="https://www.facebook.com" target="_blank" rel="noreferrer noopener">www.facebook.com</a>';
        expect(newCommentHTML).toBe(expectedOutput);

        // Comment has two links but user deletes only one of them
        // Should not generate link again for the deleted one
        originalCommentMarkdown = 'Comment [www.google.com](https://www.google.com)  [www.facebook.com](https://www.facebook.com)';
        afterEditCommentText = 'Comment www.google.com  [www.facebook.com](https://www.facebook.com)';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = 'Comment www.google.com  <a href="https://www.facebook.com" target="_blank" rel="noreferrer noopener">www.facebook.com</a>';
        expect(newCommentHTML).toBe(expectedOutput);

        // User edits and replaces comment with a link containing underscores
        // We should generate link
        originalCommentMarkdown = 'Comment';
        afterEditCommentText = 'https://www.facebook.com/hashtag/__main/?__eep__=6';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = '<a href="https://www.facebook.com/hashtag/__main/?__eep__=6" target="_blank" rel="noreferrer noopener">https://www.facebook.com/hashtag/__main/?__eep__=6</a>';
        expect(newCommentHTML).toBe(expectedOutput);

        // User edits and deletes the link containing underscores
        // We should not generate link
        originalCommentMarkdown = '[https://www.facebook.com/hashtag/__main/?__eep__=6](https://www.facebook.com/hashtag/__main/?__eep__=6)';
        afterEditCommentText = 'https://www.facebook.com/hashtag/__main/?__eep__=6';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = 'https://www.facebook.com/hashtag/__main/?__eep__=6';
        expect(newCommentHTML).toBe(expectedOutput);

        // User edits and replaces comment with a link containing asterisks
        // We should generate link
        originalCommentMarkdown = 'Comment';
        afterEditCommentText = 'http://example.com/foo/*/bar/*/test.txt';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = '<a href="http://example.com/foo/*/bar/*/test.txt" target="_blank" rel="noreferrer noopener">http://example.com/foo/*/bar/*/test.txt</a>';
        expect(newCommentHTML).toBe(expectedOutput);

        // User edits and deletes the link containing asterisks
        // We should not generate link
        originalCommentMarkdown = '[http://example.com/foo/*/bar/*/test.txt](http://example.com/foo/*/bar/*/test.txt)';
        afterEditCommentText = 'http://example.com/foo/*/bar/*/test.txt';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {});
        expectedOutput = 'http://example.com/foo/*/bar/*/test.txt';
        expect(newCommentHTML).toBe(expectedOutput);

        // User edits comment to add mention
        // We should generate mention-user tag
        const privateDomainAccount = {
            accountID: 2,
            login: 'user@expensify.com',
            email: 'user@expensify.com',
        };
        await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
            [privateDomainAccount.accountID]: privateDomainAccount,
        });
        originalCommentMarkdown = 'Comment';
        afterEditCommentText = 'Comment @user';
        newCommentHTML = Report.handleUserDeletedLinksInHtml(afterEditCommentText, originalCommentMarkdown, TEST_USER_LOGIN, {
            [privateDomainAccount.accountID]: privateDomainAccount,
        });
        expectedOutput = 'Comment <mention-user>@user@expensify.com</mention-user>';
        expect(newCommentHTML).toBe(expectedOutput);
    });

    it('should show a notification for report action updates with shouldNotify', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@user.com';
        const REPORT_ID = '1';
        const REPORT_ACTION = {
            actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
        };

        // Setup user and pusher listeners
        return TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN)
            .then(waitForBatchedUpdates)
            .then(() => {
                User.subscribeToUserEvents(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN, () => {}, undefined);
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Simulate a Pusher Onyx update with a report action with shouldNotify
                PusherHelper.emitOnyxUpdate([
                    {
                        onyxMethod: Onyx.METHOD.MERGE,
                        key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                        value: {
                            1: REPORT_ACTION,
                        },
                        shouldNotify: true,
                    },
                ]);
                return SequentialQueue.getCurrentRequest().then(waitForBatchedUpdates);
            })
            .then(() => {
                // Ensure we show a notification for this new report action
                expect(Report.showReportActionNotification).toBeCalledWith(REPORT_ID, REPORT_ACTION, undefined, TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN, undefined);
            });
    });

    it('should properly toggle reactions on a message', () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@test.com';
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const EMOJI_CODE = '👍';
        const EMOJI_SKIN_TONE = 2;
        const EMOJI_NAME = '+1';
        const EMOJI = {
            code: EMOJI_CODE,
            name: EMOJI_NAME,
            hexcode: '1F44D',
            types: ['👍🏿', '👍🏾', '👍🏽', '👍🏼', '👍🏻'],
        };

        let reportActions: OnyxTypes.ReportActions;
        Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (val) => (reportActions = val ?? {}),
        });
        const reportActionsReactions: OnyxCollection<OnyxTypes.ReportActionReactions> = {};
        Onyx.connect({
            key: ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS,
            callback: (val, key) => {
                reportActionsReactions[key] = val ?? {};
            },
        });
        let reportAction: OnyxTypes.ReportAction | undefined;
        let reportActionID: string | undefined;

        // Set up Onyx with some test user data
        return TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN)
            .then(() => {
                User.subscribeToUserEvents(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN, () => {}, undefined);
                return waitForBatchedUpdates();
            })
            .then(() => TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID))
            .then(() => {
                // This is a fire and forget response, but once it completes we should be able to verify that we
                // have an "optimistic" report action in Onyx.
                Report.addComment({
                    report: REPORT,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Testing a comment',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: TEST_USER_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });
                return waitForBatchedUpdates();
            })
            .then(() => {
                reportAction = Object.values(reportActions).at(0);
                reportActionID = reportAction?.reportActionID;

                if (reportAction) {
                    // Add a reaction to the comment
                    toggleEmojiReaction(REPORT_ID, reportAction, EMOJI, reportActionsReactions[0], CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
                }
                return waitForBatchedUpdates();
            })
            .then(() => {
                reportAction = Object.values(reportActions).at(0);

                // Expect the reaction to exist in the reportActionsReactions collection
                expect(reportActionsReactions).toHaveProperty(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`);

                // Expect the reaction to have the emoji on it
                const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`];
                expect(reportActionReaction).toHaveProperty(EMOJI.name);

                // Expect the emoji to have the user accountID
                const reportActionReactionEmoji = reportActionReaction?.[EMOJI.name];
                expect(reportActionReactionEmoji?.users).toHaveProperty(`${TEST_USER_ACCOUNT_ID}`);

                if (reportAction) {
                    // Now we remove the reaction
                    toggleEmojiReaction(REPORT_ID, reportAction, EMOJI, reportActionReaction, CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
                }
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Expect the reaction to have null where the users reaction used to be
                expect(reportActionsReactions).toHaveProperty(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`);
                const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`];
                expect(reportActionReaction?.[EMOJI.name].users[TEST_USER_ACCOUNT_ID]).toBeUndefined();
            })
            .then(() => {
                reportAction = Object.values(reportActions).at(0);

                if (reportAction) {
                    // Add the same reaction to the same report action with a different skin tone
                    toggleEmojiReaction(REPORT_ID, reportAction, EMOJI, reportActionsReactions[0], CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
                }
                return waitForBatchedUpdates()
                    .then(() => {
                        reportAction = Object.values(reportActions).at(0);

                        const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`];
                        if (reportAction) {
                            toggleEmojiReaction(REPORT_ID, reportAction, EMOJI, reportActionReaction, EMOJI_SKIN_TONE, TEST_USER_ACCOUNT_ID);
                        }
                        return waitForBatchedUpdates();
                    })
                    .then(() => {
                        reportAction = Object.values(reportActions).at(0);

                        // Expect the reaction to exist in the reportActionsReactions collection
                        expect(reportActionsReactions).toHaveProperty(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`);

                        // Expect the reaction to have the emoji on it
                        const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`];
                        expect(reportActionReaction).toHaveProperty(EMOJI.name);

                        // Expect the emoji to have the user accountID
                        const reportActionReactionEmoji = reportActionReaction?.[EMOJI.name];
                        expect(reportActionReactionEmoji?.users).toHaveProperty(`${TEST_USER_ACCOUNT_ID}`);

                        // Expect two different skin tone reactions
                        const reportActionReactionEmojiUserSkinTones = reportActionReactionEmoji?.users[TEST_USER_ACCOUNT_ID].skinTones;
                        expect(reportActionReactionEmojiUserSkinTones).toHaveProperty('-1');
                        expect(reportActionReactionEmojiUserSkinTones).toHaveProperty('2');

                        if (reportAction) {
                            // Now we remove the reaction, and expect that both variations are removed
                            toggleEmojiReaction(REPORT_ID, reportAction, EMOJI, reportActionReaction, CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
                        }
                        return waitForBatchedUpdates();
                    })
                    .then(() => {
                        // Expect the reaction to have null where the users reaction used to be
                        expect(reportActionsReactions).toHaveProperty(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`);
                        const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${reportActionID}`];
                        expect(reportActionReaction?.[EMOJI.name].users[TEST_USER_ACCOUNT_ID]).toBeUndefined();
                    });
            });
    });

    it("shouldn't add the same reaction twice when changing preferred skin color and reaction doesn't support skin colors", () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@test.com';
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const EMOJI_CODE = '😄';
        const EMOJI_NAME = 'smile';
        const EMOJI = {
            code: EMOJI_CODE,
            name: EMOJI_NAME,
            hexcode: '1F604',
        };

        let reportActions: OnyxTypes.ReportActions = {};
        Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (val) => (reportActions = val ?? {}),
        });
        const reportActionsReactions: OnyxCollection<OnyxTypes.ReportActionReactions> = {};
        Onyx.connect({
            key: ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS,
            callback: (val, key) => {
                reportActionsReactions[key] = val ?? {};
            },
        });

        let resultAction: OnyxTypes.ReportAction | undefined;

        // Set up Onyx with some test user data
        return TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN)
            .then(() => {
                User.subscribeToUserEvents(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN, () => {}, undefined);
                return waitForBatchedUpdates();
            })
            .then(() => TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID))
            .then(() => {
                // This is a fire and forget response, but once it completes we should be able to verify that we
                // have an "optimistic" report action in Onyx.
                Report.addComment({
                    report: REPORT,
                    notifyReportID: REPORT_ID,
                    ancestors: [],
                    text: 'Testing a comment',
                    timezoneParam: CONST.DEFAULT_TIME_ZONE,
                    currentUserAccountID: TEST_USER_ACCOUNT_ID,
                    delegateAccountID: undefined,
                    conciergeReportID: undefined,
                });
                return waitForBatchedUpdates();
            })
            .then(() => {
                resultAction = Object.values(reportActions).at(0);

                if (resultAction) {
                    // Add a reaction to the comment
                    toggleEmojiReaction(REPORT_ID, resultAction, EMOJI, {}, CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
                }
                return waitForBatchedUpdates();
            })
            .then(() => {
                resultAction = Object.values(reportActions).at(0);

                // Now we toggle the reaction while the skin tone has changed.
                // As the emoji doesn't support skin tones, the emoji
                // should get removed instead of added again.
                const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${resultAction?.reportActionID}`];
                if (resultAction) {
                    toggleEmojiReaction(REPORT_ID, resultAction, EMOJI, reportActionReaction, 2, TEST_USER_ACCOUNT_ID);
                }
                return waitForBatchedUpdates();
            })
            .then(() => {
                // Expect the reaction to have null where the users reaction used to be
                expect(reportActionsReactions).toHaveProperty(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${resultAction?.reportActionID}`);
                const reportActionReaction = reportActionsReactions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS_REACTIONS}${resultAction?.reportActionID}`];
                expect(reportActionReaction?.[EMOJI.name].users[TEST_USER_ACCOUNT_ID]).toBeUndefined();
            });
    });

    it('should send only one OpenReport, replacing any extra ones with same reportIDs', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const REPORT_ID = '1';

        setHasRadio(false);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        for (let i = 0; i < 5; i++) {
            Report.openReport({
                hasReportActions: true,
                reportID: REPORT_ID,
                introSelected: TEST_INTRO_SELECTED,
                participants: [{login: 'test@user.com'}],
                betas: undefined,
                newReportObject: {
                    reportID: REPORT_ID,
                },
                currentUserAccountID: 1,
            });
        }

        expect(PersistedRequests.getAll().length).toBe(1);

        await waitForBatchedUpdates();
        setHasRadio(true);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
    });

    it('should not optimistically inject default report name when report has no known name', async () => {
        const REPORT_ID = 'openReport_noKnownName';

        setHasRadio(false);
        await waitForBatchedUpdates();

        Report.openReport({hasReportActions: true, reportID: REPORT_ID, introSelected: undefined, betas: undefined, currentUserAccountID: 1});
        await waitForBatchedUpdates();

        const report = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`);
        expect(report?.reportName).toBeUndefined();

        setHasRadio(true);
        await waitForBatchedUpdates();
    });

    it('should keep optimistic new report write on report collection key', async () => {
        const REPORT_ID = 'openReport_newReportOptimistic';

        setHasRadio(false);
        await waitForBatchedUpdates();

        Report.openReport({
            hasReportActions: true,
            reportID: REPORT_ID,
            introSelected: undefined,
            betas: undefined,
            newReportObject: {
                reportID: REPORT_ID,
            },
            currentUserAccountID: 1,
        });
        await waitForBatchedUpdates();

        const report = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`);
        expect(report).toMatchObject({
            reportID: REPORT_ID,
            reportName: CONST.REPORT.DEFAULT_REPORT_NAME,
        });

        const loadingState = await getOnyxValue(`${ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE}${REPORT_ID}`);
        expect(loadingState).not.toHaveProperty('reportID');
        expect(loadingState).not.toHaveProperty('reportName');

        setHasRadio(true);
        await waitForBatchedUpdates();
    });

    it('openReport legacy preview fallback stores action under correct Onyx key and preserves existing actions', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@user.com';
        const SELF_DM_ID = '555';
        const CHILD_REPORT_ID = '9999';
        const TXN_ID = 'txn_123';

        // Sign in and set personal details
        await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
        await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);

        // Seed a self-DM report
        await Onyx.merge(
            `${ONYXKEYS.COLLECTION.REPORT}${SELF_DM_ID}`,
            createMock<OnyxTypes.Report>({
                reportID: SELF_DM_ID,
                chatType: CONST.REPORT.CHAT_TYPE.SELF_DM,
            }),
        );

        // Seed an existing action in self DM to ensure MERGE does not overwrite
        await Onyx.merge(
            `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SELF_DM_ID}`,
            createMock<OnyxTypes.ReportActions>({
                123: {
                    actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                    message: [{type: 'COMMENT', html: 'Existing', text: 'Existing'}],
                    reportActionID: '123',
                    created: DateUtils.getDBTime(),
                },
            }),
        );

        // Seed a legacy transaction (no parentReportActionID)
        await Onyx.merge(
            `${ONYXKEYS.COLLECTION.TRANSACTION}${TXN_ID}`,
            createMock<OnyxTypes.Transaction>({
                transactionID: TXN_ID,
                amount: -101,
                currency: CONST.CURRENCY.USD,
                comment: {comment: 'Legacy expense'},
            }),
        );

        // Get the transaction object from Onyx
        const transaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${TXN_ID}` as const);
        expect(transaction).toBeTruthy();

        Report.openReport({
            hasReportActions: true,
            reportID: CHILD_REPORT_ID,
            introSelected: undefined,
            betas: undefined,
            transaction: transaction ?? undefined,
            parentReportID: SELF_DM_ID,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
        });
        await waitForBatchedUpdates();

        // Validate the correct Onyx key received the new action and existing one is preserved
        const selfDMActions = (await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SELF_DM_ID}` as const)) as OnyxTypes.ReportActions | undefined;
        expect(selfDMActions).toBeTruthy();
        // Existing action still present
        expect(selfDMActions?.['123']).toBeTruthy();

        // Derive the created parentReportActionID from the self DM actions by finding the one that links to the child report
        const entries = Object.entries(selfDMActions ?? {}) as Array<[string, OnyxTypes.ReportAction]>;
        const createdEntry = entries.find((tuple): tuple is [string, OnyxTypes.ReportAction] => tuple?.[1]?.childReportID === CHILD_REPORT_ID);
        expect(createdEntry).toBeDefined();
        // Type guard for TS; the expect above will fail the test if undefined
        if (!createdEntry) {
            return;
        }
        const [parentReportActionID, createdAction] = createdEntry;
        expect(createdAction.childReportID).toBe(CHILD_REPORT_ID);

        // Ensure we did not create a stray concatenated key like reportActions_<selfDMReportID><generatedActionID>
        const wrongKeyValue = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SELF_DM_ID}${parentReportActionID}` as const);
        expect(wrongKeyValue).toBeUndefined();

        // The API call should include moneyRequestPreviewReportActionID matching the created action
        TestHelper.expectAPICommandToHaveBeenCalledWith(WRITE_COMMANDS.OPEN_REPORT, 0, {
            reportID: CHILD_REPORT_ID,
            moneyRequestPreviewReportActionID: parentReportActionID,
        });
    });

    it('should replace duplicate OpenReport commands with the same reportID', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const REPORT_ID = '1';

        setHasRadio(false);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        for (let i = 0; i < 8; i++) {
            let reportID = REPORT_ID;
            if (i > 4) {
                reportID = `${i}`;
            }
            Report.openReport({
                hasReportActions: true,
                reportID,
                introSelected: TEST_INTRO_SELECTED,
                participants: [{login: 'test@user.com'}],
                betas: undefined,
                newReportObject: {
                    reportID: REPORT_ID,
                },
                currentUserAccountID: 1,
            });
        }

        expect(PersistedRequests.getAll().length).toBe(4);

        await waitForBatchedUpdates();
        setHasRadio(true);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 4);
    });

    it('should remove AddComment and UpdateComment without sending any request when DeleteComment is set', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(false);

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Testing a comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        // Need the reportActionID to delete the comments
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const newReportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);
        const originalReport = {
            reportID: REPORT_ID,
        };

        const {result: ancestors, rerender} = renderHook(() => useAncestors(originalReport));
        Report.editReportComment(originalReport, newReportAction, 'Testing an edited comment', undefined, '', undefined);

        await waitForBatchedUpdates();

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persistedRequests) => {
                    Onyx.disconnect(connection);

                    expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_COMMENT);
                    expect(persistedRequests?.at(1)?.command).toBeUndefined();

                    resolve();
                },
            });
        });

        // Checking the Report Action exists before deleting it
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                callback: (reportActions) => {
                    Onyx.disconnect(connection);

                    const reportAction = reportActionID ? reportActions?.[reportActionID] : null;
                    expect(reportAction).not.toBeNull();
                    expect(reportAction?.reportActionID).toBe(reportActionID);
                    resolve();
                },
            });
        });

        rerender(originalReport);
        Report.deleteReportComment(originalReport, newReportAction, undefined, ancestors.current, undefined, undefined, '');

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(0);

        // Checking the Report Action doesn't exist after deleting it
        const connection = Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (reportActions) => {
                Onyx.disconnect(connection);
                const reportAction = reportActionID ? reportActions?.[reportActionID] : undefined;
                expect(reportAction).toBeUndefined();
            },
        });

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_COMMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 0);
    });

    it('should remove AddComment and UpdateComment without sending any request when DeleteComment is set with currentUserEmail', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const created = format(addSeconds(subMinutes(new Date(), 10), 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(false);
        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Testing a comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        const reportActionID = PersistedRequests.getAll().at(0)?.data?.reportActionID as string | undefined;
        const newReportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);
        const originalReport = {reportID: REPORT_ID};
        const {result: ancestors, rerender} = renderHook(() => useAncestors(originalReport));

        const currentUserEmail = 'test@test.com';
        Report.editReportComment(originalReport, newReportAction, 'Testing an edited comment', undefined, currentUserEmail, undefined);
        await waitForBatchedUpdates();

        const persistedRequests = await getOnyxValue(ONYXKEYS.PERSISTED_REQUESTS);
        expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_COMMENT);

        rerender(originalReport);
        Report.deleteReportComment(originalReport, newReportAction, undefined, ancestors.current, undefined, undefined, currentUserEmail);
        await waitForBatchedUpdates();

        expect(PersistedRequests.getAll().length).toBe(0);
        setHasRadio(true);
        await waitForBatchedUpdates();

        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_COMMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 0);
    });

    it('should send DeleteComment request and remove UpdateComment accordingly', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(true);
        await waitForBatchedUpdates();

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Testing a comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        await waitForBatchedUpdates();

        // Need the reportActionID to delete the comments — read before the queue processes the request
        const newComment = PersistedRequests.getAll().at(1);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const reportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        // Let the queue process the online ADD_COMMENT request before going offline.
        // setHasRadio(false) calls pause() synchronously, which blocks processing immediately.
        await waitForBatchedUpdates();

        setHasRadio(false);
        await waitForBatchedUpdates();

        const originalReport = {
            reportID: REPORT_ID,
        };
        const {result: ancestors, rerender} = renderHook(() => useAncestors(originalReport));

        Report.editReportComment(originalReport, reportAction, 'Testing an edited comment', undefined, '', undefined);

        await waitForBatchedUpdates();

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persistedRequests) => {
                    Onyx.disconnect(connection);
                    expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.UPDATE_COMMENT);
                    resolve();
                },
            });
        });

        rerender(originalReport);
        Report.deleteReportComment(originalReport, reportAction, undefined, ancestors.current, undefined, undefined, '');

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(1);

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_COMMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 1);
    });

    it('should send DeleteComment request after AddComment is rollback', async () => {
        global.fetch = jest.fn().mockRejectedValue(new TypeError(CONST.ERROR.FAILED_TO_FETCH));

        const mockedXhr = jest.fn();
        mockedXhr.mockImplementation(originalXHR);

        HttpUtils.xhr = mockedXhr;
        await waitForBatchedUpdates();
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Testing a comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });
        await waitForNetworkPromises();

        expect(PersistedRequests.getAll().length).toBe(1);
        expect(PersistedRequests.getAll().at(0)?.isRollback).toBeTruthy();
        const newComment = PersistedRequests.getAll().at(1);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const reportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        await waitForBatchedUpdates();
        HttpUtils.xhr = mockedXhr
            .mockImplementationOnce(() =>
                Promise.resolve({
                    jsonCode: CONST.JSON_CODE.EXP_ERROR,
                }),
            )
            .mockImplementation(() =>
                Promise.resolve({
                    jsonCode: CONST.JSON_CODE.SUCCESS,
                }),
            );

        Report.deleteReportComment(REPORT, reportAction, undefined, [], undefined, undefined, '');

        jest.runOnlyPendingTimers();
        await waitForBatchedUpdates();

        const httpCalls = (HttpUtils.xhr as jest.Mock).mock.calls;

        const addCommentCalls = httpCalls.filter(([command]) => command === 'AddComment');
        const deleteCommentCalls = httpCalls.filter(([command]) => command === 'DeleteComment');

        if (httpCalls.length === 3) {
            expect(addCommentCalls).toHaveLength(2);
            expect(deleteCommentCalls).toHaveLength(1);
        }
    });

    it('should send not DeleteComment request and remove AddAttachment accordingly', async () => {
        global.fetch = TestHelper.getGlobalFetchMock({
            headers: new Headers({
                'Content-Type': 'image/jpeg',
            }),
        });

        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(false);
        await waitForBatchedUpdates();

        const file = new File([''], 'test.txt', {type: 'text/plain'});
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        Report.addAttachmentWithComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            attachments: file,
            currentUserAccountID: 1,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        // Need the reportActionID to delete the comments
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const newReportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        // wait for Onyx.connect execute the callback and start processing the queue
        await waitForBatchedUpdates();

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persistedRequests) => {
                    Onyx.disconnect(connection);
                    expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_ATTACHMENT);
                    resolve();
                },
            });
        });

        // Checking the Report Action exists before deleting it
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                callback: (reportActions) => {
                    Onyx.disconnect(connection);
                    const reportAction = reportActionID ? reportActions?.[reportActionID] : null;
                    expect(reportAction).not.toBeNull();
                    expect(reportAction?.reportActionID).toBe(reportActionID);
                    resolve();
                },
            });
        });

        Report.deleteReportComment(REPORT, newReportAction, undefined, [], undefined, undefined, '');

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(0);

        // Checking the Report Action doesn't exist after deleting it
        const connection = Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (reportActions) => {
                Onyx.disconnect(connection);
                const reportAction = reportActionID ? reportActions?.[reportActionID] : undefined;
                expect(reportAction).toBeUndefined();
            },
        });

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_ATTACHMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 0);
    });

    it('should send not DeleteComment request and remove AddTextAndAttachment accordingly', async () => {
        global.fetch = TestHelper.getGlobalFetchMock({
            headers: new Headers({
                'Content-Type': 'image/jpeg',
            }),
        });

        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);
        const file = new File([''], 'test.txt', {type: 'text/plain'});

        setHasRadio(false);
        await waitForBatchedUpdates();

        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        Report.addAttachmentWithComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            attachments: file,
            currentUserAccountID: 1,
            text: 'Attachment with comment',
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        // Need the reportActionID to delete the comments
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const newReportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        // wait for Onyx.connect execute the callback and start processing the queue
        await waitForBatchedUpdates();

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persistedRequests) => {
                    Onyx.disconnect(connection);
                    expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_TEXT_AND_ATTACHMENT);
                    resolve();
                },
            });
        });

        // Checking the Report Action exists before deleting it
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                callback: (reportActions) => {
                    Onyx.disconnect(connection);
                    const reportAction = reportActionID ? reportActions?.[reportActionID] : null;
                    expect(reportAction).not.toBeNull();
                    expect(reportAction?.reportActionID).toBe(reportActionID);
                    resolve();
                },
            });
        });

        Report.deleteReportComment(REPORT, newReportAction, undefined, [], undefined, undefined, '');

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(0);

        // Checking the Report Action doesn't exist after deleting it
        const connection = Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (reportActions) => {
                Onyx.disconnect(connection);
                const reportAction = reportActionID ? reportActions?.[reportActionID] : undefined;
                expect(reportAction).toBeUndefined();
            },
        });

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_TEXT_AND_ATTACHMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 0);
    });

    it('should post text + attachment as first action then attachment only for remaining attachments when adding multiple attachments with a comment', async () => {
        global.fetch = TestHelper.getGlobalFetchMock({
            headers: new Headers({
                'Content-Type': 'image/jpeg',
            }),
        });
        const playSoundMock = playSound as jest.MockedFunction<typeof playSound>;
        setHasRadio(false);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        const relevantPromise = new Promise((resolve) => {
            const conn = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persisted) => {
                    const relevant = (persisted ?? []).filter((r) => r?.command === WRITE_COMMANDS.ADD_ATTACHMENT || r?.command === WRITE_COMMANDS.ADD_TEXT_AND_ATTACHMENT);
                    if (relevant.length >= 3) {
                        Onyx.disconnect(conn);
                        resolve(relevant);
                    }
                },
            });
        });

        const REPORT_ID = '1';
        const shouldPlaySound = true;
        const fileA = new File(['a'], 'a.txt', {type: 'text/plain'});
        const fileB = new File(['b'], 'b.txt', {type: 'text/plain'});
        const fileC = new File(['c'], 'c.txt', {type: 'text/plain'});

        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        Report.addAttachmentWithComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            attachments: [fileA, fileB, fileC],
            currentUserAccountID: 1,
            text: 'Hello world',
            timezone: CONST.DEFAULT_TIME_ZONE,
            shouldPlaySound,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });
        const relevant = (await relevantPromise) as OnyxTypes.AnyRequest[];

        expect(playSoundMock).toHaveBeenCalledTimes(1);
        expect(playSoundMock).toHaveBeenCalledWith(SOUNDS.DONE);
        expect(relevant.at(0)?.command).toBe(WRITE_COMMANDS.ADD_TEXT_AND_ATTACHMENT);
        expect(relevant.slice(1).every((r) => r.command === WRITE_COMMANDS.ADD_ATTACHMENT)).toBe(true);
    });

    it('should create attachment only actions when adding multiple attachments without a comment', async () => {
        global.fetch = TestHelper.getGlobalFetchMock({
            headers: new Headers({
                'Content-Type': 'image/jpeg',
            }),
        });
        const playSoundMock = playSound as jest.MockedFunction<typeof playSound>;
        setHasRadio(false);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        const relevantPromise = new Promise((resolve) => {
            const conn = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persisted) => {
                    const relevant = (persisted ?? []).filter((r) => r?.command === WRITE_COMMANDS.ADD_ATTACHMENT || r?.command === WRITE_COMMANDS.ADD_TEXT_AND_ATTACHMENT);
                    if (relevant.length >= 2) {
                        Onyx.disconnect(conn);
                        resolve(relevant);
                    }
                },
            });
        });

        const REPORT_ID = '1';
        const shouldPlaySound = true;
        const fileA = new File(['a'], 'a.txt', {type: 'text/plain'});
        const fileB = new File(['b'], 'b.txt', {type: 'text/plain'});

        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        Report.addAttachmentWithComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            attachments: [fileA, fileB],
            currentUserAccountID: 1,
            timezone: CONST.DEFAULT_TIME_ZONE,
            shouldPlaySound,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });
        const relevant = (await relevantPromise) as OnyxTypes.AnyRequest[];

        expect(playSoundMock).toHaveBeenCalledTimes(1);
        expect(playSoundMock).toHaveBeenCalledWith(SOUNDS.DONE);
        expect(relevant.at(0)?.command).toBe(WRITE_COMMANDS.ADD_ATTACHMENT);
        expect(relevant.slice(1).every((r) => r.command === WRITE_COMMANDS.ADD_ATTACHMENT)).toBe(true);
        expect(relevant.some((r) => r.command === WRITE_COMMANDS.ADD_TEXT_AND_ATTACHMENT)).toBe(false);
    });

    it('should create attachment only action & not play sound when adding attachment without a comment & shouldPlaySound not passed', async () => {
        global.fetch = TestHelper.getGlobalFetchMock({
            headers: new Headers({
                'Content-Type': 'image/jpeg',
            }),
        });
        const playSoundMock = playSound as jest.MockedFunction<typeof playSound>;
        setHasRadio(false);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        const relevantPromise = new Promise((resolve) => {
            const conn = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persisted) => {
                    const relevant = (persisted ?? []).filter((r) => r?.command === WRITE_COMMANDS.ADD_ATTACHMENT);
                    if (relevant.length >= 1) {
                        Onyx.disconnect(conn);
                        resolve(relevant);
                    }
                },
            });
        });

        const REPORT_ID = '1';
        const file = new File(['a'], 'a.txt', {type: 'text/plain'});

        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        Report.addAttachmentWithComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            attachments: file,
            currentUserAccountID: 1,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });
        const relevant = (await relevantPromise) as OnyxTypes.AnyRequest[];

        expect(playSoundMock).toHaveBeenCalledTimes(0);
        expect(relevant.at(0)?.command).toBe(WRITE_COMMANDS.ADD_ATTACHMENT);
    });

    it('should optimistically mark an unresolved ACTIONABLE_MENTION_WHISPER as deleted when its parent comment is deleted', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const REPORT_ID = '1';
        const COMMENT_ACTION_ID = '1000';
        const WHISPER_ACTION_ID = '1001'; // backend creates ACTIONABLE_MENTION_WHISPER at parentCommentID + 1
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);

        // Seed Onyx with a report action and an unresolved ACTIONABLE_MENTION_WHISPER
        await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
            [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                [COMMENT_ACTION_ID]: {
                    reportActionID: COMMENT_ACTION_ID,
                    reportID: REPORT_ID,
                    actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                    created: '2024-11-19 08:04:13.728',
                    message: [{html: '@someone', text: '@someone', type: 'COMMENT', whisperedTo: []}],
                    originalMessage: {html: '@someone', whisperedTo: []},
                    pendingAction: null,
                },
                [WHISPER_ACTION_ID]: {
                    reportActionID: WHISPER_ACTION_ID,
                    reportID: REPORT_ID,
                    actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                    created: '2024-11-19 08:04:13.730',
                    originalMessage: {inviteeAccountIDs: [123], inviteeEmails: ['test@example.com'], whisperedTo: [1]},
                },
            },
        });
        await waitForBatchedUpdates();

        const commentAction = createMock<OnyxTypes.ReportAction>({
            reportActionID: COMMENT_ACTION_ID,
            reportID: REPORT_ID,
            actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
            created: '2024-11-19 08:04:13.728',
            message: [{html: '@someone', text: '@someone', type: 'COMMENT', whisperedTo: []}],
        });

        const reportActionsForReport = {
            [COMMENT_ACTION_ID]: commentAction,
            [WHISPER_ACTION_ID]: createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                originalMessage: {inviteeAccountIDs: [123], inviteeEmails: ['test@example.com'], whisperedTo: [1]},
            }),
        };

        Report.deleteReportComment(REPORT, commentAction, reportActionsForReport, [], undefined, undefined, '', undefined);
        await waitForBatchedUpdates();

        const reportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}` as const);
        const whisper = reportActions?.[WHISPER_ACTION_ID];
        expect(getOriginalMessage(whisper)).toMatchObject({deleted: expect.any(String)});
    });

    it('should only delete the whisper linked to the deleted comment, not other whispers in the same report', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const REPORT_ID = '1';
        // Two comments, each triggering a whisper at parentID + 1
        const COMMENT_A_ID = '1000'; // triggers ACTIONABLE_MENTION_WHISPER at 1001
        const WHISPER_A_ID = '1001';
        const COMMENT_B_ID = '2000'; // triggers ACTIONABLE_MENTION_WHISPER at 2001
        const WHISPER_B_ID = '2001';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);

        await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
            [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                [COMMENT_A_ID]: {
                    reportActionID: COMMENT_A_ID,
                    reportID: REPORT_ID,
                    actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                    created: '2024-11-19 08:04:13.728',
                    message: [{html: '@someone', text: '@someone', type: 'COMMENT', whisperedTo: []}],
                },
                [WHISPER_A_ID]: {
                    reportActionID: WHISPER_A_ID,
                    reportID: REPORT_ID,
                    actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                    created: '2024-11-19 08:04:13.730',
                    originalMessage: {inviteeAccountIDs: [111], inviteeEmails: ['a@example.com'], whisperedTo: [1]},
                },
                [COMMENT_B_ID]: {
                    reportActionID: COMMENT_B_ID,
                    reportID: REPORT_ID,
                    actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                    created: '2024-11-19 08:05:00.000',
                    message: [{html: '@another', text: '@another', type: 'COMMENT', whisperedTo: []}],
                },
                [WHISPER_B_ID]: {
                    reportActionID: WHISPER_B_ID,
                    reportID: REPORT_ID,
                    actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                    created: '2024-11-19 08:05:00.002',
                    originalMessage: {inviteeAccountIDs: [222], inviteeEmails: ['b@example.com'], whisperedTo: [1]},
                },
            },
        });
        await waitForBatchedUpdates();

        const commentBAction = createMock<OnyxTypes.ReportAction>({
            reportActionID: COMMENT_B_ID,
            reportID: REPORT_ID,
            actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
            created: '2024-11-19 08:05:00.000',
            message: [{html: '@another', text: '@another', type: 'COMMENT', whisperedTo: []}],
        });

        const reportActionsForReport = {
            [COMMENT_A_ID]: createMock<OnyxTypes.ReportAction>({
                reportActionID: COMMENT_A_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
                created: '2024-11-19 08:04:13.728',
            }),
            [WHISPER_A_ID]: createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_A_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                originalMessage: {inviteeAccountIDs: [111], inviteeEmails: ['a@example.com'], whisperedTo: [1]},
            }),
            [COMMENT_B_ID]: commentBAction,
            [WHISPER_B_ID]: createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_B_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:05:00.002',
                originalMessage: {inviteeAccountIDs: [222], inviteeEmails: ['b@example.com'], whisperedTo: [1]},
            }),
        };

        // Delete comment B — only whisper B (at commentB + 1) should be marked deleted
        Report.deleteReportComment(REPORT, commentBAction, reportActionsForReport, [], undefined, undefined, '', undefined);
        await waitForBatchedUpdates();

        const reportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}` as const);
        expect(getOriginalMessage(reportActions?.[WHISPER_B_ID])).toMatchObject({deleted: expect.any(String)});
        // Whisper A must NOT be touched
        expect(getOriginalMessage(reportActions?.[WHISPER_A_ID])).not.toMatchObject({deleted: expect.any(String)});
    });

    it('should not send DeleteComment request and remove any Reactions accordingly', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();
        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
        jest.doMock('@libs/EmojiUtils', () => ({
            ...jest.requireActual('@libs/EmojiUtils'),
            hasAccountIDEmojiReacted: jest.fn(() => true),
        }));
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(false);
        await waitForBatchedUpdates();
        await Promise.resolve();

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'reactions with comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        // Need the reportActionID to delete the comments
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const newReportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        await waitForBatchedUpdates();

        toggleEmojiReaction(REPORT_ID, newReportAction, {name: 'smile', code: '😄', hexcode: '1F604'}, {}, CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
        toggleEmojiReaction(
            REPORT_ID,
            newReportAction,
            {name: 'smile', code: '😄', hexcode: '1F604'},
            {
                smile: {
                    createdAt: '2024-10-14 14:58:12',
                    oldestTimestamp: '2024-10-14 14:58:12',
                    users: {
                        [`${TEST_USER_ACCOUNT_ID}`]: {
                            id: `${TEST_USER_ACCOUNT_ID}`,
                            oldestTimestamp: '2024-10-14 14:58:12',
                            skinTones: {
                                '-1': '2024-10-14 14:58:12',
                            },
                        },
                    },
                },
            },
            CONST.EMOJI_DEFAULT_SKIN_TONE,
            TEST_USER_ACCOUNT_ID,
        );

        await waitForBatchedUpdates();

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persistedRequests) => {
                    Onyx.disconnect(connection);
                    expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_COMMENT);
                    expect(persistedRequests?.at(1)?.command).toBe(WRITE_COMMANDS.ADD_EMOJI_REACTION);
                    expect(persistedRequests?.at(2)?.command).toBe(WRITE_COMMANDS.REMOVE_EMOJI_REACTION);
                    resolve();
                },
            });
        });

        // Checking the Report Action exists before deleting it
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                callback: (reportActions) => {
                    Onyx.disconnect(connection);
                    const reportAction = reportActionID ? reportActions?.[reportActionID] : null;
                    expect(reportAction).not.toBeNull();
                    expect(reportAction?.reportActionID).toBe(reportActionID);
                    resolve();
                },
            });
        });

        Report.deleteReportComment(REPORT, newReportAction, undefined, [], undefined, undefined, '');

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(0);

        // Checking the Report Action doesn't exist after deleting it
        const connection = Onyx.connect({
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
            callback: (reportActions) => {
                Onyx.disconnect(connection);
                const reportAction = reportActionID ? reportActions?.[reportActionID] : undefined;
                expect(reportAction).toBeUndefined();
            },
        });

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_EMOJI_REACTION, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.REMOVE_EMOJI_REACTION, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 0);
    });

    it('should send DeleteComment request and remove any Reactions accordingly', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();
        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
        jest.doMock('@libs/EmojiUtils', () => ({
            ...jest.requireActual('@libs/EmojiUtils'),
            hasAccountIDEmojiReacted: jest.fn(() => true),
        }));
        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Attachment with comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        // Need the reportActionID to delete the comments — read before the queue processes the request
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const reportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        // Let the queue process the online ADD_COMMENT request before going offline
        await waitForBatchedUpdates();

        setHasRadio(false);
        await waitForBatchedUpdates();

        // wait for Onyx.connect execute the callback and start processing the queue
        await Promise.resolve();

        toggleEmojiReaction(REPORT_ID, reportAction, {name: 'smile', code: '😄', hexcode: '1F604'}, {}, CONST.EMOJI_DEFAULT_SKIN_TONE, TEST_USER_ACCOUNT_ID);
        toggleEmojiReaction(
            REPORT_ID,
            reportAction,
            {name: 'smile', code: '😄', hexcode: '1F604'},
            {
                smile: {
                    createdAt: '2024-10-14 14:58:12',
                    oldestTimestamp: '2024-10-14 14:58:12',
                    users: {
                        [`${TEST_USER_ACCOUNT_ID}`]: {
                            id: `${TEST_USER_ACCOUNT_ID}`,
                            oldestTimestamp: '2024-10-14 14:58:12',
                            skinTones: {
                                '-1': '2024-10-14 14:58:12',
                            },
                        },
                    },
                },
            },
            CONST.EMOJI_DEFAULT_SKIN_TONE,
            TEST_USER_ACCOUNT_ID,
        );

        await waitForBatchedUpdates();
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.PERSISTED_REQUESTS,
                callback: (persistedRequests) => {
                    Onyx.disconnect(connection);
                    expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_EMOJI_REACTION);
                    expect(persistedRequests?.at(1)?.command).toBe(WRITE_COMMANDS.REMOVE_EMOJI_REACTION);
                    resolve();
                },
            });
        });

        Report.deleteReportComment(REPORT, reportAction, undefined, [], undefined, undefined, '');

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(1);

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_EMOJI_REACTION, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.REMOVE_EMOJI_REACTION, 0);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 1);
    });

    it('should create and delete thread processing all the requests', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(false);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Testing a comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const reportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);

        Report.openReport({
            hasReportActions: true,
            reportID: REPORT_ID,
            introSelected: TEST_INTRO_SELECTED,
            participants: [{login: 'test@user.com'}],
            betas: undefined,
            newReportObject: {
                parentReportID: REPORT_ID,
                parentReportActionID: reportActionID,
                reportID: '2',
            },
            parentReportActionID: reportActionID,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
        });

        await waitForBatchedUpdates();

        const {result: ancestors} = renderHook(() => useAncestors({reportID: REPORT_ID}));

        Report.deleteReportComment(REPORT, reportAction, undefined, ancestors.current, undefined, undefined, '');

        expect(PersistedRequests.getAll().length).toBe(3);

        await waitForBatchedUpdates();

        const persistedRequests = await OnyxUtils.get(ONYXKEYS.PERSISTED_REQUESTS);
        expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_COMMENT);
        expect(persistedRequests?.at(1)?.command).toBe(WRITE_COMMANDS.OPEN_REPORT);
        expect(persistedRequests?.at(2)?.command).toBe(WRITE_COMMANDS.DELETE_COMMENT);

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.DELETE_COMMENT, 1);
    });

    it('should update AddComment text with the UpdateComment text, sending just an AddComment request', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_ACCOUNT_ID = 1;
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);
        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        setHasRadio(false);

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT_ID,
            ancestors: [],
            text: 'Testing a comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });
        // Need the reportActionID to delete the comments
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const reportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);
        const originalReport = {
            reportID: REPORT_ID,
        };
        Report.editReportComment(originalReport, reportAction, 'Testing an edited comment', undefined, '', undefined);

        await waitForBatchedUpdates();

        const persistedRequests = await OnyxUtils.get(ONYXKEYS.PERSISTED_REQUESTS);

        expect(persistedRequests?.at(0)?.command).toBe(WRITE_COMMANDS.ADD_COMMENT);

        await waitForBatchedUpdates();
        expect(PersistedRequests.getAll().length).toBe(1);

        setHasRadio(true);
        await waitForBatchedUpdates();

        // Checking no requests were or will be made
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_COMMENT, 0);
    });

    it('it should only send the last sequential UpdateComment request to BE', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();
        const reportID = '123';

        setHasRadio(false);
        await waitForBatchedUpdates();

        const action: OnyxEntry<OnyxTypes.ReportAction> = {
            reportID,
            reportActionID: '722',
            actionName: 'ADDCOMMENT',
            created: '2024-10-21 10:37:59.881',
        };

        const originalReport = {
            reportID,
        };

        Report.editReportComment(originalReport, action, 'value1', undefined, '', undefined);
        Report.editReportComment(originalReport, action, 'value2', undefined, '', undefined);
        Report.editReportComment(originalReport, action, 'value3', undefined, '', undefined);

        const requests = PersistedRequests?.getAll();

        expect(requests.length).toBe(1);
        expect(requests?.at(0)?.command).toBe(WRITE_COMMANDS.UPDATE_COMMENT);
        expect(requests?.at(0)?.data?.reportComment).toBe('value3');

        await waitForBatchedUpdates();
        setHasRadio(true);
        await waitForBatchedUpdates();

        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_COMMENT, 1);
    });

    it('should convert short mentions to full format when editing comments', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();

        const TEST_USER_LOGIN = 'alice@expensify.com';
        const TEST_USER_ACCOUNT_ID = 1;
        const MENTIONED_USER_ACCOUNT_ID = 2;
        const MENTIONED_USER_LOGIN = 'bob@expensify.com';
        const REPORT_ID = '1';
        const REPORT: OnyxTypes.Report = createRandomReport(1, undefined);

        const TEN_MINUTES_AGO = subMinutes(new Date(), 10);
        const created = format(addSeconds(TEN_MINUTES_AGO, 10), CONST.DATE.FNS_DB_FORMAT_STRING);

        // Set up personal details with private domain users
        await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
        await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
            [MENTIONED_USER_ACCOUNT_ID]: {
                accountID: MENTIONED_USER_ACCOUNT_ID,
                login: MENTIONED_USER_LOGIN,
                displayName: 'Bob',
            },
        });

        setHasRadio(false);
        await waitForBatchedUpdates();

        Report.addComment({
            report: REPORT,
            notifyReportID: REPORT.reportID,
            ancestors: [],
            text: 'Initial comment',
            timezoneParam: CONST.DEFAULT_TIME_ZONE,
            currentUserAccountID: TEST_USER_ACCOUNT_ID,
            delegateAccountID: undefined,
            conciergeReportID: undefined,
        });

        // Get the reportActionID to edit and delete the comment
        const newComment = PersistedRequests.getAll().at(0);
        const reportActionID = newComment?.data?.reportActionID as string | undefined;
        const newReportAction = TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, reportActionID);
        const originalReport = {
            reportID: REPORT_ID,
        };

        // Edit the comment to add a short mention
        Report.editReportComment(originalReport, newReportAction, 'Initial comment with @bob', undefined, TEST_USER_LOGIN, {
            [TEST_USER_ACCOUNT_ID]: {accountID: TEST_USER_ACCOUNT_ID, login: TEST_USER_LOGIN},
            [MENTIONED_USER_ACCOUNT_ID]: {accountID: MENTIONED_USER_ACCOUNT_ID, login: MENTIONED_USER_LOGIN, displayName: 'Bob'},
        });

        await waitForBatchedUpdates();

        // Verify the mention was converted in the edited comment
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`,
                callback: (reportActions) => {
                    Onyx.disconnect(connection);

                    const reportAction = reportActionID ? reportActions?.[reportActionID] : null;
                    const message = reportAction?.message;
                    const editedMessage = Array.isArray(message) && message.length > 0 ? message.at(0)?.html : undefined;
                    // Verify the mention was converted to full mention with domain
                    expect(editedMessage).toContain('<mention-user>@bob@expensify.com</mention-user>');
                    expect(editedMessage).toBe('Initial comment with <mention-user>@bob@expensify.com</mention-user>');
                    resolve();
                },
            });
        });
        setHasRadio(true);
        await waitForBatchedUpdates();
        await waitForBatchedUpdates();
    });

    it('it should only send the last sequential UpdateComment request to BE with currentUserLogin', async () => {
        global.fetch = TestHelper.getGlobalFetchMock();
        setHasRadio(false);
        await waitForBatchedUpdates();

        const action: OnyxEntry<OnyxTypes.ReportAction> = {
            reportID: '123',
            reportActionID: '722',
            actionName: 'ADDCOMMENT',
            created: '2024-10-21 10:37:59.881',
        };
        const originalReport = {reportID: '123'};
        const currentUserEmail = 'user@test.com';

        Report.editReportComment(originalReport, action, 'value1', undefined, currentUserEmail, undefined);
        Report.editReportComment(originalReport, action, 'value2', undefined, currentUserEmail, undefined);
        Report.editReportComment(originalReport, action, 'value3', undefined, currentUserEmail, undefined);

        const requests = PersistedRequests?.getAll();
        expect(requests.length).toBe(1);
        expect(requests?.at(0)?.command).toBe(WRITE_COMMANDS.UPDATE_COMMENT);
        expect(requests?.at(0)?.data?.reportComment).toBe('value3');

        await waitForBatchedUpdates();
        setHasRadio(true);
        await waitForBatchedUpdates();

        TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_COMMENT, 1);
    });

    it('should clears lastMentionedTime when all mentions to the current user are deleted', async () => {
        const reportID = '1';
        const mentionActionID = '1';
        const mentionActionID2 = '2';
        const currentUserAccountID = 123;

        const mentionAction = createMock<OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT>>({
            reportActionID: mentionActionID,
            created: '2024-01-01T00:00:00.000Z',
            actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
            originalMessage: {
                mentionedAccountIDs: [currentUserAccountID],
            },
        });

        const mentionAction2 = createMock<OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT>>({
            reportActionID: mentionActionID2,
            created: '2024-01-02T00:00:00.000Z',
            actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
            originalMessage: {
                mentionedAccountIDs: [currentUserAccountID],
            },
        });

        await Onyx.merge(ONYXKEYS.SESSION, {accountID: currentUserAccountID});
        await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`, {
            [mentionActionID]: mentionAction,
            [mentionActionID2]: mentionAction2,
        });

        let report = {
            ...createRandomReport(Number(reportID), undefined),
            lastMentionedTime: mentionAction2.created,
        };
        await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, report);

        await waitForBatchedUpdates();

        const {result: ancestors} = renderHook(() => useAncestors(report));

        Report.deleteReportComment(report, mentionAction, undefined, ancestors.current, undefined, undefined, '');
        Report.deleteReportComment(report, mentionAction2, undefined, ancestors.current, undefined, undefined, '');

        await waitForBatchedUpdates();

        report = await OnyxUtils.get(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);

        expect(report?.lastMentionedTime).toBeUndefined();
    });

    describe('deleteReportComment SEARCH_REPORT navigation', () => {
        const PARENT_REPORT_ID = '100';
        const CHILD_REPORT_ID = '200';
        const TEST_USER_ACCOUNT_ID = 1;

        const mockNavigation: {isActiveRoute: jest.Mock; goBack: jest.Mock; getTopmostSearchReportRouteParams: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');

        beforeEach(() => {
            mockNavigation.goBack.mockClear();
        });

        afterEach(() => {
            mockNavigation.isActiveRoute.mockImplementation(() => false);
            mockNavigation.getTopmostSearchReportRouteParams.mockReturnValue(undefined);
        });

        it('calls goBack when viewing the child thread at search/view/<childReportID>', async () => {
            const created = format(addSeconds(subMinutes(new Date(), 10), 10), CONST.DATE.FNS_DB_FORMAT_STRING);
            const parentReport: OnyxTypes.Report = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const reportAction = {
                ...TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, '101'),
                childReportID: CHILD_REPORT_ID,
                childVisibleActionCount: 0,
            };

            mockNavigation.getTopmostSearchReportRouteParams.mockReturnValue({reportID: CHILD_REPORT_ID});

            const {result: ancestors} = renderHook(() => useAncestors(parentReport));
            Report.deleteReportComment(parentReport, reportAction, undefined, ancestors.current, undefined, undefined, '');
            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
        });

        it('calls goBack when viewing the child thread at search/view/<childReportID>/<reportActionID>', async () => {
            const created = format(addSeconds(subMinutes(new Date(), 10), 10), CONST.DATE.FNS_DB_FORMAT_STRING);
            const parentReport: OnyxTypes.Report = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const reportAction = {
                ...TestHelper.buildTestReportComment(created, TEST_USER_ACCOUNT_ID, '101'),
                childReportID: CHILD_REPORT_ID,
                childVisibleActionCount: 0,
            };

            mockNavigation.getTopmostSearchReportRouteParams.mockReturnValue({reportID: CHILD_REPORT_ID, reportActionID: 'action-999'});

            const {result: ancestors} = renderHook(() => useAncestors(parentReport));
            Report.deleteReportComment(parentReport, reportAction, undefined, ancestors.current, undefined, undefined, '');
            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
        });
    });

    it('should create new report and "create report" quick action, when createNewReport gets called', async () => {
        const accountID = 1234;
        const policyID = '5678';
        const mockFetchData = getMockFetch(fetch);
        // Given a policy with harvesting is disabled
        const policy = {
            ...createRandomPolicy(Number(policyID)),
            isPolicyExpenseChatEnabled: true,
            type: CONST.POLICY.TYPE.TEAM,
            autoReporting: false,
            autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.IMMEDIATE,
            harvesting: {
                enabled: false,
            },
        };
        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policy);

        mockFetchData.pause();
        const {reportID} = Report.createNewReport({accountID}, true, false, policy, [CONST.BETAS.ALL], false);
        const parentReport = ReportUtils.getPolicyExpenseChat(accountID, policyID);

        const reportPreviewAction = await new Promise<OnyxEntry<OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW>>>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReport?.reportID}`,
                callback: (reportActions) => {
                    Onyx.disconnect(connection);
                    const action = Object.values(reportActions ?? {}).at(0);
                    resolve(action as OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW>);
                },
            });
        });
        expect(getOriginalMessage(reportPreviewAction)?.linkedReportID).toBe(reportID);
        expect(reportPreviewAction?.actorAccountID).toBe(accountID);

        await waitForBatchedUpdates();

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.COLLECTION.REPORT,
                waitForCollectionCallback: true,
                callback: (reports: OnyxCollection<OnyxTypes.Report>) => {
                    Onyx.disconnect(connection);
                    const createdReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
                    const parentPolicyExpenseChat = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${parentReport?.reportID}`];
                    // assert correctness of crucial onyx data
                    expect(createdReport?.reportID).toBe(reportID);
                    expect(parentPolicyExpenseChat?.hasOutstandingChildRequest).toBe(true);
                    expect(createdReport?.total).toBe(0);
                    expect(createdReport?.parentReportActionID).toBe(reportPreviewAction?.reportActionID);

                    resolve();
                },
            });
        });

        // When the request fails
        mockFetchData.fail();
        await mockFetchData.resume();
        await waitForBatchedUpdates();

        // Then the onyx data should be reverted to the state before the request
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.COLLECTION.REPORT,
                waitForCollectionCallback: true,
                callback: (reports: OnyxCollection<OnyxTypes.Report>) => {
                    Onyx.disconnect(connection);
                    const parentPolicyExpenseChat = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${parentReport?.reportID}`];
                    expect(parentPolicyExpenseChat?.hasOutstandingChildRequest).toBe(parentReport?.hasOutstandingChildRequest);

                    resolve();
                },
            });
        });
    });

    it('should set hasOnceLoadedReportActions for parent report metadata when creating a new report', async () => {
        const accountID = 1234;
        const policyID = '5678';
        const mockFetchData = getMockFetch(fetch);
        const policy = {
            ...createRandomPolicy(Number(policyID)),
            isPolicyExpenseChatEnabled: true,
            type: CONST.POLICY.TYPE.TEAM,
            harvesting: {
                enabled: false,
            },
        };
        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policy);

        mockFetchData.pause();
        Report.createNewReport({accountID}, true, false, policy, [CONST.BETAS.ALL], false);
        const parentReport = ReportUtils.getPolicyExpenseChat(accountID, policyID);

        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE}${parentReport?.reportID}`,
                callback: (loadingState) => {
                    if (!loadingState?.hasOnceLoadedReportActions) {
                        return;
                    }
                    Onyx.disconnect(connection);
                    expect(loadingState.hasOnceLoadedReportActions).toBe(true);
                    resolve();
                },
            });
        });
    });

    it('should not optimistic outstandingChildRequest when create report with harvesting is enabled', async () => {
        const accountID = 1234;
        const policyID = '5678';
        // Given a policy with harvesting is enabled
        const policy = {
            ...createRandomPolicy(Number(policyID)),
            isPolicyExpenseChatEnabled: true,
            type: CONST.POLICY.TYPE.TEAM,
            autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.IMMEDIATE,
            harvesting: {
                enabled: true,
            },
        };
        const parentReport = ReportUtils.getPolicyExpenseChat(accountID, policyID);
        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policy);
        if (parentReport?.reportID) {
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport?.reportID}`, parentReport);
        }

        // When create new report
        Report.createNewReport({accountID}, true, false, policy, [CONST.BETAS.ALL], false);

        // Then the parent report's hasOutstandingChildRequest property should remain unchanged
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: ONYXKEYS.COLLECTION.REPORT,
                waitForCollectionCallback: true,
                callback: (reports: OnyxCollection<OnyxTypes.Report>) => {
                    Onyx.disconnect(connection);
                    const parentPolicyExpenseChat = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${parentReport?.reportID}`];
                    expect(parentPolicyExpenseChat?.hasOutstandingChildRequest).toBe(parentReport?.hasOutstandingChildRequest);

                    resolve();
                },
            });
        });
    });

    it('should create the empty report with draft status if submission is instant with approval disabled', async () => {
        const accountID = 1234;
        const policyID = '5678';
        // Given a policy with instant submission and approval disabled
        const policy: OnyxTypes.Policy = {
            ...createRandomPolicy(Number(policyID)),
            isPolicyExpenseChatEnabled: true,
            type: CONST.POLICY.TYPE.TEAM,
            autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.INSTANT,
            approvalMode: CONST.POLICY.APPROVAL_MODE.OPTIONAL,
        };
        const parentReport = ReportUtils.getPolicyExpenseChat(accountID, policyID);
        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policy);
        if (parentReport?.reportID) {
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport?.reportID}`, parentReport);
        }

        // When create new report
        const optimisticReportData = Report.createNewReport({accountID}, true, false, policy, [CONST.BETAS.ALL], false);

        await waitForBatchedUpdates();
        // Then the report's status should be draft.
        await new Promise<void>((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.REPORT}${optimisticReportData.reportID}`,
                callback: (report) => {
                    Onyx.disconnect(connection);
                    expect(report?.stateNum).toBe(CONST.REPORT.STATE_NUM.OPEN);
                    expect(report?.statusNum).toBe(CONST.REPORT.STATUS_NUM.OPEN);

                    resolve();
                },
            });
        });
    });

    it('should add the report preview action to the chat snapshot when it is created', async () => {
        jest.spyOn(require('@src/libs/SearchQueryUtils'), 'getCurrentSearchQueryJSON').mockImplementationOnce(() =>
            createMock<SearchQueryJSON>({
                hash: currentHash,
                inputQuery: 'test',
                type: CONST.SEARCH.DATA_TYPES.CHAT,
                flatFilters: [],
            }),
        );
        const accountID = 1234;
        const policyID = '5678';

        const policy = {
            ...createRandomPolicy(Number(policyID)),
            isPolicyExpenseChatEnabled: true,
            type: CONST.POLICY.TYPE.TEAM,
            autoReporting: false,
            autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.IMMEDIATE,
            harvesting: {
                enabled: false,
            },
        };
        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policy);

        const {reportID} = Report.createNewReport({accountID}, true, false, policy, [CONST.BETAS.ALL], false);
        const parentReport = ReportUtils.getPolicyExpenseChat(accountID, policyID);

        await waitForBatchedUpdates();

        await new Promise((resolve) => {
            const connection = Onyx.connect({
                key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentHash}`,
                callback: (snapshot) => {
                    Onyx.disconnect(connection);
                    expect(snapshot?.data?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReport?.reportID}`]).toBeTruthy();
                    expect(snapshot?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${parentReport?.reportID}`]).toBeTruthy();
                    expect(snapshot?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]).toBeTruthy();
                    resolve(null);
                },
            });
        });
    });

    describe('completeOnboarding', () => {
        const TEST_USER_LOGIN = 'test@gmail.com';
        const TEST_USER_ACCOUNT_ID = 1;
        global.fetch = TestHelper.getGlobalFetchMock();

        it('should not write any optimistic actions to admins report for MANAGE_TEAM (server posts via inboxAdminsBespoke)', async () => {
            await Onyx.set(ONYXKEYS.SESSION, {email: TEST_USER_LOGIN, accountID: TEST_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            const adminsChatReportID = '7957055873634067';
            const onboardingPolicyID = 'A70D00C752416807';
            const engagementChoice = CONST.INTRO_CHOICES.MANAGE_TEAM;
            const {onboardingMessages} = getOnboardingMessages();

            Report.completeOnboarding({
                engagementChoice,
                onboardingMessage: onboardingMessages[engagementChoice],
                adminsChatReportID,
                onboardingPolicyID,
                companySize: CONST.ONBOARDING_COMPANY_SIZE.MICRO,
                userReportedIntegration: null,
                introSelected: {choice: engagementChoice},
                isSelfTourViewed: false,
            });

            await waitForBatchedUpdates();

            const reportActions: OnyxEntry<OnyxTypes.ReportActions> = await new Promise((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${adminsChatReportID}`,
                    callback: (id) => {
                        Onyx.disconnect(connection);
                        resolve(id);
                    },
                });
            });

            expect(reportActions).toBeUndefined();
        });

        it('should forward selectedInterestedFeatures to the CompleteGuidedSetup API call as a JSON-encoded array', async () => {
            await Onyx.set(ONYXKEYS.SESSION, {email: TEST_USER_LOGIN, accountID: TEST_USER_ACCOUNT_ID});
            (global.fetch as jest.Mock).mockClear();
            await waitForBatchedUpdates();

            const engagementChoice = CONST.INTRO_CHOICES.MANAGE_TEAM;
            const {onboardingMessages} = getOnboardingMessages();
            const selectedInterestedFeatures = [CONST.POLICY.MORE_FEATURES.ARE_EXPENSIFY_CARDS_ENABLED, CONST.POLICY.MORE_FEATURES.IS_TRAVEL_ENABLED];

            Report.completeOnboarding({
                engagementChoice,
                onboardingMessage: onboardingMessages[engagementChoice],
                adminsChatReportID: '7957055873634068',
                onboardingPolicyID: 'A70D00C752416808',
                companySize: CONST.ONBOARDING_COMPANY_SIZE.MICRO,
                userReportedIntegration: null,
                selectedInterestedFeatures,
                introSelected: {choice: engagementChoice},
                isSelfTourViewed: false,
            });

            await waitForBatchedUpdates();

            const calls = TestHelper.getFetchMockCalls(WRITE_COMMANDS.COMPLETE_GUIDED_SETUP);
            expect(calls.length).toBeGreaterThan(0);
            const body = calls.at(-1)?.[1]?.body;
            expect(body).toBeInstanceOf(FormData);
            const formEntries = Object.fromEntries(body as FormData);
            expect(formEntries.selectedInterestedFeatures).toBe(JSON.stringify(selectedInterestedFeatures));
        });

        it('should post onboarding tasks to the existing Concierge chat', async () => {
            await Onyx.set(ONYXKEYS.SESSION, {email: TEST_USER_LOGIN, accountID: TEST_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            // An existing 1:1 Concierge chat the onboarding tasks should be posted to
            const conciergeChatReportID = '9988776655';
            const conciergeChat: OnyxTypes.Report = {
                reportID: conciergeChatReportID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };
            // LOOKING_AROUND posts the onboarding tasks to the Concierge chat (not the #admins room)
            const engagementChoice = CONST.ONBOARDING_CHOICES.LOOKING_AROUND;
            const {onboardingMessages} = getOnboardingMessages();

            const onboardingData = ReportUtils.prepareOnboardingOnyxData({
                engagementChoice,
                onboardingMessage: onboardingMessages[engagementChoice],
                companySize: CONST.ONBOARDING_COMPANY_SIZE.MICRO,
                userReportedIntegration: null,
                introSelected: {choice: engagementChoice},
                isSelfTourViewed: false,
                conciergeChat,
            });

            // The onboarding optimistic data should target the existing Concierge chat
            expect(onboardingData).toBeTruthy();
            const targetsConciergeChat = onboardingData?.optimisticData.some((update) => update.key.includes(conciergeChatReportID));
            expect(targetsConciergeChat).toBe(true);
        });

        it('should reuse the existing self-DM for a personal spend onboarding', async () => {
            await Onyx.set(ONYXKEYS.SESSION, {email: TEST_USER_LOGIN, accountID: TEST_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            // An existing Concierge chat (the onboarding target) and an existing self-DM the personal spend
            // onboarding should reuse instead of creating a new one
            const conciergeChatReportID = '6677889900';
            const conciergeChat: OnyxTypes.Report = {
                reportID: conciergeChatReportID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };
            const selfDMReportID = '5544332211';
            const selfDMReport: OnyxTypes.Report = {
                reportID: selfDMReportID,
                type: CONST.REPORT.TYPE.CHAT,
                chatType: CONST.REPORT.CHAT_TYPE.SELF_DM,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${selfDMReportID}`, selfDMReport);
            await waitForBatchedUpdates();

            // PERSONAL_SPEND routes the onboarding to the user's self-DM
            const engagementChoice = CONST.ONBOARDING_CHOICES.PERSONAL_SPEND;
            const {onboardingMessages} = getOnboardingMessages();

            const onboardingData = ReportUtils.prepareOnboardingOnyxData({
                engagementChoice,
                onboardingMessage: onboardingMessages[engagementChoice],
                companySize: CONST.ONBOARDING_COMPANY_SIZE.MICRO,
                userReportedIntegration: null,
                introSelected: {choice: engagementChoice},
                isSelfTourViewed: false,
                conciergeChat,
            });

            // The existing self-DM should be reused, so no new self-DM is created
            expect(onboardingData).toBeTruthy();
            expect(onboardingData?.selfDMParameters?.reportID).toBeUndefined();
        });

        it('should optimistically create a self-DM for a personal spend onboarding when none exists', async () => {
            await Onyx.set(ONYXKEYS.SESSION, {email: TEST_USER_LOGIN, accountID: TEST_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            // Only a Concierge chat exists (the onboarding target); there is no self-DM yet
            const conciergeChatReportID = '1122334455';
            const conciergeChat: OnyxTypes.Report = {
                reportID: conciergeChatReportID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };
            const engagementChoice = CONST.ONBOARDING_CHOICES.PERSONAL_SPEND;
            const {onboardingMessages} = getOnboardingMessages();

            const onboardingData = ReportUtils.prepareOnboardingOnyxData({
                engagementChoice,
                onboardingMessage: onboardingMessages[engagementChoice],
                companySize: CONST.ONBOARDING_COMPANY_SIZE.MICRO,
                userReportedIntegration: null,
                introSelected: {choice: engagementChoice},
                isSelfTourViewed: false,
                conciergeChat,
            });

            // A new self-DM is created and added to the optimistic data
            expect(onboardingData).toBeTruthy();
            const newSelfDMReportID = onboardingData?.selfDMParameters?.reportID;
            expect(newSelfDMReportID).toBeTruthy();
            const createsSelfDM = onboardingData?.optimisticData.some((update) => update.key === `${ONYXKEYS.COLLECTION.REPORT}${newSelfDMReportID}`);
            expect(createsSelfDM).toBe(true);
        });
    });

    describe('markAllMessagesAsRead', () => {
        it('should mark all unread reports as read', async () => {
            // Given a collection of 10 unread and read reports, where even-index report is unread
            const currentTime = DateUtils.getDBTime();
            const reportCollections: Record<`${typeof ONYXKEYS.COLLECTION.REPORT}${string}`, OnyxTypes.Report> = createCollection<OnyxTypes.Report>(
                (item) => `${ONYXKEYS.COLLECTION.REPORT}${item.reportID}`,
                (index) => {
                    if (index % 2 === 0) {
                        return {
                            ...createRandomReport(index, undefined),
                            lastMessageText: 'test',
                            lastReadTime: DateUtils.subtractMillisecondsFromDateTime(currentTime, 1),
                            lastVisibleActionCreated: currentTime,
                        };
                    }
                    return createRandomReport(index, undefined);
                },
                10,
            );
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, reportCollections);

            // When mark all reports as read
            markAllMessagesAsRead({});

            await waitForBatchedUpdates();

            // Then all report should be read
            const isUnreadCollection = await Promise.all(
                Object.values(reportCollections).map((report) => {
                    return new Promise<boolean>((resolve) => {
                        const connection = Onyx.connect({
                            key: `${ONYXKEYS.COLLECTION.REPORT}${report.reportID}`,
                            callback: (reportVal) => {
                                Onyx.disconnect(connection);
                                resolve(ReportUtils.isUnread(reportVal, undefined, undefined));
                            },
                        });
                    });
                }),
            );
            expect(isUnreadCollection.some(Boolean)).toBe(false);
        });
    });

    describe('updateDescription', () => {
        const currentUserAccountID = 1;
        it('should not call UpdateRoomDescription API if the description is not changed', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();
            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                description: '<h1>test</h1>',
            };
            Report.updateDescription(report, '# test', currentUserAccountID);

            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.UPDATE_ROOM_DESCRIPTION, 0);
        });

        it('should revert to correct previous description if UpdateRoomDescription API fails', async () => {
            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                description: '<h1>test</h1>',
            };
            const mockFetch = getMockFetch(fetch);

            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${report.reportID}`, report);

            mockFetch?.fail?.();
            Report.updateDescription(report, '# test1', currentUserAccountID);

            await waitForBatchedUpdates();
            let updateReport: OnyxEntry<OnyxTypes.Report>;

            await TestHelper.getOnyxData({
                key: `${ONYXKEYS.COLLECTION.REPORT}${report.reportID}`,
                callback: (val) => (updateReport = val),
            });
            expect(updateReport?.description).toBe('<h1>test</h1>');
            expect(updateReport?.lastActorAccountID).toBe(currentUserAccountID);

            mockFetch.mockReset();
        });
    });

    describe('deleteAppReport', () => {
        const currentUserAccountID = 1;
        it('should only moves CREATE or TRACK type of IOU action to self DM', async () => {
            // Given an expense report with CREATE, TRACK, and PAY of IOU actions
            const reportID = '1';
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                managerID: currentUserAccountID,
                ownerAccountID: currentUserAccountID,
                stateNum: CONST.REPORT.STATE_NUM.OPEN,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, expenseReport);
            const firstIOUAction: OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU> = {
                reportActionID: '1',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
                created: DateUtils.getDBTime(),
                message: [{type: 'COMMENT', html: 'Comment 1', text: 'Comment 1'}],
                originalMessage: {
                    amount: 100,
                    currency: CONST.CURRENCY.USD,
                    type: CONST.IOU.REPORT_ACTION_TYPE.CREATE,
                },
            };
            const secondIOUAction: OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU> = {
                reportActionID: '2',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
                created: DateUtils.getDBTime(),
                message: [{type: 'COMMENT', html: 'Comment 2', text: 'Comment 2'}],
                originalMessage: {
                    amount: 100,
                    currency: CONST.CURRENCY.USD,
                    type: CONST.IOU.REPORT_ACTION_TYPE.TRACK,
                },
            };
            const payAction: OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU> = {
                reportActionID: '3',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
                created: DateUtils.getDBTime(),
                message: [{type: 'COMMENT', html: 'Comment 3', text: 'Comment 3'}],
                originalMessage: {
                    amount: 100,
                    currency: CONST.CURRENCY.USD,
                    type: CONST.IOU.REPORT_ACTION_TYPE.PAY,
                },
            };
            const reportActions = {
                [firstIOUAction.reportActionID]: firstIOUAction,
                [secondIOUAction.reportActionID]: secondIOUAction,
                [payAction.reportActionID]: payAction,
            };

            // When deleting the expense report
            Report.deleteAppReport({
                report: expenseReport,
                reportActions,
                parentReportAction: undefined,
                selfDMReport: undefined,
                currentUserEmailParam: '',
                currentUserAccountIDParam: currentUserAccountID,
                reportTransactions: {},
                allTransactionViolations: {},
                bankAccountList: {},
            });
            await waitForBatchedUpdates();

            // Then only the IOU action with type of CREATE and TRACK is moved to the self DM
            const selfDMReportID = ReportUtils.findSelfDMReportID();
            const selfDMReportActions = await new Promise<OnyxEntry<OnyxTypes.ReportActions>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReportID}`,
                    callback: (val) => {
                        Onyx.disconnect(connection);
                        resolve(val);
                    },
                });
            });
            // The length is 3 to include the CREATED action
            expect(Object.keys(selfDMReportActions ?? {}).length).toBe(3);
        });

        it('should not reset the chatReport hasOutstandingChildRequest if there is another outstanding report', async () => {
            const fakePolicy: OnyxTypes.Policy = {
                ...createRandomPolicy(6),
                role: 'admin',
                ownerAccountID: currentUserAccountID,
                areRulesEnabled: true,
                preventSelfApproval: false,
                autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.IMMEDIATE,
                harvesting: {
                    enabled: false,
                },
            };
            const chatReport: OnyxTypes.Report = {
                ...createRandomReport(11, CONST.REPORT.CHAT_TYPE.POLICY_EXPENSE_CHAT),
                policyID: fakePolicy.id,
                hasOutstandingChildRequest: true,
                isOwnPolicyExpenseChat: true,
            };

            const expenseReport1: OnyxTypes.Report = {
                ...createRandomReport(5, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                managerID: currentUserAccountID,
                ownerAccountID: currentUserAccountID,
                policyID: fakePolicy.id,
                stateNum: CONST.REPORT.STATE_NUM.OPEN,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                chatReportID: chatReport.reportID,
                parentReportID: chatReport.reportID,
            };
            const reportPreview1: OnyxTypes.ReportAction = {
                ...createRandomReportAction(1),
                actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
                originalMessage: {
                    linkedReportID: expenseReport1.reportID,
                },
            };
            const expenseReport2: OnyxTypes.Report = {
                ...createRandomReport(6, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                managerID: currentUserAccountID,
                ownerAccountID: currentUserAccountID,
                policyID: fakePolicy.id,
                stateNum: CONST.REPORT.STATE_NUM.OPEN,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                chatReportID: chatReport.reportID,
                parentReportID: chatReport.reportID,
            };
            const transaction: OnyxTypes.Transaction = {...createRandomTransaction(22), reportID: expenseReport2.reportID};
            const reportPreview2: OnyxTypes.ReportAction = {
                ...createRandomReportAction(22),
                actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
                originalMessage: {
                    linkedReportID: expenseReport2.reportID,
                },
            };
            const iouAction1: OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU> = {
                reportActionID: '1',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
                created: DateUtils.getDBTime(),
                originalMessage: {
                    amount: 100,
                    currency: CONST.CURRENCY.USD,
                    type: CONST.IOU.REPORT_ACTION_TYPE.CREATE,
                },
            };

            await Onyx.merge(ONYXKEYS.SESSION, {accountID: currentUserAccountID});
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${fakePolicy.id}`, fakePolicy);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${expenseReport1.reportID}`, {
                [iouAction1.reportActionID]: iouAction1,
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${chatReport.reportID}`, {
                [reportPreview1.reportActionID]: reportPreview1,
                [reportPreview2.reportActionID]: reportPreview2,
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${chatReport.reportID}`, chatReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport1.reportID}`, expenseReport1);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport2.reportID}`, expenseReport2);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`, transaction);

            // When deleting the first expense report
            Report.deleteAppReport({
                report: expenseReport1,
                reportActions: undefined,
                parentReportAction: undefined,
                selfDMReport: undefined,
                currentUserEmailParam: '',
                currentUserAccountIDParam: currentUserAccountID,
                reportTransactions: {
                    [`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`]: transaction,
                },
                allTransactionViolations: {},
                bankAccountList: {},
            });
            await waitForBatchedUpdates();

            const report = await new Promise<OnyxEntry<OnyxTypes.Report>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT}${chatReport.reportID}`,
                    callback: (val) => {
                        Onyx.disconnect(connection);
                        resolve(val);
                    },
                });
            });

            // The hasOutstandingChildRequest should still remain true as there is a second outstanding report.
            expect(report?.hasOutstandingChildRequest).toBe(true);
        });

        it('should mark the chat report preview action as deleted so the LHN action badge clears', async () => {
            // Given a workspace chat with a single expense report and its report preview action
            const fakePolicy: OnyxTypes.Policy = {
                ...createRandomPolicy(7),
                role: 'admin',
                ownerAccountID: currentUserAccountID,
            };
            const chatReport: OnyxTypes.Report = {
                ...createRandomReport(30, CONST.REPORT.CHAT_TYPE.POLICY_EXPENSE_CHAT),
                policyID: fakePolicy.id,
                isOwnPolicyExpenseChat: true,
            };
            const reportPreviewActionID = '300';
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(31, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                managerID: currentUserAccountID,
                ownerAccountID: currentUserAccountID,
                policyID: fakePolicy.id,
                stateNum: CONST.REPORT.STATE_NUM.OPEN,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                chatReportID: chatReport.reportID,
                parentReportID: chatReport.reportID,
                parentReportActionID: reportPreviewActionID,
            };
            const reportPreview: OnyxTypes.ReportAction = {
                ...createRandomReportAction(Number(reportPreviewActionID)),
                reportActionID: reportPreviewActionID,
                actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
                message: [{type: 'COMMENT', html: 'Report preview', text: 'Report preview'}],
                originalMessage: {
                    linkedReportID: expenseReport.reportID,
                },
            };

            await Onyx.merge(ONYXKEYS.SESSION, {accountID: currentUserAccountID});
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${fakePolicy.id}`, fakePolicy);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${chatReport.reportID}`, chatReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`, expenseReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${chatReport.reportID}`, {
                [reportPreview.reportActionID]: reportPreview,
            });
            await waitForBatchedUpdates();

            // When deleting the whole expense report (the path taken when it has multiple transactions, e.g. after duplicating)
            Report.deleteAppReport({
                report: expenseReport,
                reportActions: undefined,
                parentReportAction: reportPreview,
                selfDMReport: undefined,
                currentUserEmailParam: '',
                currentUserAccountIDParam: currentUserAccountID,
                reportTransactions: {},
                allTransactionViolations: {},
                bankAccountList: {},
            });
            await waitForBatchedUpdates();

            const chatReportActions = await new Promise<OnyxEntry<OnyxTypes.ReportActions>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${chatReport.reportID}`,
                    callback: (val) => {
                        Onyx.disconnect(connection);
                        resolve(val);
                    },
                });
            });

            // Then the report preview action is treated as deleted, so the badge logic skips it
            expect(isDeletedAction(chatReportActions?.[reportPreviewActionID])).toBe(true);
        });
    });

    describe('changeReportPolicy', () => {
        it('should unarchive the expense report', async () => {
            // Given an archived expense report
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: '1',
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${expenseReport.reportID}`, {
                private_isArchived: DateUtils.getDBTime(),
            });

            const newPolicy = createRandomPolicy(2);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`, newPolicy);

            // When moving to another workspace
            Report.changeReportPolicy({
                report: expenseReport,
                parentReport: undefined,
                policy: newPolicy,
                currentUserAccountID: 1,
                email: '',
                managerLogin: '',
                hasViolationsParam: true,
                isChangePolicyTrainingModalDismissed: false,
                ownerLogin: undefined,
                isASAPSubmitBetaEnabled: false,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // Then the expense report should not be archived anymore
            const isArchived = await new Promise<boolean>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${expenseReport.reportID}`,
                    callback: (val) => {
                        resolve(!!val?.private_isArchived);
                        Onyx.disconnect(connection);
                    },
                });
            });
            expect(isArchived).toBe(false);

            const snapshotData = await new Promise<OnyxEntry<OnyxTypes.SearchResults>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentHash}`,
                    callback: (val) => {
                        resolve(val);
                        Onyx.disconnect(connection);
                    },
                });
            });

            // Then the new policy data should also be populated on the current search snapshot.
            expect(snapshotData?.data?.[`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`]).toBeDefined();
        });

        it('should update the chatReportID and parentReportID to the new policy expense chat report ID', async () => {
            // Given an expense report
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: '1',
                chatReportID: '2',
                parentReportID: '2',
            };
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(2, CONST.REPORT.CHAT_TYPE.POLICY_EXPENSE_CHAT),
                policyID: '1',
            };

            const newPolicy = createRandomPolicy(2);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`, newPolicy);

            // When moving to another workspace
            Report.changeReportPolicy({
                report: expenseReport,
                parentReport,
                policy: newPolicy,
                currentUserAccountID: 1,
                email: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                ownerLogin: undefined,
                isASAPSubmitBetaEnabled: false,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // Then the expense report chatReportID and parentReportID should be updated to the new expense chat reportID
            const expenseReport2 = await new Promise<OnyxEntry<OnyxTypes.Report>>((resolve) => {
                const connection = Onyx.connectWithoutView({
                    key: `${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`,
                    callback: (report) => {
                        Onyx.disconnect(connection);
                        resolve(report);
                    },
                });
            });
            expect(expenseReport2?.chatReportID).toBe(MOCKED_POLICY_EXPENSE_CHAT_REPORT_ID);
            expect(expenseReport2?.parentReportID).toBe(MOCKED_POLICY_EXPENSE_CHAT_REPORT_ID);
        });

        it('should update report currency and reset totals when changing to workspace with different currency', async () => {
            // Given an expense report with AUD currency and a transaction in USD
            const oldPolicy = {
                ...createRandomPolicy(1),
                outputCurrency: 'AUD',
            };
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: oldPolicy.id,
                currency: 'AUD',
                total: -1503,
                nonReimbursableTotal: 0,
                unheldNonReimbursableTotal: 0,
            };
            const transaction: OnyxTypes.Transaction = {
                transactionID: '1',
                reportID: expenseReport.reportID,
                currency: 'USD',
                amount: -1000,
                convertedAmount: -1503,
                reimbursable: true,
                comment: {},
                created: '',
                merchant: '',
            };

            await Promise.all([
                Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${oldPolicy.id}`, oldPolicy),
                Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`, expenseReport),
                Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`, transaction),
            ]);

            // When moving to a workspace with AED currency
            const newPolicy = {
                ...createRandomPolicy(2),
                outputCurrency: 'AED',
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`, newPolicy);

            Report.changeReportPolicy({
                report: expenseReport,
                parentReport: undefined,
                policy: newPolicy,
                currentUserAccountID: 1,
                email: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                ownerLogin: undefined,
                isASAPSubmitBetaEnabled: false,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            const updatedReport = await new Promise<OnyxEntry<OnyxTypes.Report>>((resolve) => {
                const connection = Onyx.connectWithoutView({
                    key: `${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`,
                    callback: (report) => {
                        Onyx.disconnect(connection);
                        resolve(report);
                    },
                });
            });

            // Report currency should update to destination
            expect(updatedReport?.currency).toBe('AED');
            // Total should be 0 (USD transaction doesn't match AED)
            expect(updatedReport?.total).toBe(0);

            // Transaction's convertedAmount should be cleared
            const updatedTransaction = await new Promise<OnyxEntry<OnyxTypes.Transaction>>((resolve) => {
                const connection = Onyx.connectWithoutView({
                    key: `${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`,
                    callback: (txn) => {
                        Onyx.disconnect(connection);
                        resolve(txn);
                    },
                });
            });
            expect(updatedTransaction?.convertedAmount).toBeFalsy();
        });

        it('should correctly calculate totals with refund transactions (positive amounts)', async () => {
            // Given an expense report with a mix of expense and refund transactions
            const oldPolicy = {
                ...createRandomPolicy(1),
                outputCurrency: 'USD',
            };
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: oldPolicy.id,
                currency: 'USD',
                total: -500, // Net of -1000 expense + 500 refund
                nonReimbursableTotal: 0,
                unheldNonReimbursableTotal: 0,
            };
            // Regular expense (negative rawAmount)
            const expenseTransaction: OnyxTypes.Transaction = {
                transactionID: '1',
                reportID: expenseReport.reportID,
                currency: 'AUD',
                amount: -1000,
                reimbursable: true,
                comment: {},
                created: '',
                merchant: '',
            };
            // Refund transaction (positive rawAmount)
            const refundTransaction: OnyxTypes.Transaction = {
                transactionID: '2',
                reportID: expenseReport.reportID,
                currency: 'AUD',
                amount: 500, // Positive = refund
                reimbursable: true,
                comment: {},
                created: '',
                merchant: '',
            };

            await Promise.all([
                Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${oldPolicy.id}`, oldPolicy),
                Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`, expenseReport),
                Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${expenseTransaction.transactionID}`, expenseTransaction),
                Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${refundTransaction.transactionID}`, refundTransaction),
            ]);

            // When moving to a workspace with AUD currency (matching transaction currencies)
            const newPolicy = {
                ...createRandomPolicy(2),
                outputCurrency: 'AUD',
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`, newPolicy);

            Report.changeReportPolicy({
                report: expenseReport,
                parentReport: undefined,
                policy: newPolicy,
                currentUserAccountID: 1,
                email: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                ownerLogin: undefined,
                isASAPSubmitBetaEnabled: false,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // Then the report total should correctly include expense (-1000) and refund (+500) = -500
            const updatedReport = await new Promise<OnyxEntry<OnyxTypes.Report>>((resolve) => {
                const connection = Onyx.connectWithoutView({
                    key: `${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`,
                    callback: (report) => {
                        Onyx.disconnect(connection);
                        resolve(report);
                    },
                });
            });
            // Expense: -1000 → getAmount(true) = 1000 → total -= 1000 = -1000
            // Refund: +500 → getAmount(true) = -500 → total -= (-500) = -1000 + 500 = -500
            expect(updatedReport?.total).toBe(-500);
        });

        it('should only include matching currency transactions in total with mixed currencies', async () => {
            // Given an expense report with transactions in different currencies
            const oldPolicy = {
                ...createRandomPolicy(1),
                outputCurrency: 'USD',
            };
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: oldPolicy.id,
                currency: 'USD',
                total: -3000,
                nonReimbursableTotal: 0,
                unheldNonReimbursableTotal: 0,
            };
            // AUD transaction - should be included when moving to AUD workspace
            const audTransaction: OnyxTypes.Transaction = {
                transactionID: '1',
                reportID: expenseReport.reportID,
                currency: 'AUD',
                amount: -1000,
                reimbursable: true,
                comment: {},
                created: '',
                merchant: '',
            };
            // USD transaction - should NOT be included when moving to AUD workspace
            const usdTransaction: OnyxTypes.Transaction = {
                transactionID: '2',
                reportID: expenseReport.reportID,
                currency: 'USD',
                amount: -2000,
                convertedAmount: -2000,
                reimbursable: true,
                comment: {},
                created: '',
                merchant: '',
            };

            await Promise.all([
                Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${oldPolicy.id}`, oldPolicy),
                Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`, expenseReport),
                Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${audTransaction.transactionID}`, audTransaction),
                Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${usdTransaction.transactionID}`, usdTransaction),
            ]);

            // When moving to a workspace with AUD currency
            const newPolicy = {
                ...createRandomPolicy(2),
                outputCurrency: 'AUD',
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`, newPolicy);

            Report.changeReportPolicy({
                report: expenseReport,
                parentReport: undefined,
                policy: newPolicy,
                currentUserAccountID: 1,
                email: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                ownerLogin: undefined,
                isASAPSubmitBetaEnabled: false,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // Then only AUD transaction should contribute to total (-1000), USD is excluded
            const updatedReport = await new Promise<OnyxEntry<OnyxTypes.Report>>((resolve) => {
                const connection = Onyx.connectWithoutView({
                    key: `${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`,
                    callback: (report) => {
                        Onyx.disconnect(connection);
                        resolve(report);
                    },
                });
            });
            expect(updatedReport?.total).toBe(-1000); // Only AUD transaction included
        });
    });

    describe('changeReportPolicyAndInviteSubmitter', () => {
        it('should unarchive the expense report', async () => {
            // Given an archived expense report
            const ownerAccountID = 1;
            const ownerEmail = 'owner@gmail.com';
            const adminEmail = 'admin@gmail.com';
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: '1',
                ownerAccountID,
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${expenseReport.reportID}`, {
                private_isArchived: DateUtils.getDBTime(),
            });
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [ownerAccountID]: {
                    login: ownerEmail,
                },
            });

            // When moving to another workspace
            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: createRandomPolicy(Number(2)),
                currentUser: {accountID: 1},
                submitterLogin: ownerEmail,
                managerLogin: '',
                hasViolationsParam: true,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: {
                    [adminEmail]: {role: CONST.POLICY.ROLE.ADMIN},
                },
                isReportLastVisibleArchived: undefined,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // Then the expense report should not be archived anymore
            const isArchived = await new Promise<boolean>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${expenseReport.reportID}`,
                    callback: (val) => {
                        resolve(!!val?.private_isArchived);
                        Onyx.disconnect(connection);
                    },
                });
            });
            expect(isArchived).toBe(false);
        });

        it('correctly implements RedBrickRoad error handling for ChangeReportPolicyAndInviteSubmitter when the request fails to add a new user to workspace', async () => {
            const ownerAccountID = 999;
            const ownerEmail = 'submitter@test.com';
            const adminEmail = 'admin@test.com';
            const mockFetch = getMockFetch(TestHelper.getGlobalFetchMock());

            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID: 'expenseReport123',
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: 'oldPolicy123',
                ownerAccountID,
                total: 15000,
                currency: CONST.CURRENCY.USD,
                stateNum: CONST.REPORT.STATE_NUM.SUBMITTED,
                statusNum: CONST.REPORT.STATUS_NUM.SUBMITTED,
            };

            const newPolicy: OnyxTypes.Policy = {
                ...createRandomPolicy(2),
                id: 'newPolicy456',
                name: 'New Test Policy',
                role: CONST.POLICY.ROLE.ADMIN,
                type: CONST.POLICY.TYPE.TEAM,
                outputCurrency: CONST.CURRENCY.USD,
                isPolicyExpenseChatEnabled: true,
                employeeList: {
                    [adminEmail]: {
                        role: CONST.POLICY.ROLE.ADMIN,
                    },
                    // Note: submitter is NOT in the employee list, which will trigger the invitation
                },
            };

            const employeeList = {
                [adminEmail]: {
                    role: CONST.POLICY.ROLE.ADMIN,
                },
            };

            const submitter = {
                accountID: ownerAccountID,
                login: ownerEmail,
                email: ownerEmail,
            };

            global.fetch = mockFetch;
            mockFetch.pause?.();

            // Setup initial data
            await Promise.all([
                Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`, expenseReport),
                Onyx.set(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`, newPolicy),
                Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {[ownerAccountID]: submitter}),
            ]);
            await waitForBatchedUpdates();

            // Call changeReportPolicyAndInviteSubmitter
            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: newPolicy,
                currentUser: {accountID: 1},
                submitterLogin: ownerEmail,
                managerLogin: '',
                hasViolationsParam: true,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList,
                isReportLastVisibleArchived: false,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // Simulate network failure
            mockFetch.fail?.();
            await (mockFetch.resume?.() as Promise<unknown>);

            // Verify error handling after failure - focus on workspace invitation error
            const policyData = await getOnyxValue(`${ONYXKEYS.COLLECTION.POLICY}${newPolicy.id}`);

            // The submitter should have been added to the employee list with error
            const submitterEmployee = policyData?.employeeList?.[ownerEmail];
            expect(submitterEmployee).toBeTruthy();
            expect(submitterEmployee?.errors).toBeTruthy();
            expect(Object.values(submitterEmployee?.errors ?? {}).at(0)).toEqual(TestHelper.translateLocal('workspace.people.error.genericAdd'));

            // Cleanup
            mockFetch.succeed?.();
        });

        it('should not call API when report has no reportID', async () => {
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID: '',
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: '1',
                ownerAccountID: 1,
            };

            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: createRandomPolicy(Number(2)),
                currentUser: {accountID: 1},
                submitterLogin: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: {},
                isReportLastVisibleArchived: undefined,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.CHANGE_REPORT_POLICY_AND_INVITE_SUBMITTER, 0);
        });

        it('should not call API when report policyID matches the target policy', async () => {
            const targetPolicy = createRandomPolicy(Number(2));
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: targetPolicy.id,
                ownerAccountID: 1,
            };

            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: targetPolicy,
                currentUser: {accountID: 1},
                submitterLogin: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: {},
                isReportLastVisibleArchived: undefined,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.CHANGE_REPORT_POLICY_AND_INVITE_SUBMITTER, 0);
        });

        it('should not call API when report is not an expense report', async () => {
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.CHAT,
                policyID: '1',
                ownerAccountID: 1,
            };

            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: createRandomPolicy(Number(2)),
                currentUser: {accountID: 1},
                submitterLogin: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: {},
                isReportLastVisibleArchived: undefined,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.CHANGE_REPORT_POLICY_AND_INVITE_SUBMITTER, 0);
        });

        it('should not call API when report has no ownerAccountID', async () => {
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: '1',
                ownerAccountID: undefined,
            };

            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: createRandomPolicy(Number(2)),
                currentUser: {accountID: 1},
                submitterLogin: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: {},
                isReportLastVisibleArchived: undefined,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.CHANGE_REPORT_POLICY_AND_INVITE_SUBMITTER, 0);
        });

        it('should not call API when submitter email cannot be found', async () => {
            const ownerAccountID = 9999;
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: '1',
                ownerAccountID,
            };

            // Do not set personal details for ownerAccountID so getLoginByAccountID returns empty
            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: createRandomPolicy(Number(2)),
                currentUser: {accountID: 1},
                submitterLogin: '',
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: {},
                isReportLastVisibleArchived: undefined,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.CHANGE_REPORT_POLICY_AND_INVITE_SUBMITTER, 0);
        });

        it('should invite the submitter and optimistically add them to the policy employee list with USER role', async () => {
            const ownerAccountID = 42;
            const ownerEmail = 'submitter-42@expensifail.com';
            const existingAdminEmail = 'admin-1@expensifail.com';
            const existingUserEmail = 'user-1@expensifail.com';
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
                policyID: 'sourcePolicy',
                ownerAccountID,
            };
            const targetPolicy: OnyxTypes.Policy = {
                ...createRandomPolicy(2),
                id: 'targetPolicy',
                role: CONST.POLICY.ROLE.ADMIN,
                type: CONST.POLICY.TYPE.TEAM,
                isPolicyExpenseChatEnabled: true,
                employeeList: {
                    [existingAdminEmail]: {email: existingAdminEmail, role: CONST.POLICY.ROLE.ADMIN},
                    [existingUserEmail]: {email: existingUserEmail, role: CONST.POLICY.ROLE.USER},
                },
            };

            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${expenseReport.reportID}`, expenseReport);
            await Onyx.set(`${ONYXKEYS.COLLECTION.POLICY}${targetPolicy.id}`, targetPolicy);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {[ownerAccountID]: {login: ownerEmail, accountID: ownerAccountID}});

            const mockFetch = getMockFetch(TestHelper.getGlobalFetchMock());
            global.fetch = mockFetch;
            mockFetch.pause?.();

            Report.changeReportPolicyAndInviteSubmitter({
                report: expenseReport,
                parentReport: undefined,
                policy: targetPolicy,
                currentUser: {accountID: 1, email: 'current-user@expensifail.com'},
                submitterLogin: ownerEmail,
                managerLogin: '',
                hasViolationsParam: false,
                isChangePolicyTrainingModalDismissed: false,
                isASAPSubmitBetaEnabled: false,
                employeeList: targetPolicy.employeeList,
                isReportLastVisibleArchived: false,
                reportNextStep: undefined,
                reportActionsList: {},
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            await waitForBatchedUpdates();

            // While the request is in-flight the optimistic data should show the submitter as a user pending addition
            const optimisticPolicy = await getOnyxValue(`${ONYXKEYS.COLLECTION.POLICY}${targetPolicy.id}`);
            expect(optimisticPolicy?.employeeList?.[ownerEmail]).toEqual(
                expect.objectContaining({
                    email: ownerEmail,
                    role: CONST.POLICY.ROLE.USER,
                    pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                }),
            );

            await mockFetch.resume?.();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.CHANGE_REPORT_POLICY_AND_INVITE_SUBMITTER, 1);
        });
    });

    describe('moveIOUReportToPolicy', () => {
        it('should create moved action on the expense report', async () => {
            const ownerAccountID = 1;
            const ownerEmail = 'owner@gmail.com';
            const adminEmail = 'admin@gmail.com';
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
                ownerAccountID,
            };
            const policy: OnyxTypes.Policy = {
                ...createRandomPolicy(1),
                role: CONST.POLICY.ROLE.ADMIN,
                employeeList: {[adminEmail]: {email: adminEmail, role: CONST.POLICY.ROLE.ADMIN}, [ownerEmail]: {email: ownerEmail, role: CONST.POLICY.ROLE.USER}},
            };

            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [ownerAccountID]: {
                    login: ownerEmail,
                },
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`, iouReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`, policy);

            // When moving iou to a workspace
            Report.moveIOUReportToPolicy(iouReport, policy, undefined);
            await waitForBatchedUpdates();

            // Then MOVED report action should be added to the expense report
            const reportActions = await new Promise<OnyxEntry<OnyxTypes.ReportActions>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${iouReport.reportID}`,
                    callback: (val) => {
                        resolve(val);
                        Onyx.disconnect(connection);
                    },
                });
            });
            expect(Object.values(reportActions ?? {}).at(0)?.actionName).toBe(CONST.REPORT.ACTIONS.TYPE.MOVED);
        });

        it('should return undefined when iouReport is not an IOU report', () => {
            const expenseReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.EXPENSE,
            };
            const policy: OnyxTypes.Policy = {...createRandomPolicy(1), role: CONST.POLICY.ROLE.ADMIN};
            const result = Report.moveIOUReportToPolicy(expenseReport, policy, undefined);
            expect(result).toBeUndefined();
        });

        it('should return undefined when hasRequestFromCurrentAccount is true and isFromSettlementButton is false', async () => {
            const currentUserAccountID = 12;
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
                managerID: currentUserAccountID,
            };
            const policy: OnyxTypes.Policy = {...createRandomPolicy(1), role: CONST.POLICY.ROLE.ADMIN};

            // Create a non-deleted IOU report action from the current account so hasRequestFromCurrentAccount returns true
            const iouReportAction: OnyxTypes.ReportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: '100',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
                actorAccountID: currentUserAccountID,
                created: '2024-01-01 00:00:00',
                message: [{html: '$100.00 expense', text: '$100.00 expense', type: 'COMMENT'}],
            });

            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${iouReport.reportID}`, {[iouReportAction.reportActionID]: iouReportAction});
            await waitForBatchedUpdates();

            const result = Report.moveIOUReportToPolicy(iouReport, policy, undefined, false);
            expect(result).toBeUndefined();
        });

        it('should proceed when hasRequestFromCurrentAccount is true but isFromSettlementButton is true', async () => {
            const currentUserAccountID = 12;
            const ownerAccountID = 1;
            const ownerEmail = 'owner@gmail.com';
            const adminEmail = 'admin@gmail.com';
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
                ownerAccountID,
                managerID: currentUserAccountID,
            };
            const policy: OnyxTypes.Policy = {
                ...createRandomPolicy(1),
                role: CONST.POLICY.ROLE.ADMIN,
                employeeList: {[adminEmail]: {email: adminEmail, role: CONST.POLICY.ROLE.ADMIN}, [ownerEmail]: {email: ownerEmail, role: CONST.POLICY.ROLE.USER}},
            };

            // Create a non-deleted IOU report action from the current account so hasRequestFromCurrentAccount returns true
            const iouReportAction: OnyxTypes.ReportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: '100',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
                actorAccountID: currentUserAccountID,
                created: '2024-01-01 00:00:00',
                message: [{html: '$100.00 expense', text: '$100.00 expense', type: 'COMMENT'}],
            });

            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {[ownerAccountID]: {login: ownerEmail}});
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`, iouReport);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${iouReport.reportID}`, {[iouReportAction.reportActionID]: iouReportAction});
            await Onyx.set(`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`, policy);
            await waitForBatchedUpdates();

            // When isFromSettlementButton is true, it should proceed despite hasRequestFromCurrentAccount being true
            const result = Report.moveIOUReportToPolicy(iouReport, policy, undefined, true);
            expect(result).toBeDefined();
            expect(result?.policyExpenseChatReportID).toBeDefined();
        });

        describe('convertIOUReportToExpenseReport', () => {
            it('should set reportName to default formula when policy field list is empty', () => {
                // Given a policy with an empty field list
                const policyID = '300';
                const policyWithEmptyFieldList: OnyxTypes.Policy = {
                    ...createRandomPolicy(Number(policyID)),
                    id: policyID,
                    type: CONST.POLICY.TYPE.TEAM,
                    fieldList: {},
                    name: 'Test Policy',
                };

                const iouReport: OnyxTypes.Report = {
                    ...createRandomReport(1, undefined),
                    reportID: 'iouReport300',
                    type: CONST.REPORT.TYPE.IOU,
                    ownerAccountID: 1,
                    reportName: 'Original IOU Report Name',
                    total: 10000,
                };

                // Set up minimal Onyx state needed for the function
                Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policyWithEmptyFieldList);

                // When converting IOU report to expense report
                const result = Report.convertIOUReportToExpenseReport(iouReport, policyWithEmptyFieldList, policyID, 'expenseChat123', undefined, []);

                // Then the report name should be set to the default formula result ("New Report")
                const reportUpdate = result.optimisticData.find((update) => update.key === `${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`) as
                    | OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT>
                    | undefined;
                const reportValue = reportUpdate?.value as Partial<OnyxTypes.Report> | undefined;
                expect(reportValue?.reportName).toBe(CONST.REPORT.DEFAULT_EXPENSE_REPORT_NAME);
            });

            it('should set reportName to default formula when policy field list is empty for different report', () => {
                // Given a policy with an empty field list
                const policyID = '301';
                const policyWithEmptyFieldList: OnyxTypes.Policy = {
                    ...createRandomPolicy(Number(policyID)),
                    id: policyID,
                    type: CONST.POLICY.TYPE.TEAM,
                    fieldList: {},
                    name: 'Test Policy',
                };

                const iouReport: OnyxTypes.Report = {
                    ...createRandomReport(2, undefined),
                    reportID: 'iouReport301',
                    type: CONST.REPORT.TYPE.IOU,
                    ownerAccountID: 2,
                    reportName: 'Original IOU Report Name',
                    total: 10000,
                };

                // Set up minimal Onyx state needed for the function
                Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, policyWithEmptyFieldList);

                // When converting IOU report to expense report
                const result = Report.convertIOUReportToExpenseReport(iouReport, policyWithEmptyFieldList, policyID, 'expenseChat124', undefined, []);

                // Then the report name should be set to the default formula result ("New Report")
                const reportUpdate = result.optimisticData.find((update) => update.key === `${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`) as
                    | OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT>
                    | undefined;
                const reportValue = reportUpdate?.value as Partial<OnyxTypes.Report> | undefined;
                expect(reportValue?.reportName).toBe(CONST.REPORT.DEFAULT_EXPENSE_REPORT_NAME);
            });
        });
    });

    describe('moveIOUReportToPolicyAndInviteSubmitter', () => {
        const TEST_USER_ACCOUNT_ID = 1;

        it('should create moved action on the expense report', async () => {
            const ownerAccountID = 1;
            const ownerEmail = 'owner@gmail.com';
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
                ownerAccountID,
            };
            const policy: OnyxTypes.Policy = {...createRandomPolicy(1), role: CONST.POLICY.ROLE.ADMIN};

            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [ownerAccountID]: {
                    login: ownerEmail,
                },
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`, iouReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`, policy);

            // When moving iou to a workspace and invite the submitter
            Report.moveIOUReportToPolicyAndInviteSubmitter(iouReport, policy, {}, undefined, TEST_USER_ACCOUNT_ID, ownerEmail, true);
            await waitForBatchedUpdates();

            // Then MOVED report action should be added to the expense report
            const reportActions = await new Promise<OnyxEntry<OnyxTypes.ReportActions>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${iouReport.reportID}`,
                    callback: (val) => {
                        resolve(val);
                        Onyx.disconnect(connection);
                    },
                });
            });
            expect(Object.values(reportActions ?? {}).at(0)?.actionName).toBe(CONST.REPORT.ACTIONS.TYPE.MOVED);
        });

        it('correctly implements RedBrickRoad error handling for MoveIOUReportToPolicyAndInviteSubmitter when the request fails to add a new user to workspace', async () => {
            const ownerAccountID = 999;
            const ownerEmail = 'submitter@test.com';
            const mockFetch = getMockFetch(TestHelper.getGlobalFetchMock());

            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID: 'iouReport123',
                type: CONST.REPORT.TYPE.IOU,
                ownerAccountID,
                total: 10000,
                currency: CONST.CURRENCY.USD,
                stateNum: CONST.REPORT.STATE_NUM.SUBMITTED,
                statusNum: CONST.REPORT.STATUS_NUM.SUBMITTED,
            };

            const policy: OnyxTypes.Policy = {
                ...createRandomPolicy(1, undefined),
                id: 'policy456',
                name: 'Test Policy for IOU Move',
                role: CONST.POLICY.ROLE.ADMIN,
                type: CONST.POLICY.TYPE.TEAM,
                outputCurrency: CONST.CURRENCY.USD,
                isPolicyExpenseChatEnabled: true,
                employeeList: {
                    'admin@test.com': {
                        role: CONST.POLICY.ROLE.ADMIN,
                    },
                    // Note: submitter is NOT in the employee list, which will trigger the invitation
                },
            };

            const submitter = {
                accountID: ownerAccountID,
                login: ownerEmail,
                email: ownerEmail,
            };

            global.fetch = mockFetch;
            mockFetch.pause?.();

            // Setup initial data
            await Promise.all([
                Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`, iouReport),
                Onyx.set(`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`, policy),
                Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {[ownerAccountID]: submitter}),
            ]);
            await waitForBatchedUpdates();

            // Call moveIOUReportToPolicyAndInviteSubmitter
            Report.moveIOUReportToPolicyAndInviteSubmitter(iouReport, policy, {}, undefined, TEST_USER_ACCOUNT_ID, ownerEmail, true);
            await waitForBatchedUpdates();

            // Simulate network failure
            mockFetch.fail?.();
            await (mockFetch.resume?.() as Promise<unknown>);

            // Verify error handling after failure - focus on workspace invitation error
            const policyData = await new Promise<OnyxEntry<OnyxTypes.Policy>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.POLICY}${policy.id}`,
                    callback: (val) => {
                        resolve(val);
                        Onyx.disconnect(connection);
                    },
                });
            });

            // The submitter should have been added to the employee list with error
            const submitterEmployee = policyData?.employeeList?.[ownerEmail];
            expect(submitterEmployee).toBeTruthy();
            expect(submitterEmployee?.errors).toBeTruthy();
            expect(Object.values(submitterEmployee?.errors ?? {}).at(0)).toEqual(TestHelper.translateLocal('workspace.people.error.genericAdd'));

            // Cleanup
            mockFetch.succeed?.();
        });

        it('should negate transaction amounts when reportTransactions are provided', async () => {
            const ownerAccountID = 1;
            const ownerEmail = 'owner@gmail.com';
            const transactionID = 'txn123';
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
                ownerAccountID,
                total: 5000,
            };
            const policy: OnyxTypes.Policy = {...createRandomPolicy(1), role: CONST.POLICY.ROLE.ADMIN};
            const transaction: OnyxTypes.Transaction = {
                ...createRandomTransaction(1),
                transactionID,
                reportID: iouReport.reportID,
                amount: 5000,
                modifiedAmount: 6000,
                convertedAmount: 6000,
            };

            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [ownerAccountID]: {
                    login: ownerEmail,
                },
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`, iouReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`, policy);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, transaction);

            // When moving IOU to a workspace with reportTransactions
            Report.moveIOUReportToPolicyAndInviteSubmitter(iouReport, policy, {}, undefined, TEST_USER_ACCOUNT_ID, ownerEmail, true, [transaction]);
            await waitForBatchedUpdates();

            // Then the transaction amounts should be negated optimistically
            const updatedTransaction = await new Promise<OnyxEntry<OnyxTypes.Transaction>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`,
                    callback: (val) => {
                        resolve(val);
                        Onyx.disconnect(connection);
                    },
                });
            });
            expect(updatedTransaction?.amount).toBe(-5000);
            expect(updatedTransaction?.modifiedAmount).toBe(-6000);
            expect(updatedTransaction?.convertedAmount).toBe(-6000);
        });

        it('should convert IOU report to expense report with correct policyID when reportTransactions are provided', async () => {
            const ownerAccountID = 1;
            const ownerEmail = 'owner@gmail.com';
            const transactionID = 'txn456';
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
                ownerAccountID,
                total: 3000,
            };
            const policy: OnyxTypes.Policy = {...createRandomPolicy(1), role: CONST.POLICY.ROLE.ADMIN};
            const transaction: OnyxTypes.Transaction = {
                ...createRandomTransaction(1),
                transactionID,
                reportID: iouReport.reportID,
                amount: 3000,
            };

            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [ownerAccountID]: {
                    login: ownerEmail,
                },
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`, iouReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`, policy);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, transaction);

            // When moving IOU to a workspace with transactions
            Report.moveIOUReportToPolicyAndInviteSubmitter(iouReport, policy, {}, undefined, TEST_USER_ACCOUNT_ID, ownerEmail, true, [transaction]);
            await waitForBatchedUpdates();

            // Then the report should be converted to an expense report with the new policyID
            const updatedReport = await new Promise<OnyxEntry<OnyxTypes.Report>>((resolve) => {
                const connection = Onyx.connect({
                    key: `${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`,
                    callback: (val) => {
                        resolve(val);
                        Onyx.disconnect(connection);
                    },
                });
            });
            expect(updatedReport?.type).toBe(CONST.REPORT.TYPE.EXPENSE);
            expect(updatedReport?.policyID).toBe(policy.id);
            expect(updatedReport?.total).toBe(-3000);
        });

        it('should return undefined when policy is missing', () => {
            const iouReport: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                type: CONST.REPORT.TYPE.IOU,
            };
            const result = Report.moveIOUReportToPolicyAndInviteSubmitter(iouReport, undefined as unknown as OnyxTypes.Policy, {}, undefined, TEST_USER_ACCOUNT_ID, '', false);
            expect(result).toBeUndefined();
        });

        it('should return undefined when iouReport is missing', () => {
            const policy: OnyxTypes.Policy = {...createRandomPolicy(1), role: CONST.POLICY.ROLE.ADMIN};
            const result = Report.moveIOUReportToPolicyAndInviteSubmitter(undefined, policy, {}, undefined, TEST_USER_ACCOUNT_ID, '', false);
            expect(result).toBeUndefined();
        });
    });

    describe('buildOptimisticChangePolicyData', () => {
        it('should build the optimistic data next step for the change policy data', () => {
            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                statusNum: CONST.REPORT.STATUS_NUM.SUBMITTED,
                type: CONST.REPORT.TYPE.EXPENSE,
            };
            const policy = createRandomPolicy(Number(1));
            Report.buildOptimisticChangePolicyData({
                report,
                parentReport: undefined,
                policy,
                currentUserAccountID: 1,
                currentUserEmail: '',
                ownerLogin: undefined,
                managerLogin: '',
                hasViolationsParam: false,
                isASAPSubmitBetaEnabled: true,
                isReportLastVisibleArchived: undefined,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });
            expect(buildNextStepNew).toHaveBeenCalledWith({
                report,
                policy,
                currentUserAccountIDParam: 1,
                currentUserEmailParam: '',
                hasViolations: false,
                isASAPSubmitBetaEnabled: true,
                predictedNextStatus: CONST.REPORT.STATUS_NUM.SUBMITTED,
                isTrackIntentUser: false,
            });
        });

        it('should set pendingAction and clear convertedAmount when moving to workspace with different currency', async () => {
            const reportID = 'testReport123';
            const transactionID = 'testTransaction456';
            const transaction = {
                ...createRandomTransaction(1),
                transactionID,
                reportID,
                currency: 'AUD',
                convertedAmount: 15000, // Has a converted amount from old workspace
            };

            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                type: CONST.REPORT.TYPE.EXPENSE,
                currency: 'AUD', // Source report currency
            };

            const policy = {
                ...createRandomPolicy(Number(1)),
                outputCurrency: CONST.CURRENCY.USD, // Destination currency is different
            };

            // Set up the transaction in Onyx so getReportTransactions can find it
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, transaction);
            await waitForBatchedUpdates();

            const {optimisticData, successData, failureData} = Report.buildOptimisticChangePolicyData({
                report,
                parentReport: undefined,
                policy,
                currentUserAccountID: 1,
                currentUserEmail: '',
                ownerLogin: undefined,
                managerLogin: '',
                hasViolationsParam: false,
                isASAPSubmitBetaEnabled: true,
                isReportLastVisibleArchived: undefined,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });

            // Find the transaction optimistic data
            const transactionOptimisticData = optimisticData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);
            const transactionSuccessData = successData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);
            const transactionFailureData = failureData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);

            // Should have pendingAction set to UPDATE
            expect((transactionOptimisticData?.value as OnyxTypes.Transaction)?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE);
            // Should have convertedAmount cleared
            expect((transactionOptimisticData?.value as OnyxTypes.Transaction)?.convertedAmount).toBeNull();

            // Success data should clear pendingAction
            expect((transactionSuccessData?.value as OnyxTypes.Transaction)?.pendingAction).toBeNull();

            // Failure data should restore original values
            expect((transactionFailureData?.value as OnyxTypes.Transaction)?.pendingAction).toBe(transaction.pendingAction ?? null);
            expect((transactionFailureData?.value as OnyxTypes.Transaction)?.convertedAmount).toBe(transaction.convertedAmount);
        });

        it('should NOT clear convertedAmount when source and destination currencies are the same', async () => {
            const reportID = 'testReport789';
            const transactionID = 'testTransaction012';
            const transaction = {
                ...createRandomTransaction(1),
                transactionID,
                reportID,
                currency: 'EUR',
                convertedAmount: 15000,
            };

            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                type: CONST.REPORT.TYPE.EXPENSE,
                currency: CONST.CURRENCY.USD, // Source report currency
            };

            const policy = {
                ...createRandomPolicy(Number(1)),
                outputCurrency: CONST.CURRENCY.USD, // Same as source
            };

            // Set up the transaction in Onyx
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, transaction);
            await waitForBatchedUpdates();

            const {optimisticData} = Report.buildOptimisticChangePolicyData({
                report,
                parentReport: undefined,
                policy,
                currentUserAccountID: 1,
                currentUserEmail: '',
                ownerLogin: undefined,
                managerLogin: '',
                hasViolationsParam: false,
                isASAPSubmitBetaEnabled: true,
                isReportLastVisibleArchived: undefined,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });

            // Should NOT find transaction optimistic data when currencies are the same
            const transactionOptimisticData = optimisticData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);
            expect(transactionOptimisticData).toBeUndefined();
        });

        it('should NOT clear convertedAmount when transaction matches destination currency', async () => {
            const reportID = 'testReport345';
            const transactionID = 'testTransaction678';
            const transaction = {
                ...createRandomTransaction(1),
                transactionID,
                reportID,
                currency: CONST.CURRENCY.USD, // Transaction is in destination currency
                convertedAmount: 15000,
            };

            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                type: CONST.REPORT.TYPE.EXPENSE,
                currency: 'AUD', // Source report currency is different
            };

            const policy = {
                ...createRandomPolicy(Number(1)),
                outputCurrency: CONST.CURRENCY.USD, // Matches transaction currency
            };

            // Set up the transaction in Onyx
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, transaction);
            await waitForBatchedUpdates();

            const {optimisticData} = Report.buildOptimisticChangePolicyData({
                report,
                parentReport: undefined,
                policy,
                currentUserAccountID: 1,
                currentUserEmail: '',
                ownerLogin: undefined,
                managerLogin: '',
                hasViolationsParam: false,
                isASAPSubmitBetaEnabled: true,
                isReportLastVisibleArchived: undefined,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });

            // Should NOT find transaction optimistic data when transaction matches destination currency
            const transactionOptimisticData = optimisticData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);
            expect(transactionOptimisticData).toBeUndefined();
        });

        it('should only clear convertedAmount for non-matching transactions in mixed currency scenario', async () => {
            const reportID = 'testReport999';
            const matchingTransactionID = 'matchingTransaction';
            const nonMatchingTransactionID = 'nonMatchingTransaction';

            // Transaction that matches destination currency (USD)
            const matchingTransaction = {
                ...createRandomTransaction(1),
                transactionID: matchingTransactionID,
                reportID,
                currency: CONST.CURRENCY.USD,
                convertedAmount: 10000,
            };

            // Transaction that doesn't match destination currency (AUD != USD)
            const nonMatchingTransaction = {
                ...createRandomTransaction(2),
                transactionID: nonMatchingTransactionID,
                reportID,
                currency: 'AUD',
                convertedAmount: 15000,
            };

            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                type: CONST.REPORT.TYPE.EXPENSE,
                currency: 'AUD', // Source report currency
            };

            const policy = {
                ...createRandomPolicy(Number(1)),
                outputCurrency: CONST.CURRENCY.USD, // Destination currency
            };

            // Set up both transactions in Onyx
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${matchingTransactionID}`, matchingTransaction);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${nonMatchingTransactionID}`, nonMatchingTransaction);
            await waitForBatchedUpdates();

            const {optimisticData} = Report.buildOptimisticChangePolicyData({
                report,
                parentReport: undefined,
                policy,
                currentUserAccountID: 1,
                currentUserEmail: '',
                ownerLogin: undefined,
                managerLogin: '',
                hasViolationsParam: false,
                isASAPSubmitBetaEnabled: true,
                isReportLastVisibleArchived: undefined,
                reportPreviewAction: undefined,
                isTrackIntentUser: false,
            });

            // Should NOT find optimistic data for the matching transaction (USD matches USD destination)
            const matchingOptimisticData = optimisticData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${matchingTransactionID}`);
            expect(matchingOptimisticData).toBeUndefined();

            // Should find optimistic data for the non-matching transaction (AUD doesn't match USD destination)
            const nonMatchingOptimisticData = optimisticData.find((data) => data.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${nonMatchingTransactionID}`);
            expect(nonMatchingOptimisticData).toBeDefined();
            expect((nonMatchingOptimisticData?.value as OnyxTypes.Transaction)?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE);
            expect((nonMatchingOptimisticData?.value as OnyxTypes.Transaction)?.convertedAmount).toBeNull();
        });

        it('should mark old report preview action as deleted when changing report policy', () => {
            const parentReportID = '2';
            const parentReportActionID = '3';

            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                parentReportID,
                parentReportActionID,
                statusNum: CONST.REPORT.STATUS_NUM.OPEN,
                type: CONST.REPORT.TYPE.EXPENSE,
            };

            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(Number(parentReportID), undefined),
            };

            const reportPreviewAction: OnyxTypes.ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW> = {
                ...createRandomReportAction(Number(parentReportActionID)),
                actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
                originalMessage: {
                    linkedReportID: parentReportID,
                },
                previousMessage: [],
                message: [
                    {
                        translationKey: '',
                        type: 'COMMENT',
                        html: '',
                        text: '',
                        isEdited: false,
                        isDeletedParentAction: false,
                    },
                ],
            };

            const policy = createRandomPolicy(Number(1));

            const {optimisticData, failureData} = Report.buildOptimisticChangePolicyData({
                report,
                parentReport,
                policy,
                currentUserAccountID: 1,
                currentUserEmail: '',
                ownerLogin: undefined,
                managerLogin: '',
                hasViolationsParam: false,
                isASAPSubmitBetaEnabled: true,
                isReportLastVisibleArchived: undefined,
                reportPreviewAction,
                isTrackIntentUser: false,
            });

            const parentReportActionKey = `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`;
            const optimisticReportActionData = optimisticData.find((data) => data.key === parentReportActionKey);
            const failureReportActionData = failureData.find((data) => data.key === parentReportActionKey);

            function isReportActions(value: OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>['value']): value is OnyxTypes.ReportActions {
                return !!value && parentReportActionID in value;
            }

            expect(optimisticReportActionData).toBeDefined();
            const updatedOptimisticAction = isReportActions(optimisticReportActionData?.value) ? optimisticReportActionData.value[parentReportActionID] : undefined;
            const updatedOriginalMessage = updatedOptimisticAction ? getOriginalMessage(updatedOptimisticAction) : undefined;
            expect(updatedOriginalMessage && 'deleted' in updatedOriginalMessage && updatedOriginalMessage.deleted).toBeTruthy();
            expect(Array.isArray(updatedOptimisticAction?.message) && updatedOptimisticAction?.message.at(0)?.deleted).toBeTruthy();

            expect(failureReportActionData).toBeDefined();
            const revertedAction = isReportActions(failureReportActionData?.value) ? failureReportActionData.value[parentReportActionID] : undefined;
            const revertedOriginalMessage = revertedAction ? getOriginalMessage(revertedAction) : undefined;
            expect(revertedOriginalMessage && 'deleted' in revertedOriginalMessage && revertedOriginalMessage.deleted).toBeNull();
        });
    });

    describe('searchInServer', () => {
        it('should return the same result with or without uppercase input.', () => {
            Report.searchInServer('test');
            Report.searchInServer('TEST');
            const upperCaseRequest = PersistedRequests.getAll().at(0);
            const lowerCaseRequest = PersistedRequests.getAll().at(1);
            expect(upperCaseRequest?.data?.searchInput).toBe(lowerCaseRequest?.data?.searchInput);
        });
    });

    describe('searchUserInServer', () => {
        it('should return the same result with or without uppercase input.', () => {
            Report.searchUserInServer('test');
            Report.searchUserInServer('TEST');
            const upperCaseRequest = PersistedRequests.getAll().at(0);
            const lowerCaseRequest = PersistedRequests.getAll().at(1);
            expect(upperCaseRequest?.data?.searchInput).toBe(lowerCaseRequest?.data?.searchInput);
        });
    });

    describe('openReport with introSelected', () => {
        it('should call OpenReport API with introSelected parameter', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '1';

            await Onyx.set(ONYXKEYS.NVP_INTRO_SELECTED, TEST_INTRO_SELECTED);
            await waitForBatchedUpdates();

            Report.openReport({hasReportActions: true, reportID: REPORT_ID, introSelected: TEST_INTRO_SELECTED, betas: undefined, currentUserAccountID: 1});
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        });

        it('should handle openReport with TEST_INTRO_SELECTED', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '2';

            Report.openReport({hasReportActions: true, reportID: REPORT_ID, introSelected: TEST_INTRO_SELECTED, betas: undefined, currentUserAccountID: 1});
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        });

        it('should handle openReport when introSelected is undefined', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '3';

            Report.openReport({hasReportActions: true, reportID: REPORT_ID, introSelected: undefined, betas: undefined, currentUserAccountID: 1});
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        });
    });

    describe('setOptimisticTransactionThread', () => {
        it('should set optimistic transaction thread data with the provided parameters', async () => {
            const reportID = 'report12';
            const parentReportID = 'parentReport34';
            const parentReportActionID = 'parentAction56';
            const policyID = 'policy78';

            Report.setOptimisticTransactionThread(reportID, parentReportID, parentReportActionID, policyID);

            await waitForBatchedUpdates();

            const report = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);

            expect(report).toMatchObject({
                reportID,
                policyID,
                parentReportID,
                parentReportActionID,
                chatReportID: parentReportID,
                type: CONST.REPORT.TYPE.CHAT,
            });
            expect(report?.lastReadTime).toBeTruthy();
            expect(report?.lastVisibleActionCreated).toBeTruthy();
        });

        it('should not set anything if no reportID was provided', async () => {
            const reportID = undefined;

            Report.setOptimisticTransactionThread(reportID);

            await waitForBatchedUpdates();

            const reportsCollectionAfter = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}`);

            expect(reportsCollectionAfter).toBeUndefined();
        });
    });

    describe('navigateToConciergeChat', () => {
        const CONCIERGE_REPORT_ID = '123456';
        const TEST_USER_ACCOUNT_ID = 1;

        const mockNavigation: {navigate: jest.Mock; dismissModalWithReport: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');

        beforeEach(async () => {
            jest.clearAllMocks();
            mockNavigation.navigate.mockClear();
            mockNavigation.dismissModalWithReport.mockClear();
            await Onyx.clear();
            return waitForBatchedUpdates();
        });

        const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

        it('should navigate to concierge chat with provided conciergeReportID', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);

            await waitForBatchedUpdates();

            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should navigate with shouldDismissModal=true when provided', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, true);

            await waitForBatchedUpdates();

            expect(mockNavigation.dismissModalWithReport).toHaveBeenCalled();
        });

        it('should handle undefined conciergeReportID gracefully', async () => {
            // Don't set CONCIERGE_REPORT_ID to simulate undefined state
            await Onyx.set(ONYXKEYS.IS_LOADING_REPORT_DATA, false);
            await waitForBatchedUpdates();

            // When conciergeReportID is undefined, the function uses onServerDataReady()
            // which is async. We're testing that it doesn't throw and handles the case properly.
            expect(() => {
                Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);
            }).not.toThrow();
        });

        it('should navigate with reportActionID when provided', async () => {
            const reportActionID = 'action789';
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, true, undefined, undefined, reportActionID);

            await waitForBatchedUpdates();

            expect(mockNavigation.dismissModalWithReport).toHaveBeenCalledWith({
                reportID: CONCIERGE_REPORT_ID,
                reportActionID,
            });
        });

        it('should navigate with linkToOptions when provided', async () => {
            const linkToOptions = {forceReplace: true};
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false, undefined, linkToOptions);

            await waitForBatchedUpdates();

            expect(mockNavigation.navigate).toHaveBeenCalledWith(expect.any(String), linkToOptions);
        });

        it('should respect checkIfCurrentPageActive callback when creating new concierge chat', async () => {
            const checkIfCurrentPageActive = jest.fn(() => false);
            const navigateToAndOpenReportSpy = jest.spyOn(Report, 'navigateToAndOpenReport');

            // Don't set CONCIERGE_REPORT_ID to simulate undefined state
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false, checkIfCurrentPageActive);

            await waitForBatchedUpdates();

            // Should not navigate if checkIfCurrentPageActive returns false
            expect(navigateToAndOpenReportSpy).not.toHaveBeenCalled();
        });

        it('should handle null conciergeReportID gracefully', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, null);
            await waitForBatchedUpdates();

            // When conciergeReportID is undefined (or null passed as undefined),
            // it should handle it gracefully
            expect(() => {
                Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);
            }).not.toThrow();
        });

        it('should handle empty string conciergeReportID gracefully', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, '');
            await waitForBatchedUpdates();

            // Empty string is falsy in JavaScript, so it should trigger the undefined path
            expect(() => {
                Report.navigateToConciergeChat('', testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);
            }).not.toThrow();
        });

        it('should work with all optional parameters provided', async () => {
            const reportActionID = 'action123';
            const linkToOptions = {forceReplace: true};
            const checkIfCurrentPageActive = jest.fn(() => true);

            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, true, checkIfCurrentPageActive, linkToOptions, reportActionID);

            await waitForBatchedUpdates();

            expect(mockNavigation.dismissModalWithReport).toHaveBeenCalledWith({
                reportID: CONCIERGE_REPORT_ID,
                reportActionID,
            });
        });

        it('should prioritize provided conciergeReportID over Onyx value', async () => {
            const onyxConciergeReportID = 'onyx-report-id';
            const providedConciergeReportID = 'provided-report-id';

            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, onyxConciergeReportID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(providedConciergeReportID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);

            await waitForBatchedUpdates();

            // Should use the provided ID, not the Onyx ID
            expect(mockNavigation.navigate).toHaveBeenCalledWith(expect.stringContaining(providedConciergeReportID), undefined);
        });

        it('should pass betas through to openReport when conciergeReportID is undefined', async () => {
            const TEST_USER_LOGIN = 'test@user.com';

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [CONST.ACCOUNT_ID.CONCIERGE]: {
                    accountID: CONST.ACCOUNT_ID.CONCIERGE,
                    login: CONST.EMAIL.CONCIERGE,
                    displayName: 'Concierge',
                },
            });
            await waitForBatchedUpdates();

            const testBetas = [CONST.BETAS.ALL];

            Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, testBetas, false);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        });

        it('should not throw with any isSelfTourViewed value when conciergeReportID is undefined', async () => {
            await Onyx.set(ONYXKEYS.IS_LOADING_REPORT_DATA, false);
            await waitForBatchedUpdates();

            expect(() => {
                Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, true, undefined, false);
            }).not.toThrow();

            expect(() => {
                Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, false, undefined, false);
            }).not.toThrow();

            expect(() => {
                Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);
            }).not.toThrow();
        });

        it('should navigate via navigateToAndOpenReport with isSelfTourViewed when conciergeReportID is undefined and page is active', async () => {
            const checkIfCurrentPageActive = jest.fn(() => true);

            Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, true, undefined, false, checkIfCurrentPageActive);

            await waitForBatchedUpdates();

            // checkIfCurrentPageActive should have been called, proving the onServerDataReady path was taken
            expect(checkIfCurrentPageActive).toHaveBeenCalled();
            // Navigation should have been triggered (navigateToAndOpenReport calls navigateToReport -> Navigation.navigate)
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should navigate via navigateToAndOpenReport with isSelfTourViewed=undefined when conciergeReportID is undefined', async () => {
            const checkIfCurrentPageActive = jest.fn(() => true);

            Report.navigateToConciergeChat(undefined, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false, checkIfCurrentPageActive);

            await waitForBatchedUpdates();

            expect(checkIfCurrentPageActive).toHaveBeenCalled();
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should navigate correctly with isSelfTourViewed=true and existing conciergeReportID', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, true, undefined, false);

            await waitForBatchedUpdates();

            // When conciergeReportID exists and shouldDismissModal=false, it navigates directly regardless of isSelfTourViewed
            expect(mockNavigation.navigate).toHaveBeenCalledWith(expect.stringContaining(CONCIERGE_REPORT_ID), undefined);
        });

        it('should navigate correctly with isSelfTourViewed=undefined and existing conciergeReportID', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, false);

            await waitForBatchedUpdates();

            expect(mockNavigation.navigate).toHaveBeenCalledWith(expect.stringContaining(CONCIERGE_REPORT_ID), undefined);
        });

        it('should not affect dismissModal behavior based on isSelfTourViewed value', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            // isSelfTourViewed=true should not change dismissModal behavior
            Report.navigateToConciergeChat(CONCIERGE_REPORT_ID, testIntroSelected, TEST_USER_ACCOUNT_ID, true, undefined, true);

            await waitForBatchedUpdates();

            expect(mockNavigation.dismissModalWithReport).toHaveBeenCalledWith({
                reportID: CONCIERGE_REPORT_ID,
                reportActionID: undefined,
            });
        });
    });

    describe('navigateToConciergeChatAndDeleteReport', () => {
        const CONCIERGE_REPORT_ID = '123456';
        const REPORT_ID = '789';
        const TEST_USER_ACCOUNT_ID = 1;
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        const mockNavigation: {navigate: jest.Mock; dismissModalWithReport: jest.Mock; goBack: jest.Mock; popToSidebar: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');

        beforeEach(async () => {
            jest.clearAllMocks();
            mockNavigation.navigate.mockClear();
            mockNavigation.goBack.mockClear();
            mockNavigation.popToSidebar.mockClear();
            await Onyx.clear();
            return waitForBatchedUpdates();
        });

        it('should navigate to concierge chat and delete report with valid conciergeReportID', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChatAndDeleteReport(REPORT_ID, CONCIERGE_REPORT_ID, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined, undefined, undefined);

            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should pop to sidebar when shouldPopToTop is true', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChatAndDeleteReport(
                REPORT_ID,
                CONCIERGE_REPORT_ID,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                undefined,
                true,
                undefined,
            );

            await waitForBatchedUpdates();

            expect(mockNavigation.popToSidebar).toHaveBeenCalled();
            expect(mockNavigation.goBack).not.toHaveBeenCalled();
        });

        it('should handle undefined reportID gracefully', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            expect(() => {
                Report.navigateToConciergeChatAndDeleteReport(undefined, CONCIERGE_REPORT_ID, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined, undefined, undefined);
            }).not.toThrow();
        });

        it('should handle undefined conciergeReportID by using fallback navigation', async () => {
            await Onyx.set(ONYXKEYS.IS_LOADING_REPORT_DATA, false);
            await waitForBatchedUpdates();

            expect(() => {
                Report.navigateToConciergeChatAndDeleteReport(REPORT_ID, undefined, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined, undefined, undefined);
            }).not.toThrow();

            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
        });

        it('should delete child reports when shouldDeleteChildReports is true', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChatAndDeleteReport(
                REPORT_ID,
                CONCIERGE_REPORT_ID,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                undefined,
                false,
                true,
            );

            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
        });

        it('should work with all parameters provided', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChatAndDeleteReport(
                REPORT_ID,
                CONCIERGE_REPORT_ID,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                undefined,
                true,
                true,
            );

            await waitForBatchedUpdates();

            expect(mockNavigation.popToSidebar).toHaveBeenCalled();
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should pass introSelected to navigateToConciergeChat', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChatAndDeleteReport(REPORT_ID, CONCIERGE_REPORT_ID, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined, undefined, undefined);

            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should handle undefined introSelected', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            expect(() => {
                Report.navigateToConciergeChatAndDeleteReport(REPORT_ID, CONCIERGE_REPORT_ID, TEST_USER_ACCOUNT_ID, undefined, undefined, undefined, undefined, undefined, undefined);
            }).not.toThrow();

            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
        });

        it('should pass isSelfTourViewed to navigateToConciergeChat', async () => {
            await Onyx.set(ONYXKEYS.CONCIERGE_REPORT_ID, CONCIERGE_REPORT_ID);
            const testReport = createRandomReport(Number(REPORT_ID), undefined);
            await Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, testReport);
            await waitForBatchedUpdates();

            Report.navigateToConciergeChatAndDeleteReport(REPORT_ID, CONCIERGE_REPORT_ID, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, true, undefined, undefined, undefined, undefined);

            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });
    });

    describe('navigateToAndOpenChildReport', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@domain.com';
        const PARENT_REPORT_ID = '1';
        const CHILD_REPORT_ID = '2';
        const REPORT_ACTION_ID = 1;
        const MOCK_NEW_THREAD_REPORT_ID = '9876';
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        it('should accept a child report ID and navigate to it', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(EXISTING_CHILD_REPORT, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });

        it('should work with undefined child report ID (new thread scenario)', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(undefined, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));
        });

        it('should work with empty parent report action', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(
                EXISTING_CHILD_REPORT,
                createMock<OnyxTypes.ReportAction>({}),
                PARENT_REPORT,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
            );
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });

        it('should create optimistic report when childReportID is provided but report does not exist', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(undefined, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));
        });

        it('should pass introSelected through when creating new child report', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(undefined, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            // Verify navigation happened with the new thread report
            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));

            // Verify the optimistic report was created in Onyx
            const newReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${MOCK_NEW_THREAD_REPORT_ID}`);
            expect(newReport).toBeDefined();
        });

        it('should handle undefined introSelected', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(EXISTING_CHILD_REPORT, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, undefined, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });

        it('should pass betas through to openReport when creating a new child report', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };
            const testBetas = [CONST.BETAS.ALL];

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(undefined, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, testBetas, undefined, undefined);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));
        });

        it.each<[boolean, 'defined' | 'undefined']>([
            [true, 'defined'],
            [false, 'undefined'],
        ])('should pass isSelfTourViewed=%s through to openReport so viewTour.completedTaskReportActionID is %s', async (isSelfTourViewed, expectation) => {
            const CONCIERGE_REPORT_ID = '123456';
            const PARENT_REPORT = createRandomReport(1, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };
            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.SUBMIT, isInviteOnboardingComplete: false};

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [CONST.ACCOUNT_ID.CONCIERGE]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            });
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(undefined, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, introSelected, undefined, undefined, isSelfTourViewed);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            const openReportCall = TestHelper.getFetchMockCalls(WRITE_COMMANDS.OPEN_REPORT).at(0);
            const body = (openReportCall?.at(1) as RequestInit)?.body;
            const guidedSetupDataParam = body instanceof FormData ? body.get('guidedSetupData') : null;
            const guidedSetupData = JSON.parse(typeof guidedSetupDataParam === 'string' ? guidedSetupDataParam : '[]') as Array<{
                type: string;
                task?: string;
                completedTaskReportActionID?: string;
            }>;
            const viewTourTask = guidedSetupData.find((item) => item.type === 'task' && item.task === CONST.ONBOARDING_TASK_TYPE.VIEW_TOUR);
            expect(viewTourTask).toBeDefined();
            if (expectation === 'defined') {
                expect(viewTourTask?.completedTaskReportActionID).toBeDefined();
            } else {
                expect(viewTourTask?.completedTaskReportActionID).toBeUndefined();
            }

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));
        });

        it('should handle undefined isSelfTourViewed when navigating to existing child report', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.navigateToAndOpenChildReport(EXISTING_CHILD_REPORT, PARENT_REPORT_ACTION, PARENT_REPORT, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });
    });

    describe('explain', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@domain.com';
        const PARENT_REPORT_ID = '1';
        const CHILD_REPORT_ID = '2';
        const REPORT_ACTION_ID = 1;
        const MOCK_NEW_THREAD_REPORT_ID = '9876';
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        beforeEach(() => {
            jest.spyOn(global, 'requestAnimationFrame').mockImplementation((cb: FrameRequestCallback) => {
                cb(0);
                return 0;
            });
        });

        afterEach(() => {
            jest.restoreAllMocks();
        });

        it('should return early if originalReport is not provided', () => {
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            const result = Report.explain(
                undefined,
                undefined,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );

            expect(result).toBeUndefined();
        });

        it('should return early if reportAction is not provided', () => {
            const result = Report.explain(
                undefined,
                undefined,
                undefined,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );

            expect(result).toBeUndefined();
        });

        it('should accept report action and original report', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            await waitForBatchedUpdates();

            Report.explain(
                EXISTING_CHILD_REPORT,
                PARENT_REPORT,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });

        it('should work with new explain thread scenario', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.explain(
                undefined,
                PARENT_REPORT,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));

            const newReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${MOCK_NEW_THREAD_REPORT_ID}`);
            const participantAccountIDs = Object.keys(newReport?.participants ?? {}).map(Number);
            expect(participantAccountIDs).toContain(TEST_USER_ACCOUNT_ID);
        });

        it('should handle explain with default timezone parameter', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            await waitForBatchedUpdates();

            Report.explain(EXISTING_CHILD_REPORT, PARENT_REPORT, REPORT_ACTION, TestHelper.translateLocal, TEST_USER_ACCOUNT_ID, INTRO_SELECTED, undefined, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });

        it('should handle undefined introSelected', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            await waitForBatchedUpdates();

            Report.explain(
                EXISTING_CHILD_REPORT,
                PARENT_REPORT,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                undefined,
                undefined,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });

        it('should pass betas through to createChildReport when creating a new explain thread', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };
            const testBetas = [CONST.BETAS.ALL];

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.explain(
                undefined,
                PARENT_REPORT,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                testBetas,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));
        });

        it.each<[boolean, 'defined' | 'undefined']>([
            [true, 'defined'],
            [false, 'undefined'],
        ])('should pass isSelfTourViewed=%s through to createChildReport so viewTour.completedTaskReportActionID is %s', async (isSelfTourViewed, expectation) => {
            const CONCIERGE_REPORT_ID = '123456';
            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.SUBMIT, isInviteOnboardingComplete: false};
            const PARENT_REPORT = createRandomReport(1, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [CONST.ACCOUNT_ID.CONCIERGE]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            });
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            Report.explain(
                undefined,
                PARENT_REPORT,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                introSelected,
                undefined,
                isSelfTourViewed,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            const openReportCall = TestHelper.getFetchMockCalls(WRITE_COMMANDS.OPEN_REPORT).at(0);
            const body = (openReportCall?.at(1) as RequestInit)?.body;
            const guidedSetupDataParam = body instanceof FormData ? body.get('guidedSetupData') : null;
            const guidedSetupData = JSON.parse(typeof guidedSetupDataParam === 'string' ? guidedSetupDataParam : '[]') as Array<{
                type: string;
                task?: string;
                completedTaskReportActionID?: string;
            }>;
            const viewTourTask = guidedSetupData.find((item) => item.type === 'task' && item.task === CONST.ONBOARDING_TASK_TYPE.VIEW_TOUR);
            expect(viewTourTask).toBeDefined();
            if (expectation === 'defined') {
                expect(viewTourTask?.completedTaskReportActionID).toBeDefined();
            } else {
                expect(viewTourTask?.completedTaskReportActionID).toBeUndefined();
            }

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(MOCK_NEW_THREAD_REPORT_ID));
        });

        it('should handle undefined isSelfTourViewed when navigating to existing explain thread', async () => {
            const PARENT_REPORT = createRandomReport(1, undefined);
            const EXISTING_CHILD_REPORT = createRandomReport(2, undefined);
            const REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${CHILD_REPORT_ID}`, EXISTING_CHILD_REPORT);
            await waitForBatchedUpdates();

            Report.explain(
                EXISTING_CHILD_REPORT,
                PARENT_REPORT,
                REPORT_ACTION,
                TestHelper.translateLocal,
                TEST_USER_ACCOUNT_ID,
                INTRO_SELECTED,
                undefined,
                undefined,
                undefined,
                undefined,
                CONST.DEFAULT_TIME_ZONE,
            );
            await waitForBatchedUpdates();

            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_CHILD_REPORT.reportID));
        });
    });

    describe('toggleSubscribeToChildReport', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@domain.com';
        const PARENT_REPORT_ID = '1';
        const CHILD_REPORT_ID = '2';
        const REPORT_ACTION_ID = 1;
        const INTRO_SELECTED: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

        it('should subscribe to an existing child report with introSelected', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(
                    CHILD_REPORT_ID,
                    TEST_USER_ACCOUNT_ID,
                    PARENT_REPORT_ACTION,
                    PARENT_REPORT,
                    INTRO_SELECTED,
                    false,
                    undefined,
                    undefined,
                    'hidden',
                    undefined,
                );
            }).not.toThrow();
        });

        it('should create a new child report when childReportID is undefined', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(undefined, TEST_USER_ACCOUNT_ID, PARENT_REPORT_ACTION, PARENT_REPORT, INTRO_SELECTED, false, undefined, undefined, undefined, undefined);
            }).not.toThrow();
        });

        it('should handle undefined introSelected', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(CHILD_REPORT_ID, TEST_USER_ACCOUNT_ID, PARENT_REPORT_ACTION, PARENT_REPORT, undefined, true, undefined, undefined, 'hidden', undefined);
            }).not.toThrow();
        });

        it('should unsubscribe from child report when already subscribed', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(
                    CHILD_REPORT_ID,
                    TEST_USER_ACCOUNT_ID,
                    PARENT_REPORT_ACTION,
                    PARENT_REPORT,
                    INTRO_SELECTED,
                    true,
                    undefined,
                    undefined,
                    CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    undefined,
                );
            }).not.toThrow();
        });

        it('should pass isSelfTourViewed=true when creating new child report', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(undefined, TEST_USER_ACCOUNT_ID, PARENT_REPORT_ACTION, PARENT_REPORT, INTRO_SELECTED, true, undefined, undefined, undefined, undefined);
            }).not.toThrow();
        });

        it('should pass isSelfTourViewed=false when creating new child report', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(undefined, TEST_USER_ACCOUNT_ID, PARENT_REPORT_ACTION, PARENT_REPORT, INTRO_SELECTED, false, undefined, undefined, undefined, undefined);
            }).not.toThrow();
        });

        it('should handle isSelfTourViewed with existing child report and hidden preference', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(
                    CHILD_REPORT_ID,
                    TEST_USER_ACCOUNT_ID,
                    PARENT_REPORT_ACTION,
                    PARENT_REPORT,
                    INTRO_SELECTED,
                    true,
                    undefined,
                    undefined,
                    'hidden',
                    undefined,
                );
            }).not.toThrow();
        });

        it('should handle isSelfTourViewed with existing child report and no previous notification preference', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(
                    CHILD_REPORT_ID,
                    TEST_USER_ACCOUNT_ID,
                    PARENT_REPORT_ACTION,
                    PARENT_REPORT,
                    INTRO_SELECTED,
                    false,
                    undefined,
                    undefined,
                    undefined,
                    undefined,
                );
            }).not.toThrow();
        });

        it('should pass betas to openReport when subscribing to an existing child report', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
                childReportID: CHILD_REPORT_ID,
            };
            const testBetas = [CONST.BETAS.ALL];

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(
                    CHILD_REPORT_ID,
                    TEST_USER_ACCOUNT_ID,
                    PARENT_REPORT_ACTION,
                    PARENT_REPORT,
                    INTRO_SELECTED,
                    undefined,
                    undefined,
                    testBetas,
                    'hidden',
                    undefined,
                );
            }).not.toThrow();
        });

        it('should pass betas through to openReport when creating a new child report', async () => {
            const PARENT_REPORT = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const PARENT_REPORT_ACTION: OnyxTypes.ReportAction = {
                ...createRandomReportAction(REPORT_ACTION_ID),
                reportActionID: '1',
                actorAccountID: TEST_USER_ACCOUNT_ID,
            };
            const testBetas = [CONST.BETAS.ALL];

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            Onyx.set(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, PARENT_REPORT);
            await waitForBatchedUpdates();

            expect(() => {
                Report.toggleSubscribeToChildReport(
                    undefined,
                    TEST_USER_ACCOUNT_ID,
                    PARENT_REPORT_ACTION,
                    PARENT_REPORT,
                    INTRO_SELECTED,
                    undefined,
                    undefined,
                    testBetas,
                    undefined,
                    undefined,
                );
            }).not.toThrow();
        });
    });

    describe('buildOptimisticResolvedFollowups', () => {
        it('should return null when reportAction is undefined', () => {
            const result = Report.buildOptimisticResolvedFollowups(undefined);
            expect(result).toBeNull();
        });

        it('should return null when reportAction has no followup-list', () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: '123',
                message: [{html: '<p>Hello world</p>', text: 'Hello world', type: CONST.REPORT.MESSAGE.TYPE.COMMENT}],
            });

            const result = Report.buildOptimisticResolvedFollowups(reportAction);
            expect(result).toBeNull();
        });

        it('should return null when followup-list is already resolved (has selected attribute)', () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: '123',
                message: [
                    {
                        html: '<p>Message</p><followup-list selected><followup><followup-text>Question?</followup-text></followup></followup-list>',
                        text: 'Message',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            const result = Report.buildOptimisticResolvedFollowups(reportAction);
            expect(result).toBeNull();
        });

        it('should return updated action with resolved followup-list when unresolved followups exist', () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: '123',
                actorAccountID: CONST.ACCOUNT_ID.CONCIERGE,
                message: [
                    {
                        html: '<p>Here is some help</p><followup-list><followup><followup-text>How do I set up QuickBooks?</followup-text></followup></followup-list>',
                        text: 'Here is some help',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            const result = Report.buildOptimisticResolvedFollowups(reportAction);

            expect(result).not.toBeNull();

            expect(result?.reportActionID).toBe('123');
            expect((result?.message as Message[]).at(0)?.html).toContain('<followup-list selected>');
            expect((result?.message as Message[]).at(0)?.html).not.toMatch(/<followup-list>/);
        });

        it('should handle followup-list with attributes before adding selected', () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: '456',
                message: [
                    {
                        html: '<p>Help</p><followup-list class="test"><followup><followup-text>Question 1</followup-text></followup><followup><followup-text>Question 2</followup-text></followup></followup-list>',
                        text: 'Help',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            const result = Report.buildOptimisticResolvedFollowups(reportAction);

            expect(result).not.toBeNull();
            expect((result?.message as Message[]).at(0)?.html).toContain('<followup-list selected>');
        });
    });

    describe('resolveSuggestedFollowup', () => {
        const REPORT_ID = '12345';
        const REPORT_ACTION_ID = '67890';
        const report = createMock<OnyxTypes.Report>({
            reportID: REPORT_ID,
            type: CONST.REPORT.TYPE.CHAT,
        });
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_EMAIL = 'test@example.com';

        it('should do nothing when reportAction has no unresolved followups', async () => {
            const htmlMessage = '<p>Just a regular message</p>';
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: REPORT_ACTION_ID,
                message: [
                    {
                        html: htmlMessage,
                        text: 'Just a regular message',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`, {
                [REPORT_ACTION_ID]: reportAction,
            });
            await waitForBatchedUpdates();

            resolveSuggestedFollowup(report, undefined, reportAction, {text: 'test question'}, CONST.DEFAULT_TIME_ZONE, TEST_USER_ACCOUNT_ID, TEST_USER_EMAIL, undefined, undefined);
            await waitForBatchedUpdates();

            // The report action should remain unchanged (no followup-list to resolve)
            const reportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}` as const);
            expect((reportActions?.[REPORT_ACTION_ID]?.message as Message[])?.at(0)?.html).toBe(htmlMessage);
        });

        it('should optimistically resolve followups and post comment when unresolved followups exist', async () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: REPORT_ACTION_ID,
                actorAccountID: CONST.ACCOUNT_ID.CONCIERGE,
                message: [
                    {
                        html: '<p>Here is help</p><followup-list><followup><followup-text>How do I set up QuickBooks?</followup-text></followup></followup-list>',
                        text: 'Here is help',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            // Set up initial Onyx state
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`, {
                [REPORT_ACTION_ID]: reportAction,
            });
            await waitForBatchedUpdates();

            resolveSuggestedFollowup(
                report,
                undefined,
                reportAction,
                {text: 'How do I set up QuickBooks?'},
                CONST.DEFAULT_TIME_ZONE,
                TEST_USER_ACCOUNT_ID,
                TEST_USER_EMAIL,
                undefined,
                undefined,
            );
            await waitForBatchedUpdates();

            // Verify the followup-list was marked as selected
            const reportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}` as const);
            const updatedHtml = (reportActions?.[REPORT_ACTION_ID]?.message as Message[])?.at(0)?.html;
            expect(updatedHtml).toContain('<followup-list selected>');

            // Verify addComment was called (which triggers ADD_COMMENT API call)
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
        });

        it('should optimistically resolve followups and post comment with pre-generated response when response is provided', async () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: REPORT_ACTION_ID,
                actorAccountID: CONST.ACCOUNT_ID.CONCIERGE,
                message: [
                    {
                        html: '<p>Here is help</p><followup-list><followup><followup-text>How do I set up QuickBooks?</followup-text><followup-response>To set up QuickBooks, go to Settings...</followup-response></followup></followup-list>',
                        text: 'Here is help',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            // Set up initial Onyx state with real timers
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`, {
                [REPORT_ACTION_ID]: reportAction,
            });
            await waitForBatchedUpdates();

            resolveSuggestedFollowup(
                report,
                undefined,
                reportAction,
                {text: 'How do I set up QuickBooks?', response: 'To set up QuickBooks, go to Settings...'},
                CONST.DEFAULT_TIME_ZONE,
                TEST_USER_ACCOUNT_ID,
                TEST_USER_EMAIL,
                undefined,
                undefined,
            );
            await waitForBatchedUpdates();

            // Verify the followup-list was marked as selected
            const reportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}` as const);
            const updatedHtml = (reportActions?.[REPORT_ACTION_ID]?.message as Message[])?.at(0)?.html;
            expect(updatedHtml).toContain('<followup-list selected>');

            // Verify addComment was called (which triggers ADD_COMMENT API call)
            // With pre-generated response, the API call should include the optimistic Concierge response params
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);

            // Verify the pending concierge response was written to Onyx (the hook will process it)
            const pendingResponse = await getOnyxValue(`${ONYXKEYS.COLLECTION.PENDING_CONCIERGE_RESPONSE}${REPORT_ID}` as const);
            expect(pendingResponse).not.toBeNull();
            expect(pendingResponse?.reportAction.actorAccountID).toBe(CONST.ACCOUNT_ID.CONCIERGE);
            expect(pendingResponse?.displayAfter).toBeGreaterThan(Date.now() - CONCIERGE_RESPONSE_DELAY_MS);

            expect(apiWriteSpy).toHaveBeenCalledWith(
                WRITE_COMMANDS.ADD_COMMENT,
                expect.objectContaining({
                    optimisticConciergeReportActionID: pendingResponse?.reportAction.reportActionID,
                    optimisticConciergeCreated: pendingResponse?.reportAction.created,
                }),
                expect.anything(),
            );

            // Verify the client did NOT set REPORT_USER_IS_TYPING. The server-owned
            // agentZeroProcessingIndicator is the source of truth for the "Concierge is thinking..."
            // state during the delayed pre-generated response window.
            const typingStatus = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_USER_IS_TYPING}${REPORT_ID}` as const);
            expect(typingStatus?.[CONST.ACCOUNT_ID.CONCIERGE]).toBeFalsy();
        });

        it('should create Concierge response with timestamp strictly after the user comment', async () => {
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: REPORT_ACTION_ID,
                actorAccountID: CONST.ACCOUNT_ID.CONCIERGE,
                message: [
                    {
                        html: '<p>Here is help</p><followup-list><followup><followup-text>How do I set up QuickBooks?</followup-text><followup-response>To set up QuickBooks, go to Settings...</followup-response></followup></followup-list>',
                        text: 'Here is help',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`, {
                [REPORT_ACTION_ID]: reportAction,
            });
            await waitForBatchedUpdates();

            resolveSuggestedFollowup(
                report,
                undefined,
                reportAction,
                {text: 'How do I set up QuickBooks?', response: 'To set up QuickBooks, go to Settings...'},
                CONST.DEFAULT_TIME_ZONE,
                TEST_USER_ACCOUNT_ID,
                TEST_USER_EMAIL,
                undefined,
                undefined,
            );
            await waitForBatchedUpdates();

            // Get the pending Concierge response and verify its created timestamp
            const pendingResponse = await getOnyxValue(`${ONYXKEYS.COLLECTION.PENDING_CONCIERGE_RESPONSE}${REPORT_ID}` as const);
            expect(pendingResponse).not.toBeNull();

            // Find the user's comment action (any new action that isn't the original Concierge message)
            const reportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}` as const);
            const userCommentAction = Object.values(reportActions ?? {}).find(
                (action) => action?.reportActionID !== REPORT_ACTION_ID && action?.actorAccountID !== CONST.ACCOUNT_ID.CONCIERGE,
            );

            // The Concierge response timestamp should be strictly after the user comment
            expect(userCommentAction).toBeDefined();
            expect(userCommentAction?.created).toBeDefined();
            expect(pendingResponse?.reportAction.created).toBeDefined();
            expect(new Date(pendingResponse?.reportAction.created ?? 0).getTime()).toBeGreaterThan(new Date(userCommentAction?.created ?? 0).getTime());
        });

        it('should emit Log.info followup_clicked telemetry when a suggested followup is resolved', async () => {
            const logInfoSpy = jest.spyOn(Log, 'info');
            const reportAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: REPORT_ACTION_ID,
                actorAccountID: CONST.ACCOUNT_ID.CONCIERGE,
                message: [
                    {
                        html: '<p>Here is help</p><followup-list><followup><followup-text>How do I set up QuickBooks?</followup-text></followup></followup-list>',
                        text: 'Here is help',
                        type: CONST.REPORT.MESSAGE.TYPE.COMMENT,
                    },
                ],
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`, {
                [REPORT_ACTION_ID]: reportAction,
            });
            await waitForBatchedUpdates();

            resolveSuggestedFollowup(
                report,
                undefined,
                reportAction,
                {text: 'How do I set up QuickBooks?'},
                CONST.DEFAULT_TIME_ZONE,
                TEST_USER_ACCOUNT_ID,
                TEST_USER_EMAIL,
                undefined,
                undefined,
            );
            await waitForBatchedUpdates();

            const telemetryCall = logInfoSpy.mock.calls.find((args) => {
                const params = args.at(2);
                return !!params && typeof params === 'object' && !Array.isArray(params) && (params as Record<string, unknown>).event === 'followup_clicked';
            });
            expect(telemetryCall).toBeDefined();

            logInfoSpy.mockRestore();
        });
    });

    describe('resolveConciergeCategoryOptions', () => {
        it('posts the selected category back to Concierge as a comment (routes through resolveConciergeOptions → addComment)', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();
            const REPORT_ID = 'concierge-opts-1';
            const report = createMock<OnyxTypes.Report>({reportID: REPORT_ID, type: CONST.REPORT.TYPE.CHAT});
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await waitForBatchedUpdates();

            // When the user picks one of the Concierge-suggested category options
            Report.resolveConciergeCategoryOptions(report, REPORT_ID, '5150', 'Food', CONST.DEFAULT_TIME_ZONE, 1, undefined);
            await waitForBatchedUpdates();

            // Then the selection is posted back to Concierge as a comment
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
        });
    });

    // Shared test constants for leave functions
    const TEST_CONCIERGE_REPORT_ID = '999';
    const TEST_CURRENT_USER_ACCOUNT_ID = 1;

    describe('leaveGroupChat', () => {
        const GROUP_CHAT_REPORT_ID = '1001';

        beforeEach(async () => {
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should call LEAVE_GROUP_CHAT API with correct parameters', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.CONCIERGE_REPORT_ID, TEST_CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });

        it('should remove report from Onyx on success', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await waitForBatchedUpdates();

            Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            // After success, the report should be removed from Onyx (set to null)
            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}` as const);
            expect(updatedReport).toBeFalsy();
        });

        it('should clear quick action when shouldClearQuickAction is true', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE, {
                action: CONST.QUICK_ACTIONS.SEND_MONEY,
                chatReportID: GROUP_CHAT_REPORT_ID,
            });
            await waitForBatchedUpdates();

            Report.leaveGroupChat(groupChatReport, true, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            const quickAction = await getOnyxValue(ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE);
            // Onyx returns undefined when a key is set to null
            expect(quickAction).toBeFalsy();
        });

        it('should not clear quick action when shouldClearQuickAction is false', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            const quickActionValue = {
                action: CONST.QUICK_ACTIONS.SEND_MONEY,
                chatReportID: 'other-report-id',
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE, quickActionValue);
            await waitForBatchedUpdates();

            Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            const quickAction = await getOnyxValue(ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE);
            expect(quickAction).not.toBeNull();
        });

        it('should work with undefined conciergeReportID', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await waitForBatchedUpdates();

            // Should not throw an error with undefined conciergeReportID
            expect(() => {
                Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, undefined, TEST_INTRO_SELECTED, undefined);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });
    });

    describe('leaveRoom', () => {
        const ROOM_REPORT_ID = '2001';
        const PARENT_REPORT_ID = '2002';
        const PARENT_REPORT_ACTION_ID = '3001';

        beforeEach(async () => {
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should call LEAVE_ROOM API with correct parameters', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await Onyx.merge(ONYXKEYS.CONCIERGE_REPORT_ID, TEST_CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });

        it('should set hidden notification preference when workspace member is leaving workspace room', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, true);
            await waitForBatchedUpdates();

            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}` as const);
            expect(updatedReport?.participants?.[TEST_CURRENT_USER_ACCOUNT_ID]?.notificationPreference).toBe(CONST.REPORT.NOTIFICATION_PREFERENCE.HIDDEN);
            // When workspace member is leaving, the report should NOT be closed
            expect(updatedReport?.stateNum).not.toBe(CONST.REPORT.STATE_NUM.APPROVED);
        });

        it('should only keep reportName on success when non-workspace member leaves room', async () => {
            TestHelper.getGlobalFetchMock();

            const reportName = 'Test Room';
            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                reportName,
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            await waitForBatchedUpdates();

            // After success, the report should only have reportName (all other fields removed)
            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}` as const);
            expect(updatedReport?.reportName).toBe(reportName);
            // Other fields should be removed
            expect(updatedReport?.participants).toBeUndefined();
        });

        it('should update parent report action when leaving a thread', async () => {
            TestHelper.getGlobalFetchMock();

            const threadReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                type: CONST.REPORT.TYPE.CHAT,
                parentReportID: PARENT_REPORT_ID,
                parentReportActionID: PARENT_REPORT_ACTION_ID,
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            const parentReportAction = {
                ...createRandomReportAction(Number(PARENT_REPORT_ACTION_ID)),
                childReportNotificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, threadReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${PARENT_REPORT_ID}`, {
                [PARENT_REPORT_ACTION_ID]: parentReportAction,
            });
            await waitForBatchedUpdates();

            Report.leaveRoom(threadReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            await waitForBatchedUpdates();

            const updatedParentReportActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${PARENT_REPORT_ID}` as const);
            expect(updatedParentReportActions?.[PARENT_REPORT_ACTION_ID]?.childReportNotificationPreference).toBe(CONST.REPORT.NOTIFICATION_PREFERENCE.HIDDEN);
        });

        it('should work with undefined conciergeReportID', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            // Should not throw an error with undefined conciergeReportID
            expect(() => {
                Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, undefined, TEST_INTRO_SELECTED, undefined, false);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });

        it('should handle leaving a chat thread correctly', async () => {
            TestHelper.getGlobalFetchMock();

            const parentReport = createRandomReport(Number(PARENT_REPORT_ID), undefined);
            const threadReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), undefined),
                type: CONST.REPORT.TYPE.CHAT,
                parentReportID: PARENT_REPORT_ID,
                parentReportActionID: PARENT_REPORT_ACTION_ID,
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, parentReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, threadReport);
            await waitForBatchedUpdates();

            Report.leaveRoom(threadReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            await waitForBatchedUpdates();

            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}` as const);
            // Chat threads should only hide notification preference, not close the report
            expect(updatedReport?.participants?.[TEST_CURRENT_USER_ACCOUNT_ID]?.notificationPreference).toBe(CONST.REPORT.NOTIFICATION_PREFERENCE.HIDDEN);
        });

        it('should pass introSelected through to navigateToMostRecentReport', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            // Should not throw when introSelected is provided
            expect(() => {
                Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });
    });

    describe('leaveGroupChat with introSelected', () => {
        const GROUP_CHAT_REPORT_ID = '1001';

        beforeEach(async () => {
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should pass introSelected through to navigateToMostRecentReport', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.CONCIERGE_REPORT_ID, TEST_CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            // Should not throw and should call the API
            Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });

        it('should accept introSelected with different onboarding choices', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            const customIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.PERSONAL_SPEND};

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.CONCIERGE_REPORT_ID, TEST_CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            expect(() => {
                Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, customIntroSelected, undefined);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });

        it('should handle undefined introSelected', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.CONCIERGE_REPORT_ID, TEST_CONCIERGE_REPORT_ID);
            await waitForBatchedUpdates();

            expect(() => {
                Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, undefined, undefined);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });
    });

    describe('leaveRoom with introSelected', () => {
        const ROOM_REPORT_ID = '2001';

        beforeEach(async () => {
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should accept introSelected with different onboarding choices', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            const customIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM};

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            expect(() => {
                Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, customIntroSelected, undefined, false);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });

        it('should handle undefined introSelected', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            expect(() => {
                Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, undefined, undefined, false);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });

        it('should handle empty introSelected object', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            expect(() => {
                Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, {}, undefined, false);
            }).not.toThrow();

            await waitForBatchedUpdates();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });
    });

    describe('navigateToMostRecentReport via leaveRoom', () => {
        const ROOM_REPORT_ID = '2001';
        const OTHER_REPORT_ID = '5001';

        const mockNavigation: {goBack: jest.Mock; dismissToSuperWideRHP: jest.Mock; navigate: jest.Mock; getTopmostSuperWideRHPReportID: jest.Mock} =
            jest.requireMock('@libs/Navigation/Navigation');

        beforeEach(async () => {
            jest.clearAllMocks();
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should navigate to last accessed report when one exists', async () => {
            TestHelper.getGlobalFetchMock();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            // Create another report that findLastAccessedReport can return
            const otherReport = {
                ...createRandomReport(Number(OTHER_REPORT_ID), undefined),
                lastVisibleActionCreated: new Date().toISOString(),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${OTHER_REPORT_ID}`, otherReport);
            await Onyx.merge(ONYXKEYS.SESSION, {accountID: TEST_CURRENT_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            await waitForBatchedUpdates();

            // Should navigate via goBack since there's another report to navigate to
            expect(mockNavigation.goBack).toHaveBeenCalled();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });

        it('should navigate to concierge when leaving a chat thread and no other report exists', async () => {
            TestHelper.getGlobalFetchMock();

            const PARENT_REPORT_ID = '2002';
            const PARENT_REPORT_ACTION_ID = '3001';

            const threadReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), undefined),
                type: CONST.REPORT.TYPE.CHAT,
                parentReportID: PARENT_REPORT_ID,
                parentReportActionID: PARENT_REPORT_ACTION_ID,
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, threadReport);
            await Onyx.merge(ONYXKEYS.SESSION, {accountID: TEST_CURRENT_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            // Chat thread with no other report → navigateToMostRecentReport calls navigateToConciergeChat without goBack
            Report.leaveRoom(threadReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, false);
            await waitForBatchedUpdates();

            // For chat threads, goBack should NOT be called before navigating to concierge (the isChatThread branch)
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });
    });

    describe('navigateToMostRecentReport via leaveGroupChat', () => {
        const GROUP_CHAT_REPORT_ID = '1001';
        const OTHER_REPORT_ID = '5001';

        const mockNavigation: {goBack: jest.Mock; navigate: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');

        beforeEach(async () => {
            jest.clearAllMocks();
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should navigate to last accessed report when one exists', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            const otherReport = {
                ...createRandomReport(Number(OTHER_REPORT_ID), undefined),
                lastVisibleActionCreated: new Date().toISOString(),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${OTHER_REPORT_ID}`, otherReport);
            await Onyx.merge(ONYXKEYS.SESSION, {accountID: TEST_CURRENT_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            expect(mockNavigation.goBack).toHaveBeenCalled();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });

        it('should navigate to concierge when no other report exists', async () => {
            TestHelper.getGlobalFetchMock();

            const groupChatReport = {
                ...createRandomReport(Number(GROUP_CHAT_REPORT_ID), CONST.REPORT.CHAT_TYPE.GROUP),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`, groupChatReport);
            await Onyx.merge(ONYXKEYS.SESSION, {accountID: TEST_CURRENT_USER_ACCOUNT_ID});
            await waitForBatchedUpdates();

            Report.leaveGroupChat(groupChatReport, false, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined);
            await waitForBatchedUpdates();

            // With no other reports, navigateToMostRecentReport calls goBack (not a chat thread) then navigateToConciergeChat
            expect(mockNavigation.goBack).toHaveBeenCalled();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_GROUP_CHAT, 1);
        });
    });

    describe('leaveRoom dismissModal branch', () => {
        const ROOM_REPORT_ID = '2001';

        beforeEach(async () => {
            await Onyx.clear();
            await waitForBatchedUpdates();
        });

        it('should dismiss modal when workspace member leaves a non-thread workspace room', async () => {
            TestHelper.getGlobalFetchMock();

            const mockNavigation: {dismissModal: jest.Mock; goBack: jest.Mock; navigate: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');
            mockNavigation.dismissModal.mockClear();

            const roomReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, roomReport);
            await waitForBatchedUpdates();

            // isWorkspaceMemberLeavingWorkspaceRoom=true and report is NOT a chat thread → should dismissModal
            Report.leaveRoom(roomReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, true);
            await waitForBatchedUpdates();

            expect(mockNavigation.dismissModal).toHaveBeenCalled();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });

        it('should NOT dismiss modal when workspace member leaves a chat thread in workspace room', async () => {
            TestHelper.getGlobalFetchMock();

            const mockNavigation: {dismissModal: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');
            mockNavigation.dismissModal.mockClear();

            const PARENT_REPORT_ID = '2002';
            const PARENT_REPORT_ACTION_ID = '3001';

            // A chat thread has parentReportID and parentReportActionID set
            const threadReport = {
                ...createRandomReport(Number(ROOM_REPORT_ID), CONST.REPORT.CHAT_TYPE.POLICY_ROOM),
                type: CONST.REPORT.TYPE.CHAT,
                parentReportID: PARENT_REPORT_ID,
                parentReportActionID: PARENT_REPORT_ACTION_ID,
                participants: {
                    [TEST_CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ROOM_REPORT_ID}`, threadReport);
            await waitForBatchedUpdates();

            // isWorkspaceMemberLeavingWorkspaceRoom=true but report IS a chat thread → should NOT dismissModal, should navigateToMostRecentReport instead
            Report.leaveRoom(threadReport, TEST_CURRENT_USER_ACCOUNT_ID, TEST_CONCIERGE_REPORT_ID, TEST_INTRO_SELECTED, undefined, true);
            await waitForBatchedUpdates();

            expect(mockNavigation.dismissModal).not.toHaveBeenCalled();
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.LEAVE_ROOM, 1);
        });
    });

    describe('navigateToAndCreateGroupChat', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@user.com';
        const PARTICIPANT_1_LOGIN = 'participant1@test.com';
        const PARTICIPANT_1_ACCOUNT_ID = 2;
        const KNOWN_PARTICIPANTS_PERSONAL_DETAILS = {
            [TEST_USER_ACCOUNT_ID]: {accountID: TEST_USER_ACCOUNT_ID, login: TEST_USER_LOGIN, displayName: 'Test user account'},
            [PARTICIPANT_1_ACCOUNT_ID]: {accountID: PARTICIPANT_1_ACCOUNT_ID, login: PARTICIPANT_1_LOGIN, displayName: 'Participant One'},
        };

        beforeEach(async () => {
            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [CONST.ACCOUNT_ID.CONCIERGE]: {
                    accountID: CONST.ACCOUNT_ID.CONCIERGE,
                    login: CONST.EMAIL.CONCIERGE,
                    displayName: 'Concierge',
                },
                [TEST_USER_ACCOUNT_ID]: {
                    accountID: TEST_USER_ACCOUNT_ID,
                    login: TEST_USER_LOGIN,
                    displayName: 'Test user account',
                },
                [PARTICIPANT_1_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_1_ACCOUNT_ID,
                    login: PARTICIPANT_1_LOGIN,
                    displayName: 'Participant One',
                },
            });
            await waitForBatchedUpdates();
        });

        it('should create a group chat and navigate to it', async () => {
            // Given a test user with initial data
            const GROUP_CHAT_NAME = 'Test Group';
            const GROUP_CHAT_REPORT_ID = '12345';
            const CONCIERGE_REPORT_ID = '99999';

            // Create a Concierge chat for guided setup
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                chatType: undefined,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                    [TEST_USER_ACCOUNT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                },
            });

            // Set up introSelected and onboarding state for guided setup
            await Onyx.set(ONYXKEYS.NVP_INTRO_SELECTED, TEST_INTRO_SELECTED);
            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            // When create group chat is called
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: KNOWN_PARTICIPANTS_PERSONAL_DETAILS,
                reportName: GROUP_CHAT_NAME,
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: TEST_INTRO_SELECTED,
                isSelfTourViewed: false,
                hasCompletedGuidedSetupFlow: undefined,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
            });
            await waitForBatchedUpdates();

            // Then it should create a new group chat report in Onyx
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);

            // Then verify the group chat was created with correct properties
            expect(newGroupChatReport).not.toBeNull();
            expect(newGroupChatReport?.reportName).toBe(GROUP_CHAT_NAME);
            expect(newGroupChatReport?.chatType).toBe(CONST.REPORT.CHAT_TYPE.GROUP);

            // Then verify the participants were added to the group chat
            const participantAccountIDs = Object.keys(newGroupChatReport?.participants ?? {}).map(Number);
            expect(participantAccountIDs).toContain(TEST_USER_ACCOUNT_ID);
            expect(participantAccountIDs).toContain(PARTICIPANT_1_ACCOUNT_ID);

            // Then verify isInviteOnboardingComplete is set to true after creating group chat
            const introSelected = await getOnyxValue(ONYXKEYS.NVP_INTRO_SELECTED);
            expect(introSelected?.isInviteOnboardingComplete).toBe(true);
        });

        it('should create group chat with avatar URI and isSelfTourViewed', async () => {
            const GROUP_CHAT_NAME = 'Avatar Group';
            const GROUP_CHAT_REPORT_ID = '12348';
            const CONCIERGE_REPORT_ID = '99996';
            const AVATAR_URI = 'https://example.com/avatar.png';

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                chatType: undefined,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                    [TEST_USER_ACCOUNT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                },
            });

            await Onyx.set(ONYXKEYS.NVP_INTRO_SELECTED, TEST_INTRO_SELECTED);
            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            // When create group chat is called with an avatar URI and isSelfTourViewed=true
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: KNOWN_PARTICIPANTS_PERSONAL_DETAILS,
                reportName: GROUP_CHAT_NAME,
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: TEST_INTRO_SELECTED,
                isSelfTourViewed: true,
                hasCompletedGuidedSetupFlow: undefined,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                avatarUri: AVATAR_URI,
            });
            await waitForBatchedUpdates();

            // Then it should create a new group chat report with the avatar
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);
            expect(newGroupChatReport).not.toBeNull();
            expect(newGroupChatReport?.reportName).toBe(GROUP_CHAT_NAME);
            expect(newGroupChatReport?.chatType).toBe(CONST.REPORT.CHAT_TYPE.GROUP);
            expect(newGroupChatReport?.avatarUrl).toBe(AVATAR_URI);

            // Then guided setup data should have run via the isSelfTourViewed=true path, marking onboarding complete
            const introSelectedAfter = await getOnyxValue(ONYXKEYS.NVP_INTRO_SELECTED);
            expect(introSelectedAfter?.isInviteOnboardingComplete).toBe(true);
        });

        it('should create group chat when onboarding is already completed and isSelfTourViewed=true', async () => {
            const GROUP_CHAT_NAME = 'Completed Onboarding Group';
            const GROUP_CHAT_REPORT_ID = '12349';

            // Set onboarding as already completed
            await Onyx.set(ONYXKEYS.NVP_INTRO_SELECTED, {...TEST_INTRO_SELECTED, isInviteOnboardingComplete: true});
            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();

            // When create group chat is called with isSelfTourViewed=true but onboarding already completed
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: KNOWN_PARTICIPANTS_PERSONAL_DETAILS,
                reportName: GROUP_CHAT_NAME,
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: {...TEST_INTRO_SELECTED, isInviteOnboardingComplete: true},
                isSelfTourViewed: true,
                hasCompletedGuidedSetupFlow: undefined,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
            });
            await waitForBatchedUpdates();

            // Then the group chat should still be created
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);
            expect(newGroupChatReport).not.toBeNull();
            expect(newGroupChatReport?.reportName).toBe(GROUP_CHAT_NAME);
            expect(newGroupChatReport?.chatType).toBe(CONST.REPORT.CHAT_TYPE.GROUP);
        });

        it('should include avatarFile in API request when provided', async () => {
            const GROUP_CHAT_REPORT_ID = '12350';
            const avatarFile = new File([''], 'avatar.png', {type: 'image/png'});

            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();

            // When create group chat is called with an avatarFile
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: KNOWN_PARTICIPANTS_PERSONAL_DETAILS,
                reportName: 'Avatar File Group',
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: {choice: CONST.ONBOARDING_CHOICES.ADMIN},
                isSelfTourViewed: false,
                hasCompletedGuidedSetupFlow: undefined,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                avatarFile,
            });
            await waitForBatchedUpdates();

            // Then the group chat report should be created
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);
            expect(newGroupChatReport).not.toBeNull();
            expect(newGroupChatReport?.chatType).toBe(CONST.REPORT.CHAT_TYPE.GROUP);

            // Then the API should be called with the file parameter
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        });

        it('should add optimistic personal details for participants not in personal details', async () => {
            const GROUP_CHAT_REPORT_ID = '12351';
            const UNKNOWN_PARTICIPANT_LOGIN = 'unknown@test.com';

            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();

            // When create group chat is called with a participant not in allPersonalDetails (flagged as an optimistic personal detail)
            const unknownParticipantAccountID = getAccountIDsByLogins([UNKNOWN_PARTICIPANT_LOGIN]).at(0) ?? CONST.DEFAULT_NUMBER_ID;
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: {
                    [TEST_USER_ACCOUNT_ID]: {accountID: TEST_USER_ACCOUNT_ID, login: TEST_USER_LOGIN, displayName: 'Test user account'},
                    [unknownParticipantAccountID]: {
                        accountID: unknownParticipantAccountID,
                        login: UNKNOWN_PARTICIPANT_LOGIN,
                        displayName: UNKNOWN_PARTICIPANT_LOGIN,
                        isOptimisticPersonalDetail: true,
                    },
                },
                reportName: 'Optimistic Group',
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: {choice: CONST.ONBOARDING_CHOICES.ADMIN},
                isSelfTourViewed: false,
                hasCompletedGuidedSetupFlow: undefined,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
            });
            await waitForBatchedUpdates();

            // Then the group chat report should be created
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);
            expect(newGroupChatReport).not.toBeNull();

            // Then optimistic personal details should be added for the unknown participant
            const personalDetails = await getOnyxValue(ONYXKEYS.PERSONAL_DETAILS_LIST);
            const optimisticEntry = Object.values(personalDetails ?? {}).find((details) => details?.login === UNKNOWN_PARTICIPANT_LOGIN && details?.isOptimisticPersonalDetail === true);
            expect(optimisticEntry).not.toBeUndefined();
        });

        it('should skip guided setup when hasCompletedGuidedSetupFlow param is true even if Onyx says false', async () => {
            const GROUP_CHAT_NAME = 'Skip Setup Group';
            const GROUP_CHAT_REPORT_ID = '12352';
            const CONCIERGE_REPORT_ID = '99997';

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                chatType: undefined,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                    [TEST_USER_ACCOUNT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                },
            });

            // Onyx says onboarding is NOT completed
            await Onyx.set(ONYXKEYS.NVP_INTRO_SELECTED, TEST_INTRO_SELECTED);
            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            // When hasCompletedGuidedSetupFlow param is explicitly true, it overrides Onyx
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: KNOWN_PARTICIPANTS_PERSONAL_DETAILS,
                reportName: GROUP_CHAT_NAME,
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: TEST_INTRO_SELECTED,
                isSelfTourViewed: false,
                hasCompletedGuidedSetupFlow: true,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
            });
            await waitForBatchedUpdates();

            // Then the group chat should be created
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);
            expect(newGroupChatReport).not.toBeNull();
            expect(newGroupChatReport?.reportName).toBe(GROUP_CHAT_NAME);
            expect(newGroupChatReport?.chatType).toBe(CONST.REPORT.CHAT_TYPE.GROUP);

            // Then isInviteOnboardingComplete should NOT be set because guided setup was skipped
            const introSelected = await getOnyxValue(ONYXKEYS.NVP_INTRO_SELECTED);
            expect(introSelected?.isInviteOnboardingComplete).toBeFalsy();
        });

        it('should trigger guided setup when hasCompletedGuidedSetupFlow param is false', async () => {
            const GROUP_CHAT_NAME = 'Trigger Setup Group';
            const GROUP_CHAT_REPORT_ID = '12353';
            const CONCIERGE_REPORT_ID = '99998';

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                chatType: undefined,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [CONST.ACCOUNT_ID.CONCIERGE]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                    [TEST_USER_ACCOUNT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                },
            });

            // Onyx says onboarding is NOT completed
            await Onyx.set(ONYXKEYS.NVP_INTRO_SELECTED, TEST_INTRO_SELECTED);
            await Onyx.set(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            // When hasCompletedGuidedSetupFlow param is explicitly false, guided setup should run
            Report.navigateToAndCreateGroupChat({
                participantsPersonalDetails: KNOWN_PARTICIPANTS_PERSONAL_DETAILS,
                reportName: GROUP_CHAT_NAME,
                currentUserLogin: TEST_USER_LOGIN,
                optimisticReportID: GROUP_CHAT_REPORT_ID,
                introSelected: TEST_INTRO_SELECTED,
                isSelfTourViewed: false,
                hasCompletedGuidedSetupFlow: false,
                betas: undefined,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
            });
            await waitForBatchedUpdates();

            // Then the group chat should be created
            const newGroupChatReport: OnyxEntry<OnyxTypes.Report> = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${GROUP_CHAT_REPORT_ID}`);
            expect(newGroupChatReport).not.toBeNull();
            expect(newGroupChatReport?.reportName).toBe(GROUP_CHAT_NAME);
            expect(newGroupChatReport?.chatType).toBe(CONST.REPORT.CHAT_TYPE.GROUP);

            // Then isInviteOnboardingComplete should be set to true because guided setup ran
            const introSelected = await getOnyxValue(ONYXKEYS.NVP_INTRO_SELECTED);
            expect(introSelected?.isInviteOnboardingComplete).toBe(true);
        });
    });

    describe('handleWalletStatementNavigation', () => {
        let handleWalletStatementNavigation: typeof handleWalletStatementNavigationDefault;

        beforeEach(() => {
            jest.resetModules();
            handleWalletStatementNavigation = jest.requireActual<{default: typeof handleWalletStatementNavigationDefault}>('@components/WalletStatementModal/walletNavigationUtils').default;
        });

        it('should do nothing when type is undefined', () => {
            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            // No error should be thrown, function should return early
            expect(() => {
                handleWalletStatementNavigation('123', testIntroSelected, undefined, undefined, undefined);
            }).not.toThrow();
        });

        it('should do nothing when type is not a valid wallet message type', () => {
            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            const TEST_USER_ACCOUNT_ID = 1;
            expect(() => {
                handleWalletStatementNavigation('123', testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, 'invalidType', undefined);
            }).not.toThrow();
        });

        it('should navigate when type is CONCIERGE and conciergeReportID is provided', async () => {
            const mockNavigation: {navigate: jest.Mock} = jest.requireMock('@libs/Navigation/Navigation');
            mockNavigation.navigate.mockClear();

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            const TEST_USER_ACCOUNT_ID = 1;

            handleWalletStatementNavigation('123', testIntroSelected, TEST_USER_ACCOUNT_ID, undefined, undefined, CONST.WALLET.WEB_MESSAGE_TYPE.CONCIERGE, undefined);

            await waitForBatchedUpdates();

            // navigateToConciergeChat with a valid reportID and default shouldDismissModal=false calls Navigation.navigate
            expect(mockNavigation.navigate).toHaveBeenCalled();
        });

        it('should not throw with undefined introSelected', () => {
            const TEST_USER_ACCOUNT_ID = 1;
            expect(() => {
                handleWalletStatementNavigation('123', undefined, TEST_USER_ACCOUNT_ID, undefined, undefined, CONST.WALLET.WEB_MESSAGE_TYPE.CONCIERGE, undefined);
            }).not.toThrow();
        });

        it('should pass isSelfTourViewed=true to navigateToConciergeChat when selfTour has been viewed', async () => {
            const mockNavigateToConciergeChat = jest.fn();
            jest.mock('@userActions/Report', () => ({
                ...jest.requireActual<Record<string, unknown>>('@userActions/Report'),
                navigateToConciergeChat: mockNavigateToConciergeChat,
            }));

            jest.resetModules();
            const localHandleWalletStatementNavigation = jest.requireActual<{default: typeof handleWalletStatementNavigationDefault}>(
                '@components/WalletStatementModal/walletNavigationUtils',
            ).default;

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            const TEST_USER_ACCOUNT_ID = 1;
            const isSelfTourViewed = true;

            expect(() => {
                localHandleWalletStatementNavigation('123', testIntroSelected, TEST_USER_ACCOUNT_ID, isSelfTourViewed, undefined, CONST.WALLET.WEB_MESSAGE_TYPE.CONCIERGE, undefined);
            }).not.toThrow();
        });

        it('should pass isSelfTourViewed=false to navigateToConciergeChat when selfTour has not been viewed', () => {
            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            const TEST_USER_ACCOUNT_ID = 1;
            const isSelfTourViewed = false;

            expect(() => {
                handleWalletStatementNavigation('123', testIntroSelected, TEST_USER_ACCOUNT_ID, isSelfTourViewed, undefined, CONST.WALLET.WEB_MESSAGE_TYPE.CONCIERGE, undefined);
            }).not.toThrow();
        });
    });

    describe('navigateToAndOpenReport', () => {
        it('should create new chat when no existing chat with participant', async () => {
            // Given a test user with initial data
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            // When navigateToAndOpenReport is called with a participant that doesn't have an existing chat
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined);
            await waitForBatchedUpdates();

            // Then verify OpenReport API was called
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            // Then verify navigation was called
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should not create new chat when there is an existing chat with the participant', async () => {
            // Given a test user with initial data
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;
            const EXISTING_REPORT_ID = '123';

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            // When there is an existing chat report with the participant
            const existingReport: OnyxTypes.Report = {
                reportID: EXISTING_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                    [PARTICIPANT_ACCOUNT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                    },
                },
            };
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${EXISTING_REPORT_ID}`, existingReport);

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            // When navigateToAndOpenReport is called with the participant that has an existing chat
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined);
            await waitForBatchedUpdates();

            // Then verify OpenReport API was NOT called since the chat already exists
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 0);

            // Then verify navigation was called to the existing report
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should revalidate existing chat when shouldRevalidateExistingChat is true', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;
            const EXISTING_REPORT_ID = '123';

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${EXISTING_REPORT_ID}`, {
                reportID: EXISTING_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [PARTICIPANT_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            });
            await waitForBatchedUpdates();

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined, false, true);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_REPORT_ID));
        });

        it('should pass introSelected through to openReport when creating new chat', async () => {
            // Given a test user with initial data
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};

            // When navigateToAndOpenReport is called with introSelected
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined);
            await waitForBatchedUpdates();

            // Then verify OpenReport API was called (new chat created)
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            // Then verify navigation was called
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should respect shouldDismissModal parameter', async () => {
            // Given a test user with initial data
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            // When navigateToAndOpenReport is called with shouldDismissModal=false
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined, false);
            await waitForBatchedUpdates();

            // Then verify navigation was called
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should pass isSelfTourViewed=true through to openReport when creating new chat', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            // When navigateToAndOpenReport is called with isSelfTourViewed=true
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, true, undefined);
            await waitForBatchedUpdates();

            // Then verify OpenReport API was called
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            // Then verify navigation was called
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should pass isSelfTourViewed=undefined through to openReport when creating new chat', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            // When navigateToAndOpenReport is called with isSelfTourViewed=undefined
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, undefined, undefined);
            await waitForBatchedUpdates();

            // Then verify OpenReport API was called
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            // Then verify navigation was called
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should pass isSelfTourViewed along with shouldDismissModal', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            // When navigateToAndOpenReport is called with isSelfTourViewed=true and shouldDismissModal=false
            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, true, undefined, false);
            await waitForBatchedUpdates();

            // Then verify OpenReport API was called
            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);

            // Then verify navigation was called
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should pass betas through to openReport when creating new chat', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_LOGIN = 'participant@test.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(ONYXKEYS.PERSONAL_DETAILS_LIST, {
                [PARTICIPANT_ACCOUNT_ID]: {
                    accountID: PARTICIPANT_ACCOUNT_ID,
                    login: PARTICIPANT_LOGIN,
                    displayName: 'Participant',
                },
            });

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            const testBetas = [CONST.BETAS.ALL];

            Report.navigateToAndOpenReport([PARTICIPANT_LOGIN], {}, TEST_USER_ACCOUNT_ID, testIntroSelected, false, testBetas);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
            expect(Navigation.navigate).toHaveBeenCalled();
        });
    });

    describe('getOptimisticChatReport', () => {
        it('should return an optimistic chat report with correct participants and notification preference', () => {
            const accountID = 2;
            const currentUserAccountID = 1;

            const result = Report.getOptimisticChatReport(accountID, currentUserAccountID);

            expect(result.reportID).toBeTruthy();
            expect(result.type).toBe('chat');
        });

        it('should include both accountID and currentUserAccountID as participants', () => {
            const accountID = 2;
            const currentUserAccountID = 1;

            const result = Report.getOptimisticChatReport(accountID, currentUserAccountID);

            // The result should be a valid optimistic report
            expect(result).toBeTruthy();
            expect(result.reportID).toBeTruthy();
        });
    });

    describe('navigateToAndOpenReportWithAccountIDs', () => {
        it.each([true, false])('should create new chat and call openReport when no existing chat (isSelfTourViewed=%s)', async (isSelfTourViewed) => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_ACCOUNT_ID = 2;

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            Report.navigateToAndOpenReportWithAccountIDs([PARTICIPANT_ACCOUNT_ID], TEST_USER_ACCOUNT_ID, testIntroSelected, isSelfTourViewed, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
            expect(Navigation.navigate).toHaveBeenCalled();
        });

        it('should not call openReport when chat already exists', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_ACCOUNT_ID = 2;
            const EXISTING_REPORT_ID = '456';

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${EXISTING_REPORT_ID}`, {
                reportID: EXISTING_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [PARTICIPANT_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            });
            await waitForBatchedUpdates();

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            Report.navigateToAndOpenReportWithAccountIDs([PARTICIPANT_ACCOUNT_ID], TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined, undefined, undefined);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 0);
            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_REPORT_ID));
        });

        it('should revalidate existing chat when shouldRevalidateExistingChat is true', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_ACCOUNT_ID = 2;
            const EXISTING_REPORT_ID = '456';

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${EXISTING_REPORT_ID}`, {
                reportID: EXISTING_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [PARTICIPANT_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            });
            await waitForBatchedUpdates();

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};

            Report.navigateToAndOpenReportWithAccountIDs([PARTICIPANT_ACCOUNT_ID], TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined, undefined, {}, true);
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
            expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.REPORT_WITH_ID.getRoute(EXISTING_REPORT_ID));
        });

        it('should send first AddComment to fallback report after stale cached DM recovery', async () => {
            const TEST_USER_ACCOUNT_ID = 1;
            const TEST_USER_LOGIN = 'test@user.com';
            const PARTICIPANT_ACCOUNT_ID = 2;
            const STALE_REPORT_ID = '456';
            // Matches ReportUtils jest mock: mockGenerateReportID returns '9876' for optimistic fallback DM reportID.
            const MOCK_FALLBACK_DM_REPORT_ID = '9876';

            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${STALE_REPORT_ID}`, {
                reportID: STALE_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [PARTICIPANT_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
                errorFields: {
                    notFound: {message: 'stale'},
                },
            });
            await waitForBatchedUpdates();

            const testIntroSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN};
            Report.navigateToAndOpenReportWithAccountIDs([PARTICIPANT_ACCOUNT_ID], TEST_USER_ACCOUNT_ID, testIntroSelected, false, undefined, undefined, {}, true);
            await waitForBatchedUpdates();

            const openReportCalls = getMockFetch(global.fetch).mock.calls.filter((c) => c[0] === `https://www.expensify.com.dev/api/${WRITE_COMMANDS.OPEN_REPORT}?`);
            expect(openReportCalls.length).toBeGreaterThanOrEqual(1);
            const openReportParamsList = openReportCalls.map((call) => {
                const body = (call.at(1) as RequestInit)?.body;
                return body instanceof FormData ? Object.fromEntries(body) : {};
            });
            expect(openReportParamsList.some((p) => p.reportID === MOCK_FALLBACK_DM_REPORT_ID)).toBe(true);

            Report.addComment({
                report: {reportID: STALE_REPORT_ID},
                notifyReportID: STALE_REPORT_ID,
                ancestors: [],
                text: 'hello fallback',
                timezoneParam: CONST.DEFAULT_TIME_ZONE,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                delegateAccountID: undefined,
                conciergeReportID: undefined,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.ADD_COMMENT, 1);
            const addCommentCalls = getMockFetch(global.fetch).mock.calls.filter((c) => c[0] === `https://www.expensify.com.dev/api/${WRITE_COMMANDS.ADD_COMMENT}?`);
            const addCommentBody = (addCommentCalls.at(-1)?.at(1) as RequestInit)?.body;
            const addCommentParams = addCommentBody instanceof FormData ? Object.fromEntries(addCommentBody) : {};
            expect(addCommentParams.reportID).toBe(MOCK_FALLBACK_DM_REPORT_ID);
        });
    });

    describe('getGuidedSetupDataForOpenReport', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@user.com';
        const CONCIERGE_REPORT_ID = '100';

        async function setupUserWithConciergeChat() {
            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await TestHelper.setPersonalDetails(TEST_USER_LOGIN, TEST_USER_ACCOUNT_ID);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${CONCIERGE_REPORT_ID}`, {
                reportID: CONCIERGE_REPORT_ID,
                type: CONST.REPORT.TYPE.CHAT,
                participants: {
                    [TEST_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    [CONST.ACCOUNT_ID.CONCIERGE]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                },
            });
        }

        it('should return undefined when user completed guided setup', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();
            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: true};

            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);
            expect(result).toBeUndefined();
        });

        it('should return guided setup data when introSelected has a valid choice and onboarding is not completed', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);

            expect(result).toBeDefined();
            expect(result?.guidedSetupData).toBeDefined();
            expect(result?.optimisticData).toBeDefined();
            expect(result?.successData).toBeDefined();
            expect(result?.failureData).toBeDefined();
        });

        it('should return guided setup data for ADMIN choice', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);

            expect(result).toBeDefined();
            expect(result?.guidedSetupData).toBeDefined();
            expect(result?.optimisticData).toBeDefined();
            expect(result?.successData).toBeDefined();
            expect(result?.failureData).toBeDefined();
        });

        it('should return guided setup data for pending invite onboarding when regular guided setup is completed', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {
                choice: CONST.ONBOARDING_CHOICES.ADMIN,
                inviteType: CONST.ONBOARDING_INVITE_TYPES.WORKSPACE,
                isInviteOnboardingComplete: false,
            };
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);

            expect(result).toBeDefined();
            expect(result?.guidedSetupData).toContain(CONST.ONBOARDING_TASK_TYPE.REVIEW_WORKSPACE_SETTINGS);
            expect(result?.optimisticData.find((update) => update.key === ONYXKEYS.NVP_ONBOARDING)).toBeUndefined();
        });

        it('should complete regular onboarding for first-time pending invite onboarding', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {
                choice: CONST.ONBOARDING_CHOICES.ADMIN,
                inviteType: CONST.ONBOARDING_INVITE_TYPES.WORKSPACE,
                isInviteOnboardingComplete: false,
            };
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);

            expect(result).toBeDefined();
            expect(result?.optimisticData.find((update) => update.key === ONYXKEYS.NVP_ONBOARDING)?.value).toEqual({hasCompletedGuidedSetupFlow: true});
        });

        it('should return undefined for completed regular onboarding when invite onboarding is not pending', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);

            expect(result).toBeUndefined();
        });

        it.each<[boolean, string]>([
            [true, 'should be defined'],
            [false, 'should be undefined'],
        ])('viewTour completedTaskReportActionID when isSelfTourViewed=%s %s', async (isSelfTourViewed) => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.SUBMIT, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID, isSelfTourViewed);

            expect(result).toBeDefined();
            const guidedSetupData = JSON.parse(result?.guidedSetupData ?? '[]') as Array<{type: string; task?: string; completedTaskReportActionID?: string}>;
            const viewTourTask = guidedSetupData.find((item) => item.type === 'task' && item.task === CONST.ONBOARDING_TASK_TYPE.VIEW_TOUR);
            expect(viewTourTask).toBeDefined();

            if (isSelfTourViewed) {
                expect(viewTourTask?.completedTaskReportActionID).toBeDefined();
            } else {
                expect(viewTourTask?.completedTaskReportActionID).toBeUndefined();
            }
        });

        it('should return undefined when hasCompletedGuidedSetupFlow param is true even if Onyx says false', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID, undefined, true);

            expect(result).toBeUndefined();
        });

        it('should return guided setup data when hasCompletedGuidedSetupFlow param is false', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: false});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID, undefined, false);

            expect(result).toBeDefined();
            expect(result?.guidedSetupData).toBeDefined();
            expect(result?.optimisticData).toBeDefined();
            expect(result?.successData).toBeDefined();
            expect(result?.failureData).toBeDefined();
        });

        it('should return undefined when hasCompletedGuidedSetupFlow param is undefined but Onyx says true', async () => {
            await setupUserWithConciergeChat();
            await Onyx.merge(ONYXKEYS.NVP_ONBOARDING, {hasCompletedGuidedSetupFlow: true});
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {choice: CONST.ONBOARDING_CHOICES.ADMIN, isInviteOnboardingComplete: false};
            const result = Report.getGuidedSetupDataForOpenReport(introSelected, CONST.DEFAULT_NUMBER_ID);

            expect(result).toBeUndefined();
        });
    });

    describe('createTransactionThreadReport', () => {
        const TEST_USER_ACCOUNT_ID = 1;
        const TEST_USER_LOGIN = 'test@test.com';

        beforeEach(async () => {
            global.fetch = TestHelper.getGlobalFetchMock();
            await TestHelper.signInWithTestUser(TEST_USER_ACCOUNT_ID, TEST_USER_LOGIN);
            await waitForBatchedUpdates();
        });

        it('should return undefined when no valid report is provided', () => {
            const result = Report.createTransactionThreadReport({
                introSelected: TEST_INTRO_SELECTED,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: undefined,
            });
            expect(result).toBeUndefined();
        });

        it('should return undefined when report has no reportID', () => {
            const reportWithoutID = createMock<OnyxTypes.Report>({});
            const result = Report.createTransactionThreadReport({
                introSelected: TEST_INTRO_SELECTED,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: undefined,
                iouReport: reportWithoutID,
            });
            expect(result).toBeUndefined();
        });

        it('should return an optimistic transaction thread report when given a valid report and action', async () => {
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(100, undefined),
                reportID: '100',
                type: CONST.REPORT.TYPE.EXPENSE,
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport.reportID}`, parentReport);
            await waitForBatchedUpdates();

            const reportAction: OnyxTypes.ReportAction = {
                ...createRandomReportAction(1),
                reportActionID: 'action-1',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
            };

            const result = Report.createTransactionThreadReport({
                introSelected: TEST_INTRO_SELECTED,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: undefined,
                iouReport: parentReport,
                iouReportAction: reportAction,
            });

            expect(result).toBeDefined();
            expect(result?.reportID).toBeDefined();
            expect(result?.parentReportID).toBe(parentReport.reportID);
        });

        it('should accept introSelected as first parameter and not bypass it', async () => {
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(200, undefined),
                reportID: '200',
                type: CONST.REPORT.TYPE.EXPENSE,
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport.reportID}`, parentReport);
            await waitForBatchedUpdates();

            const introSelected: OnyxTypes.IntroSelected = {
                choice: CONST.ONBOARDING_CHOICES.MANAGE_TEAM,
                isInviteOnboardingComplete: true,
            };

            const reportAction: OnyxTypes.ReportAction = {
                ...createRandomReportAction(4),
                reportActionID: 'action-4',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
            };

            // Should not throw when called with introSelected and return a valid thread report
            const result = Report.createTransactionThreadReport({
                introSelected,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: undefined,
                iouReport: parentReport,
                iouReportAction: reportAction,
            });
            expect(result).toBeDefined();
            expect(result?.reportID).toBeDefined();
            expect(result?.parentReportID).toBe(parentReport.reportID);
        });

        it('should work with undefined introSelected', async () => {
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(300, undefined),
                reportID: '300',
                type: CONST.REPORT.TYPE.EXPENSE,
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport.reportID}`, parentReport);
            await waitForBatchedUpdates();

            const reportAction: OnyxTypes.ReportAction = {
                ...createRandomReportAction(2),
                reportActionID: 'action-2',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
            };

            // Should work fine with undefined introSelected - it's OnyxEntry<IntroSelected> which allows undefined
            const result = Report.createTransactionThreadReport({
                introSelected: undefined,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: undefined,
                iouReport: parentReport,
                iouReportAction: reportAction,
            });
            expect(result).toBeDefined();
            expect(result?.reportID).toBeDefined();
        });

        it('should pass transaction and violations when provided', async () => {
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(400, undefined),
                reportID: '400',
                type: CONST.REPORT.TYPE.EXPENSE,
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport.reportID}`, parentReport);
            await waitForBatchedUpdates();

            const reportAction: OnyxTypes.ReportAction = {
                ...createRandomReportAction(3),
                reportActionID: 'action-3',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
            };

            const transaction = createRandomTransaction(1);
            const violations: OnyxTypes.TransactionViolation[] = [
                {
                    type: CONST.VIOLATION_TYPES.VIOLATION,
                    name: CONST.VIOLATIONS.MISSING_CATEGORY,
                },
            ];

            const result = Report.createTransactionThreadReport({
                introSelected: TEST_INTRO_SELECTED,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: undefined,
                iouReport: parentReport,
                iouReportAction: reportAction,
                transaction,
                transactionViolations: violations,
            });
            expect(result).toBeDefined();
            expect(result?.reportID).toBeDefined();
            expect(result?.parentReportID).toBe(parentReport.reportID);
        });

        it('should pass betas through to openReport', async () => {
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(500, undefined),
                reportID: '500',
                type: CONST.REPORT.TYPE.EXPENSE,
            };

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${parentReport.reportID}`, parentReport);
            await waitForBatchedUpdates();

            const reportAction: OnyxTypes.ReportAction = {
                ...createRandomReportAction(5),
                reportActionID: 'action-5',
                actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
            };

            const testBetas = [CONST.BETAS.ALL];
            Report.createTransactionThreadReport({
                introSelected: TEST_INTRO_SELECTED,
                currentUserLogin: TEST_USER_LOGIN,
                currentUserAccountID: TEST_USER_ACCOUNT_ID,
                betas: testBetas,
                iouReport: parentReport,
                iouReportAction: reportAction,
            });
            await waitForBatchedUpdates();

            TestHelper.expectAPICommandToHaveBeenCalled(WRITE_COMMANDS.OPEN_REPORT, 1);
        });
    });

    describe('resolveActionableMentionWhisper', () => {
        it('should optimistically add invited users to report.participants when resolution is INVITE', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '1';
            const WHISPER_ACTION_ID = '1001';
            const EXISTING_PARTICIPANT_ID = 100;
            const INVITEE_ACCOUNT_ID_1 = 200;
            const INVITEE_ACCOUNT_ID_2 = 300;

            const report: OnyxTypes.Report = {
                ...createRandomReport(1, undefined),
                reportID: REPORT_ID,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
                lastMessageText: 'Hello',
                lastVisibleActionCreated: '2024-11-19 08:04:13.728',
                lastActorAccountID: EXISTING_PARTICIPANT_ID,
            };

            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1 and @user2', text: 'Mentioned @user1 and @user2', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [INVITEE_ACCOUNT_ID_1, INVITEE_ACCOUNT_ID_2],
                    inviteeEmails: ['user1@example.com', 'user2@example.com'],
                    whisperedTo: [EXISTING_PARTICIPANT_ID],
                },
            });

            // Seed Onyx with report and report actions
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            // Call resolveActionableMentionWhisper with INVITE resolution
            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            // Verify optimistic participant update
            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const);

            // Existing participant should still be there with original values
            expect(updatedReport?.participants?.[EXISTING_PARTICIPANT_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.ADMIN,
            });

            // Invitees should be added with default notification preference and member role
            expect(updatedReport?.participants?.[INVITEE_ACCOUNT_ID_1]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });
            expect(updatedReport?.participants?.[INVITEE_ACCOUNT_ID_2]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });
        });

        it('should NOT update participants when resolution is NOTHING', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '2';
            const WHISPER_ACTION_ID = '2001';
            const EXISTING_PARTICIPANT_ID = 100;
            const INVITEE_ACCOUNT_ID = 200;

            const report: OnyxTypes.Report = {
                ...createRandomReport(2, undefined),
                reportID: REPORT_ID,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
                lastMessageText: 'Hello',
                lastVisibleActionCreated: '2024-11-19 08:04:13.728',
                lastActorAccountID: EXISTING_PARTICIPANT_ID,
            };

            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1', text: 'Mentioned @user1', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [INVITEE_ACCOUNT_ID],
                    inviteeEmails: ['user1@example.com'],
                    whisperedTo: [EXISTING_PARTICIPANT_ID],
                },
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            // Call with NOTHING resolution
            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.NOTHING, false);
            await waitForBatchedUpdates();

            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const);

            // Existing participant should still be there
            expect(updatedReport?.participants?.[EXISTING_PARTICIPANT_ID]).toBeDefined();

            // Invitee should NOT be added
            expect(updatedReport?.participants?.[INVITEE_ACCOUNT_ID]).toBeUndefined();
        });

        it('should preserve existing participant settings when invitee is already in participants', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '4';
            const WHISPER_ACTION_ID = '4001';
            const EXISTING_ADMIN_ID = 100;
            const ALREADY_ADDED_USER_ID = 200;
            const NEW_INVITEE_ID = 300;

            const report: OnyxTypes.Report = {
                ...createRandomReport(4, undefined),
                reportID: REPORT_ID,
                participants: {
                    [EXISTING_ADMIN_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                    [ALREADY_ADDED_USER_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.DAILY,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
                lastMessageText: 'Hello',
                lastVisibleActionCreated: '2024-11-19 08:04:13.728',
                lastActorAccountID: EXISTING_ADMIN_ID,
            };

            // Stale whisper that includes an already-added user alongside a new one
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1 and @user2', text: 'Mentioned @user1 and @user2', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [ALREADY_ADDED_USER_ID, NEW_INVITEE_ID],
                    inviteeEmails: ['user1@example.com', 'user2@example.com'],
                    whisperedTo: [EXISTING_ADMIN_ID],
                },
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const);

            // Already-added user's settings must NOT be overwritten
            expect(updatedReport?.participants?.[ALREADY_ADDED_USER_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.DAILY,
                role: CONST.REPORT.ROLE.ADMIN,
            });

            // New invitee should be added with default settings
            expect(updatedReport?.participants?.[NEW_INVITEE_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });
        });

        it('should also update parent report participants when parentReport is provided (oneTransactionThread)', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const TRANSACTION_THREAD_ID = '10';
            const PARENT_REPORT_ID = '11';
            const WHISPER_ACTION_ID = '10001';
            const EXISTING_PARTICIPANT_ID = 100;
            const INVITEE_ACCOUNT_ID = 200;

            // Transaction thread report (where the whisper action lives)
            const transactionThreadReport: OnyxTypes.Report = {
                ...createRandomReport(10, undefined),
                reportID: TRANSACTION_THREAD_ID,
                parentReportID: PARENT_REPORT_ID,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
                lastMessageText: 'Receipt',
                lastVisibleActionCreated: '2024-11-19 08:04:13.728',
                lastActorAccountID: EXISTING_PARTICIPANT_ID,
            };

            // Parent report (what the user is viewing - the expense report)
            const parentReport: OnyxTypes.Report = {
                ...createRandomReport(11, undefined),
                reportID: PARENT_REPORT_ID,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
            };

            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: TRANSACTION_THREAD_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1', text: 'Mentioned @user1', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [INVITEE_ACCOUNT_ID],
                    inviteeEmails: ['user1@example.com'],
                    whisperedTo: [EXISTING_PARTICIPANT_ID],
                },
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${TRANSACTION_THREAD_ID}`, transactionThreadReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}`, parentReport);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${TRANSACTION_THREAD_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            // Call with parentReport to simulate oneTransactionThread context
            Report.resolveActionableMentionWhisper(transactionThreadReport, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false, parentReport);
            await waitForBatchedUpdates();

            // Verify the invitee was added to the transaction thread participants
            const updatedThreadReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${TRANSACTION_THREAD_ID}` as const);
            expect(updatedThreadReport?.participants?.[INVITEE_ACCOUNT_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });

            // Verify the invitee was also added to the parent report participants
            const updatedParentReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${PARENT_REPORT_ID}` as const);
            expect(updatedParentReport?.participants?.[INVITEE_ACCOUNT_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });
        });

        it('should fall back to ancestor report via parentReportID when parentReport matches current report', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const TRANSACTION_THREAD_ID = '20';
            const ANCESTOR_IOU_REPORT_ID = '21';
            const WHISPER_ACTION_ID = '20001';
            const EXISTING_PARTICIPANT_ID = 100;
            const INVITEE_ACCOUNT_ID = 200;

            // Transaction thread report — parentReportID points to the IOU ancestor
            const transactionThreadReport: OnyxTypes.Report = {
                ...createRandomReport(20, undefined),
                reportID: TRANSACTION_THREAD_ID,
                parentReportID: ANCESTOR_IOU_REPORT_ID,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
                lastMessageText: 'Receipt',
                lastVisibleActionCreated: '2024-11-19 08:04:13.728',
                lastActorAccountID: EXISTING_PARTICIPANT_ID,
            };

            // Ancestor IOU report (money request report)
            const ancestorIOUReport: OnyxTypes.Report = {
                ...createRandomReport(21, undefined),
                reportID: ANCESTOR_IOU_REPORT_ID,
                type: CONST.REPORT.TYPE.IOU,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
            };

            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: TRANSACTION_THREAD_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1', text: 'Mentioned @user1', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [INVITEE_ACCOUNT_ID],
                    inviteeEmails: ['user1@example.com'],
                    whisperedTo: [EXISTING_PARTICIPANT_ID],
                },
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${TRANSACTION_THREAD_ID}`, transactionThreadReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${ANCESTOR_IOU_REPORT_ID}`, ancestorIOUReport);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${TRANSACTION_THREAD_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            // Pass parentReport as the same report (simulating viewing transaction thread directly)
            Report.resolveActionableMentionWhisper(transactionThreadReport, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false, transactionThreadReport);
            await waitForBatchedUpdates();

            // Verify the invitee was added to the transaction thread participants
            const updatedThreadReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${TRANSACTION_THREAD_ID}` as const);
            expect(updatedThreadReport?.participants?.[INVITEE_ACCOUNT_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });

            // Verify the invitee was also added to the ancestor IOU report via the fallback path
            const updatedAncestorReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${ANCESTOR_IOU_REPORT_ID}` as const);
            expect(updatedAncestorReport?.participants?.[INVITEE_ACCOUNT_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });
        });

        it('should remove optimistically added participants on failure rollback', async () => {
            const mockFetch = getMockFetch(TestHelper.getGlobalFetchMock());
            global.fetch = mockFetch;

            const REPORT_ID = '3';
            const WHISPER_ACTION_ID = '3001';
            const EXISTING_PARTICIPANT_ID = 100;
            const INVITEE_ACCOUNT_ID = 200;

            const report: OnyxTypes.Report = {
                ...createRandomReport(3, undefined),
                reportID: REPORT_ID,
                participants: {
                    [EXISTING_PARTICIPANT_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
                lastMessageText: 'Hello',
                lastVisibleActionCreated: '2024-11-19 08:04:13.728',
                lastActorAccountID: EXISTING_PARTICIPANT_ID,
            };

            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1', text: 'Mentioned @user1', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [INVITEE_ACCOUNT_ID],
                    inviteeEmails: ['user1@example.com'],
                    whisperedTo: [EXISTING_PARTICIPANT_ID],
                },
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            // Pause fetch so we can verify optimistic state, then trigger failure
            mockFetch.pause();
            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            // Verify the invitee was optimistically added
            let updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const);
            expect(updatedReport?.participants?.[INVITEE_ACCOUNT_ID]).toBeDefined();

            // Now make the request fail and resume
            mockFetch.fail();
            mockFetch.resume();
            await waitForBatchedUpdates();
            await waitForNetworkPromises();
            await waitForBatchedUpdates();

            // After failure, the invitee should be removed from participants
            updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const);
            expect(updatedReport?.participants?.[INVITEE_ACCOUNT_ID]).toBeFalsy();

            // Existing participant should still be there
            expect(updatedReport?.participants?.[EXISTING_PARTICIPANT_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.ADMIN,
            });
        });

        it('should forward reportID and inviteeEmails to the API when resolution is INVITE', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '900';
            const WHISPER_ACTION_ID = '9001';
            const report: OnyxTypes.Report = {
                ...createRandomReport(900, undefined),
                reportID: REPORT_ID,
            };
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1 and @user2', text: 'Mentioned @user1 and @user2', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [200, 300],
                    inviteeEmails: ['user1@example.com', 'user2@example.com'],
                    whisperedTo: [100],
                },
            });

            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            // The resolve request must carry the same (reportID, inviteeEmails) pair InviteToRoom sends, so the backend can email the new logins
            expect(apiWriteSpy).toHaveBeenCalledWith(
                WRITE_COMMANDS.RESOLVE_ACTIONABLE_MENTION_WHISPER,
                expect.objectContaining({
                    reportActionID: WHISPER_ACTION_ID,
                    resolution: CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE,
                    reportID: REPORT_ID,
                    inviteeEmails: ['user1@example.com', 'user2@example.com'],
                }),
                expect.anything(),
            );
        });

        it('should NOT forward reportID and inviteeEmails when resolution is NOTHING', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '901';
            const WHISPER_ACTION_ID = '9011';
            const report: OnyxTypes.Report = {
                ...createRandomReport(901, undefined),
                reportID: REPORT_ID,
            };
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @user1', text: 'Mentioned @user1', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [200],
                    inviteeEmails: ['user1@example.com'],
                    whisperedTo: [100],
                },
            });

            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.NOTHING, false);
            await waitForBatchedUpdates();

            const resolveCall = apiWriteSpy.mock.calls.find((call) => call.at(0) === WRITE_COMMANDS.RESOLVE_ACTIONABLE_MENTION_WHISPER);
            const params = resolveCall?.at(1);
            expect(params).toBeDefined();
            expect(params).not.toHaveProperty('reportID');
            expect(params).not.toHaveProperty('inviteeEmails');
        });

        it('should NOT forward reportID and inviteeEmails when the whisper has no invitee emails', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '902';
            const WHISPER_ACTION_ID = '9021';
            const report: OnyxTypes.Report = {
                ...createRandomReport(902, undefined),
                reportID: REPORT_ID,
            };
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned invitee', text: 'Mentioned invitee', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [],
                    inviteeEmails: [],
                    whisperedTo: [100],
                },
            });

            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            const resolveCall = apiWriteSpy.mock.calls.find((call) => call.at(0) === WRITE_COMMANDS.RESOLVE_ACTIONABLE_MENTION_WHISPER);
            const params = resolveCall?.at(1);
            expect(params).toBeDefined();
            expect(params).not.toHaveProperty('reportID');
            expect(params).not.toHaveProperty('inviteeEmails');
        });

        it('should only forward emails for invitees not already in the room (stale whisper)', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '903';
            const WHISPER_ACTION_ID = '9031';
            const ALREADY_MEMBER_ID = 200;
            const NEW_INVITEE_ID = 300;
            const report: OnyxTypes.Report = {
                ...createRandomReport(903, undefined),
                reportID: REPORT_ID,
                participants: {
                    [ALREADY_MEMBER_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.MEMBER,
                    },
                },
            };
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @already and @new', text: 'Mentioned @already and @new', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [ALREADY_MEMBER_ID, NEW_INVITEE_ID],
                    inviteeEmails: ['already@example.com', 'new@example.com'],
                    whisperedTo: [100],
                },
            });

            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            // The already-member's email must be dropped so they don't receive a duplicate room invitation
            expect(apiWriteSpy).toHaveBeenCalledWith(
                WRITE_COMMANDS.RESOLVE_ACTIONABLE_MENTION_WHISPER,
                expect.objectContaining({
                    resolution: CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE,
                    reportID: REPORT_ID,
                    inviteeEmails: ['new@example.com'],
                }),
                expect.anything(),
            );
        });

        it('should still forward a brand-new-user email that has no matching accountID (shorter inviteeAccountIDs)', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '904';
            const WHISPER_ACTION_ID = '9041';
            const ALREADY_MEMBER_ID = 200;
            const report: OnyxTypes.Report = {
                ...createRandomReport(904, undefined),
                reportID: REPORT_ID,
                participants: {
                    [ALREADY_MEMBER_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.MEMBER,
                    },
                },
            };
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @already and @new', text: 'Mentioned @already and @new', type: 'COMMENT'}],
                originalMessage: {
                    // The brand-new user has no accountID yet, so inviteeAccountIDs is shorter than inviteeEmails.
                    inviteeAccountIDs: [ALREADY_MEMBER_ID],
                    inviteeEmails: ['already@example.com', 'new@example.com'],
                    whisperedTo: [100],
                },
            });

            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            // already@example.com (index 0, accountID 200) is an existing member and is dropped; new@example.com
            // (index 1, no matching accountID) is still forwarded so the new user gets invited.
            expect(apiWriteSpy).toHaveBeenCalledWith(
                WRITE_COMMANDS.RESOLVE_ACTIONABLE_MENTION_WHISPER,
                expect.objectContaining({
                    resolution: CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE,
                    reportID: REPORT_ID,
                    inviteeEmails: ['new@example.com'],
                }),
                expect.anything(),
            );
        });

        it('should optimistically add only the new invitee to participants for a stale whisper (offline path)', async () => {
            global.fetch = TestHelper.getGlobalFetchMock();

            const REPORT_ID = '905';
            const WHISPER_ACTION_ID = '9051';
            const ALREADY_MEMBER_ID = 200;
            const NEW_INVITEE_ID = 300;
            const report: OnyxTypes.Report = {
                ...createRandomReport(905, undefined),
                reportID: REPORT_ID,
                participants: {
                    [ALREADY_MEMBER_ID]: {
                        notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                        role: CONST.REPORT.ROLE.ADMIN,
                    },
                },
            };
            const whisperAction = createMock<OnyxTypes.ReportAction>({
                reportActionID: WHISPER_ACTION_ID,
                reportID: REPORT_ID,
                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
                created: '2024-11-19 08:04:13.730',
                message: [{html: 'Mentioned @already and @new', text: 'Mentioned @already and @new', type: 'COMMENT'}],
                originalMessage: {
                    inviteeAccountIDs: [ALREADY_MEMBER_ID, NEW_INVITEE_ID],
                    inviteeEmails: ['already@example.com', 'new@example.com'],
                    whisperedTo: [100],
                },
            });

            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${REPORT_ID}`]: {
                    [WHISPER_ACTION_ID]: whisperAction,
                },
            });
            await waitForBatchedUpdates();

            // Let API.write run against the mock fetch so the optimistic Onyx update is actually applied.
            Report.resolveActionableMentionWhisper(report, whisperAction, CONST.REPORT.ACTIONABLE_MENTION_WHISPER_RESOLUTION.INVITE, false);
            await waitForBatchedUpdates();

            const updatedReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}` as const);
            // The brand-new invitee is added optimistically as a member...
            expect(updatedReport?.participants?.[NEW_INVITEE_ID]).toMatchObject({
                notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS,
                role: CONST.REPORT.ROLE.MEMBER,
            });
            // ...while the already-existing member keeps their original ADMIN role (not overwritten).
            expect(updatedReport?.participants?.[ALREADY_MEMBER_ID]).toMatchObject({
                role: CONST.REPORT.ROLE.ADMIN,
            });
        });
    });

    describe('buildOptimisticAddCommentReportAction delegateAccountID forwarding', () => {
        const DELEGATE_ACCOUNT_ID = 999;

        it('sets delegateAccountID when delegateAccountIDParam is provided', () => {
            const result = ReportUtils.buildOptimisticAddCommentReportAction({text: 'test comment', delegateAccountIDParam: DELEGATE_ACCOUNT_ID});
            expect(result.reportAction.delegateAccountID).toBe(DELEGATE_ACCOUNT_ID);
        });

        it('does not set delegateAccountID when delegateAccountIDParam is undefined', () => {
            const result = ReportUtils.buildOptimisticAddCommentReportAction({text: 'test comment', delegateAccountIDParam: undefined});
            expect(result.reportAction.delegateAccountID).toBeUndefined();
        });
    });

    describe('buildOptimisticModifiedExpenseReportAction delegateAccountID forwarding', () => {
        const DELEGATE_ACCOUNT_ID = 999;

        it('sets delegateAccountID when delegateAccountIDParam is provided', () => {
            const result = ReportUtils.buildOptimisticModifiedExpenseReportAction(undefined, undefined, {}, false, undefined, DELEGATE_ACCOUNT_ID);
            expect(result.delegateAccountID).toBe(DELEGATE_ACCOUNT_ID);
        });

        it('does not set delegateAccountID when delegateAccountIDParam is undefined', () => {
            const result = ReportUtils.buildOptimisticModifiedExpenseReportAction(undefined, undefined, {}, false, undefined, undefined);
            expect(result.delegateAccountID).toBeUndefined();
        });
    });

    describe('buildOptimisticIOUReportAction delegateAccountID forwarding', () => {
        const DELEGATE_ACCOUNT_ID = 998;

        it('sets delegateAccountID when delegateAccountIDParam is provided', () => {
            const result = ReportUtils.buildOptimisticIOUReportAction({
                type: CONST.IOU.REPORT_ACTION_TYPE.CREATE,
                amount: 100,
                currency: CONST.CURRENCY.USD,
                comment: '',
                participants: [],
                transactionID: '1',
                delegateAccountIDParam: DELEGATE_ACCOUNT_ID,
            });
            expect(result.delegateAccountID).toBe(DELEGATE_ACCOUNT_ID);
        });

        it('does not set delegateAccountID when delegateAccountIDParam is undefined', () => {
            const result = ReportUtils.buildOptimisticIOUReportAction({
                type: CONST.IOU.REPORT_ACTION_TYPE.CREATE,
                amount: 100,
                currency: CONST.CURRENCY.USD,
                comment: '',
                participants: [],
                transactionID: '1',
                delegateAccountIDParam: undefined,
            });
            expect(result.delegateAccountID).toBeUndefined();
        });
    });

    describe('buildOptimisticReportPreview delegateAccountID forwarding', () => {
        const DELEGATE_ACCOUNT_ID = 997;

        it('sets delegateAccountID when delegateAccountIDParam is provided', () => {
            const chatReport = createMock<OnyxTypes.Report>({reportID: 'chat1'});
            const iouReport = createMock<OnyxTypes.Report>({reportID: 'iou1', ownerAccountID: 1, managerID: 2});
            const result = ReportUtils.buildOptimisticReportPreview(chatReport, iouReport, '', null, undefined, undefined, DELEGATE_ACCOUNT_ID);
            expect(result.delegateAccountID).toBe(DELEGATE_ACCOUNT_ID);
        });

        it('does not set delegateAccountID when delegateAccountIDParam is undefined', () => {
            const chatReport = createMock<OnyxTypes.Report>({reportID: 'chat2'});
            const iouReport = createMock<OnyxTypes.Report>({reportID: 'iou2', ownerAccountID: 1, managerID: 2});
            const result = ReportUtils.buildOptimisticReportPreview(chatReport, iouReport, '', null, undefined, undefined, undefined);
            expect(result.delegateAccountID).toBeUndefined();
        });
    });

    describe('mergeReports', () => {
        const currentUserAccountID = 1;
        const currentUserEmail = 'test@example.com';

        const POLICY_ID = 'policy_123';
        const WORKSPACE_CHAT_REPORT_ID = 'workspace_chat_456';
        const DESTINATION_REPORT_ID = 'destination_report_789';
        const SOURCE_REPORT_1_ID = 'source_report_101';
        const SOURCE_REPORT_2_ID = 'source_report_102';
        const REPORT_PREVIEW_ACTION_1_ID = 'preview_action_201';
        const REPORT_PREVIEW_ACTION_2_ID = 'preview_action_202';
        const TRANSACTION_1_ID = 'transaction_301';
        const TRANSACTION_2_ID = 'transaction_302';
        const SNAPSHOT_HASH = 999;

        const policy = createMock<OnyxTypes.Policy>({
            ...createRandomPolicy(1),
            id: POLICY_ID,
            ownerAccountID: currentUserAccountID,
            owner: currentUserEmail,
            role: CONST.POLICY.ROLE.ADMIN,
            type: CONST.POLICY.TYPE.TEAM,
        });

        const workspaceChatReport = createMock<OnyxTypes.Report>({
            ...createRandomReport(0, CONST.REPORT.CHAT_TYPE.POLICY_EXPENSE_CHAT),
            reportID: WORKSPACE_CHAT_REPORT_ID,
            policyID: POLICY_ID,
            type: CONST.REPORT.TYPE.CHAT,
            chatType: CONST.REPORT.CHAT_TYPE.POLICY_EXPENSE_CHAT,
        });

        const destinationReport = createMock<OnyxTypes.Report>({
            ...createRandomReport(0, undefined),
            reportID: DESTINATION_REPORT_ID,
            policyID: POLICY_ID,
            type: CONST.REPORT.TYPE.EXPENSE,
            managerID: currentUserAccountID,
            ownerAccountID: currentUserAccountID,
            stateNum: CONST.REPORT.STATE_NUM.OPEN,
            statusNum: CONST.REPORT.STATUS_NUM.OPEN,
            currency: CONST.CURRENCY.USD,
            total: 0,
            transactionCount: 0,
        });

        const sourceReport1 = createMock<OnyxTypes.Report>({
            ...createRandomReport(0, undefined),
            reportID: SOURCE_REPORT_1_ID,
            policyID: POLICY_ID,
            type: CONST.REPORT.TYPE.EXPENSE,
            managerID: currentUserAccountID,
            ownerAccountID: currentUserAccountID,
            stateNum: CONST.REPORT.STATE_NUM.OPEN,
            statusNum: CONST.REPORT.STATUS_NUM.OPEN,
            currency: CONST.CURRENCY.USD,
            parentReportID: WORKSPACE_CHAT_REPORT_ID,
            parentReportActionID: REPORT_PREVIEW_ACTION_1_ID,
            total: -1000,
            transactionCount: 1,
        });

        const sourceReport2 = createMock<OnyxTypes.Report>({
            ...createRandomReport(0, undefined),
            reportID: SOURCE_REPORT_2_ID,
            policyID: POLICY_ID,
            type: CONST.REPORT.TYPE.EXPENSE,
            managerID: currentUserAccountID,
            ownerAccountID: currentUserAccountID,
            stateNum: CONST.REPORT.STATE_NUM.OPEN,
            statusNum: CONST.REPORT.STATUS_NUM.OPEN,
            currency: CONST.CURRENCY.USD,
            parentReportID: WORKSPACE_CHAT_REPORT_ID,
            parentReportActionID: REPORT_PREVIEW_ACTION_2_ID,
            total: -2000,
            transactionCount: 1,
        });

        const reportPreviewAction1 = createMock<OnyxTypes.ReportAction>({
            ...createRandomReportAction(0),
            reportActionID: REPORT_PREVIEW_ACTION_1_ID,
            actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
            message: [{type: 'COMMENT', html: 'Report preview', text: 'Report preview'}],
            originalMessage: {
                linkedReportID: SOURCE_REPORT_1_ID,
            },
        });

        const reportPreviewAction2 = createMock<OnyxTypes.ReportAction>({
            ...createRandomReportAction(0),
            reportActionID: REPORT_PREVIEW_ACTION_2_ID,
            actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
            message: [{type: 'COMMENT', html: 'Report preview', text: 'Report preview'}],
            originalMessage: {
                linkedReportID: SOURCE_REPORT_2_ID,
            },
        });

        const transaction1 = createMock<OnyxTypes.Transaction>({
            ...createRandomTransaction(0),
            transactionID: TRANSACTION_1_ID,
            reportID: SOURCE_REPORT_1_ID,
            amount: -1000,
            currency: CONST.CURRENCY.USD,
        });

        const transaction2 = createMock<OnyxTypes.Transaction>({
            ...createRandomTransaction(0),
            transactionID: TRANSACTION_2_ID,
            reportID: SOURCE_REPORT_2_ID,
            amount: -2000,
            currency: CONST.CURRENCY.USD,
        });

        let mockFetch: MockFetch;
        beforeEach(async () => {
            await Onyx.merge(ONYXKEYS.SESSION, {
                accountID: currentUserAccountID,
                email: currentUserEmail,
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${POLICY_ID}`, policy);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${WORKSPACE_CHAT_REPORT_ID}`, workspaceChatReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`, destinationReport);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`, sourceReport1);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`, sourceReport2);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_1_ID}`, transaction1);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_2_ID}`, transaction2);
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${WORKSPACE_CHAT_REPORT_ID}`, {
                [REPORT_PREVIEW_ACTION_1_ID]: reportPreviewAction1,
                [REPORT_PREVIEW_ACTION_2_ID]: reportPreviewAction2,
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SOURCE_REPORT_1_ID}`, {
                someAction: createRandomReportAction(203),
            });
            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SOURCE_REPORT_2_ID}`, {
                someAction: createRandomReportAction(204),
            });
            await waitForBatchedUpdates();

            global.fetch = TestHelper.getGlobalFetchMock();
            mockFetch = getMockFetch(global.fetch);
            // Clear the queue before each test to avoid test pollution
            SequentialQueue.resetQueue();
        });

        afterEach(() => {
            jest.clearAllMocks();
            PusherHelper.teardown();
        });

        it('handles success case: moves transactions, deletes source reports, and updates parent preview actions in Onyx', async () => {
            mockFetch.pause();

            Report.mergeReports({
                destinationReportID: DESTINATION_REPORT_ID,
                sourceReportIDs: [SOURCE_REPORT_1_ID, SOURCE_REPORT_2_ID],
                isASAPSubmitBetaEnabled: false,
                accountID: currentUserAccountID,
                email: currentUserEmail,
                policy,
                policyTagList: {},
                allReports: {
                    [`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]: destinationReport,
                    [`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`]: sourceReport1,
                    [`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`]: sourceReport2,
                },
                bankAccountList: undefined,
                isTrackIntentUser: false,
                personalPolicyOutputCurrency: undefined,
                selfDMReportActions: undefined,
            });
            await waitForBatchedUpdates();

            // Verify optimistic state in Onyx
            // Transactions moved to destination report
            const tx1 = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_1_ID}`);
            expect(tx1?.reportID).toBe(DESTINATION_REPORT_ID);
            const tx2 = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_2_ID}`);
            expect(tx2?.reportID).toBe(DESTINATION_REPORT_ID);
            const destReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`);
            expect(destReport?.total).toBe(-3000);
            expect(destReport?.transactionCount).toBe(2);

            // Source reports marked as deleted
            const rep1 = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`);
            expect(rep1?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
            const rep2 = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`);
            expect(rep2?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);

            // Source report actions cleared optimistically
            const actions1 = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SOURCE_REPORT_1_ID}`);
            expect(actions1).toBeFalsy();
            const actions2 = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SOURCE_REPORT_2_ID}`);
            expect(actions2).toBeFalsy();

            // Parent report preview actions marked as deleted
            const parentActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${WORKSPACE_CHAT_REPORT_ID}`);
            expect(parentActions?.[REPORT_PREVIEW_ACTION_1_ID]?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
            expect(parentActions?.[REPORT_PREVIEW_ACTION_2_ID]?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);

            await mockFetch.resume();
            await waitForBatchedUpdates();

            // Verify success state in Onyx
            // Source reports deleted (null)
            const rep1AfterSuccess = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`);
            expect(rep1AfterSuccess).toBeFalsy();

            const rep2AfterSuccess = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`);
            expect(rep2AfterSuccess).toBeFalsy();

            // Parent preview actions cleared
            const parentActionsAfterSuccess = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${WORKSPACE_CHAT_REPORT_ID}`);
            expect(parentActionsAfterSuccess?.[REPORT_PREVIEW_ACTION_1_ID]).toBeFalsy();
            expect(parentActionsAfterSuccess?.[REPORT_PREVIEW_ACTION_2_ID]).toBeFalsy();
        });

        it('handles failure case: rolls back transaction moves, restores source reports, and restores parent preview actions in Onyx', async () => {
            mockFetch.pause();

            Report.mergeReports({
                destinationReportID: DESTINATION_REPORT_ID,
                sourceReportIDs: [SOURCE_REPORT_1_ID, SOURCE_REPORT_2_ID],
                isASAPSubmitBetaEnabled: false,
                accountID: currentUserAccountID,
                email: currentUserEmail,
                policy,
                policyTagList: {},
                allReports: {
                    [`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]: destinationReport,
                    [`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`]: sourceReport1,
                    [`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`]: sourceReport2,
                },
                bankAccountList: undefined,
                isTrackIntentUser: false,
                personalPolicyOutputCurrency: undefined,
                selfDMReportActions: undefined,
            });
            await waitForBatchedUpdates();

            mockFetch.fail();
            await mockFetch.resume();
            await waitForBatchedUpdates();

            // Verify failure state in Onyx
            // Transactions rolled back to source reports
            const tx1 = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_1_ID}`);
            expect(tx1?.reportID).toBe(SOURCE_REPORT_1_ID);

            const tx2 = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_2_ID}`);
            expect(tx2?.reportID).toBe(SOURCE_REPORT_2_ID);

            // Source reports restored
            const rep1 = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`);
            expect(rep1?.reportID).toBe(SOURCE_REPORT_1_ID);
            expect(rep1?.pendingAction).toBeUndefined();

            const rep2 = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`);
            expect(rep2?.reportID).toBe(SOURCE_REPORT_2_ID);
            expect(rep2?.pendingAction).toBeUndefined();

            // Parent preview actions restored with errors and keep pendingAction as DELETE
            const parentActions = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${WORKSPACE_CHAT_REPORT_ID}`);
            expect(parentActions?.[REPORT_PREVIEW_ACTION_1_ID]?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
            expect(parentActions?.[REPORT_PREVIEW_ACTION_1_ID]?.errors).toBeDefined();
            expect(parentActions?.[REPORT_PREVIEW_ACTION_2_ID]?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
            expect(parentActions?.[REPORT_PREVIEW_ACTION_2_ID]?.errors).toBeDefined();

            const destReport = await getOnyxValue(`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`);
            expect(destReport?.total).toBe(0);
            expect(destReport?.transactionCount).toBe(0);
        });

        it('correctly handles snapshot updates when hash is provided', async () => {
            mockFetch.pause();

            Report.mergeReports({
                destinationReportID: DESTINATION_REPORT_ID,
                sourceReportIDs: [SOURCE_REPORT_1_ID, SOURCE_REPORT_2_ID],
                isASAPSubmitBetaEnabled: false,
                accountID: currentUserAccountID,
                email: currentUserEmail,
                policy,
                policyTagList: {},
                allReports: {
                    [`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]: destinationReport,
                    [`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`]: sourceReport1,
                    [`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_2_ID}`]: sourceReport2,
                },
                hash: SNAPSHOT_HASH,
                bankAccountList: undefined,
                isTrackIntentUser: false,
                personalPolicyOutputCurrency: undefined,
                selfDMReportActions: undefined,
            });
            await waitForBatchedUpdates();

            // Check snapshot update in optimisticData via Onyx
            const snapshotOptimistic = await getOnyxValue(`${ONYXKEYS.COLLECTION.SNAPSHOT}${SNAPSHOT_HASH}`);
            expect(snapshotOptimistic?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`]?.pendingAction).toBe(CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
            expect(snapshotOptimistic?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]?.total).toBe(-3000);
            expect(snapshotOptimistic?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]?.transactionCount).toBe(2);

            mockFetch.fail();
            await mockFetch.resume();
            await waitForBatchedUpdates();

            // Check snapshot update in failureData via Onyx
            const snapshotFailure = await getOnyxValue(`${ONYXKEYS.COLLECTION.SNAPSHOT}${SNAPSHOT_HASH}`);
            expect(snapshotFailure?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${SOURCE_REPORT_1_ID}`]?.reportID).toBe(SOURCE_REPORT_1_ID);
            expect(snapshotFailure?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]?.total).toBe(0);
            expect(snapshotFailure?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${DESTINATION_REPORT_ID}`]?.transactionCount).toBe(0);
        });
    });

    describe('prepareOnyxDataForCleanUpOptimisticParticipants', () => {
        const REPORT_ID = '1';
        const OPTIMISTIC_ACCOUNT_ID = 100;
        const SETTLED_ACCOUNT_ID = 200;
        const CURRENT_USER_ACCOUNT_ID = 300;

        it('marks only participants with optimistic personal details for clean up', async () => {
            // Given a report with one optimistic and one settled participant
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {
                [`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`]: {
                    reportID: REPORT_ID,
                    participants: {
                        [OPTIMISTIC_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                        [SETTLED_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    },
                },
            });
            await waitForBatchedUpdates();

            // When preparing the clean up data using the provided personal details
            const result = Report.prepareOnyxDataForCleanUpOptimisticParticipants(
                REPORT_ID,
                {
                    [OPTIMISTIC_ACCOUNT_ID]: {accountID: OPTIMISTIC_ACCOUNT_ID, isOptimisticPersonalDetail: true},
                    [SETTLED_ACCOUNT_ID]: {accountID: SETTLED_ACCOUNT_ID},
                },
                CURRENT_USER_ACCOUNT_ID,
            );

            // Then only the optimistic participant is marked for clean up, and the settled login-less participant is reported
            expect(result).toEqual({
                settledPersonalDetails: {[OPTIMISTIC_ACCOUNT_ID]: null},
                redundantParticipants: {[OPTIMISTIC_ACCOUNT_ID]: null},
                missingLoginParticipants: [SETTLED_ACCOUNT_ID],
            });
        });

        it('returns empty clean up data when no participant has optimistic personal details', async () => {
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {
                [`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`]: {
                    reportID: REPORT_ID,
                    participants: {[SETTLED_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS}},
                },
            });
            await waitForBatchedUpdates();

            const result = Report.prepareOnyxDataForCleanUpOptimisticParticipants(REPORT_ID, {[SETTLED_ACCOUNT_ID]: {accountID: SETTLED_ACCOUNT_ID}}, CURRENT_USER_ACCOUNT_ID);

            expect(result).toEqual({settledPersonalDetails: {}, redundantParticipants: {}, missingLoginParticipants: [SETTLED_ACCOUNT_ID]});
        });

        it('returns undefined when the report has no participants', async () => {
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {[`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`]: {reportID: REPORT_ID}});
            await waitForBatchedUpdates();

            const result = Report.prepareOnyxDataForCleanUpOptimisticParticipants(
                REPORT_ID,
                {[OPTIMISTIC_ACCOUNT_ID]: {accountID: OPTIMISTIC_ACCOUNT_ID, isOptimisticPersonalDetail: true}},
                CURRENT_USER_ACCOUNT_ID,
            );

            expect(result).toBeUndefined();
        });

        it('returns undefined when the report does not exist', () => {
            const result = Report.prepareOnyxDataForCleanUpOptimisticParticipants(
                'non-existent-report',
                {[OPTIMISTIC_ACCOUNT_ID]: {accountID: OPTIMISTIC_ACCOUNT_ID, isOptimisticPersonalDetail: true}},
                CURRENT_USER_ACCOUNT_ID,
            );

            expect(result).toBeUndefined();
        });

        it('never cleans up the current user even if their personal details are optimistic (prevents avatar flicker, see #95427)', async () => {
            // Given the current user is a participant whose own personal details are still optimistic
            await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {
                [`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`]: {
                    reportID: REPORT_ID,
                    participants: {
                        [CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                        [OPTIMISTIC_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
                    },
                },
            });
            await waitForBatchedUpdates();

            // When preparing the clean up data with the current user's account ID
            const result = Report.prepareOnyxDataForCleanUpOptimisticParticipants(
                REPORT_ID,
                {
                    [CURRENT_USER_ACCOUNT_ID]: {accountID: CURRENT_USER_ACCOUNT_ID, isOptimisticPersonalDetail: true},
                    [OPTIMISTIC_ACCOUNT_ID]: {accountID: OPTIMISTIC_ACCOUNT_ID, isOptimisticPersonalDetail: true},
                },
                CURRENT_USER_ACCOUNT_ID,
            );

            // Then the current user's personal details are preserved and only the other optimistic participant is cleaned up
            expect(result).toEqual({
                settledPersonalDetails: {[OPTIMISTIC_ACCOUNT_ID]: null},
                redundantParticipants: {[OPTIMISTIC_ACCOUNT_ID]: null},
                missingLoginParticipants: [],
            });
        });
    });
});