import React from 'react';
import { fireEvent, screen } from '@testing-library/react';
import { BRAND_AWAL, BRAND_KNR } from '@theorchard/constants';
import { type Identity } from '@theorchard/suite-frontend';
import { renderInAppContext } from '@theorchard/suite-testing';
import { BrowserRouter as Router } from 'react-router-dom';
import { referencePaymentEntities } from 'src/__fixtures__/graphql/reference-payment-entity';
import * as abacusReferenceAgreementTypesQuery from 'src/apollo/queries/abacus-reference-agreement-types';
import * as referencePaymentEntityQuery from 'src/apollo/queries/reference-payment-entity';
import { PAID_BY_TOOLTIP_MSG } from 'src/apollo/type-constants/account';
import PayeeFields, {
    type PayeeFieldsProps,
} from 'src/components/payee-form/payee-fields';
import { USER_FEATURES } from 'src/constants';
import * as paymentNameUtil from 'src/utils/getPaymentEntityNameById';
import type { IPayeeFormData } from 'src/types/payee-form';
import * as payoneerProgramQuery from 'src/apollo/queries/payment-entity-payoneer-program';
import type { GetPaymentEntityPayoneerProgramsListQuery } from 'src/apollo/queries/payment-entity-payoneer-program/__generated__/get-payment-entity-payoneer-programs-list';
import { NetworkStatus } from '@apollo/client';

const renderComponent = (props: PayeeFieldsProps, identity?: Identity) =>
    renderInAppContext(
        <Router>
            <PayeeFields {...props} />
        </Router>,
        { identity }
    );

describe('<PayeeFields>', () => {
    const defaultProps: PayeeFieldsProps = {
        errors: {},
        payeeFormData: {} as IPayeeFormData,
        contracts: [],
        changeHandler: jest.fn(() => jest.fn()),
        setErrors: jest.fn(),
        paymentPendingInCurrentStatementPeriod: null,
    };
    const mockIdentity = {
        features: {
            [USER_FEATURES.ABACUS_RELEASE_PAYEE]: true,
        },
        id: '',
    };
    afterEach(jest.restoreAllMocks);

    beforeEach(() => {
        jest.spyOn(
            referencePaymentEntityQuery,
            'useReferencePaymentEntities'
        ).mockReturnValue({
            data: referencePaymentEntities,
            loading: false,
            error: undefined,
        });
        jest.spyOn(
            abacusReferenceAgreementTypesQuery,
            'useReferenceAgreementTypes'
        ).mockReturnValue({
            data: {
                abacusReferenceAgreementTypes: [
                    {
                        agreementType: 'AWAL Core',
                        referenceAgreementTypeId: '1',
                    },
                    { agreementType: 'AWAL +', referenceAgreementTypeId: '2' },
                    {
                        agreementType: 'AWAL Recordings',
                        referenceAgreementTypeId: '3',
                    },
                ],
            },
            loading: false,
        });
        jest.spyOn(
            payoneerProgramQuery,
            'usePayoneerProgramsList'
        ).mockReturnValue({
            data: {
                abacusPaymentEntityPayoneerProgramsList: {
                    totalCount: 2,
                    items: [
                        {
                            agreementType: 'AWAL Core',
                            paymentCurrency: 'EUR',
                            paymentService: 'Payoneer',
                            referencePaymentTypeId: 1,
                            referencePaymentEntity: {
                                paymentEntityName: 'AWAL-UK',
                                referencePaymentEntityId: '1',
                            },
                            payoneerProgram: null,
                        },
                        {
                            agreementType: 'AWAL +',
                            paymentCurrency: 'GBP',
                            paymentService: 'Wire',
                            referencePaymentTypeId: 2,
                            referencePaymentEntity: {
                                paymentEntityName: 'AWAL-US',
                                referencePaymentEntityId: '2',
                            },
                            payoneerProgram: null,
                        },
                    ],
                },
            } as GetPaymentEntityPayoneerProgramsListQuery,
            fetchMore: jest.fn(),
            loading: false,
            error: undefined,
            networkStatus: NetworkStatus.ready,
        });
    });

    it('renders', () => {
        const { container } = renderComponent(defaultProps, mockIdentity);
        expect(container).toBeDefined();
        expect(screen.getByText('Paid By')).toBeDefined();
        expect(
            container
                .querySelector('.paymentEntity')
                ?.classList.contains('Select--is-disabled')
        ).toBe(false);
        expect(screen.getByText('Payment Currency')).toBeDefined();
        expect(
            screen
                .getByTestId('currencySelect')
                .querySelector('.Select')
                ?.classList.contains('Select--is-disabled')
        ).toBe(true);
        expect(screen.getByText('Payment Schedule')).toBeDefined();
        expect(screen.getByText('Payment Minimum')).toBeDefined();
        expect(screen.getByText('Payment Method')).toBeDefined();
        expect(
            container
                .querySelector('.paymentType')
                // @ts-expect-error: classList does work
                ?.firstChild?.classList.contains('Select--is-disabled')
        ).toBe(true);
    });

    it('renders paymentDescription', () => {
        const { container } = renderComponent(
            {
                ...defaultProps,
                // @ts-expect-error: ignore other required props of payeeFormData
                payeeFormData: { paymentDescription: 'test description' },
            },
            mockIdentity
        );
        expect(container).toBeDefined();
        expect(screen.getByText('Payment Description')).toBeDefined();
        expect(screen.getByText('test description')).toBeDefined();
    });

    it('renders payment entity dropdown', () => {
        const props: PayeeFieldsProps = {
            ...defaultProps,
            payeeFormData: {
                accountPaymentTermId: '123',
                currencyCode: 'USD',
                // @ts-expect-error: ignore other required props of paymentEntity
                paymentEntity: {
                    referencePaymentEntityId: '1',
                },
            },
        };
        const { container } = renderComponent(props, mockIdentity);
        const paymentEntityNode = container.querySelector('.paymentEntity');
        expect(paymentEntityNode?.textContent).toContain('AWAL-UK');
    });

    it('disables payment entity select when rendered as edit form', () => {
        const props: PayeeFieldsProps = {
            ...defaultProps,
            payeeFormData: {
                accountPaymentTermId: '123',
                currencyCode: 'USD',
                paymentEntity: {
                    referencePaymentEntityId: '1',
                    paymentEntityName: 'AWAL-UK',
                },
            } as IPayeeFormData,
        };
        renderComponent(props, mockIdentity);
        expect(
            screen
                ?.getByTestId('Dropdown_paymentEntity')
                // @ts-expect-error: classList does work
                ?.firstChild?.classList.value.includes('is-disabled')
        ).toBe(true);
    });

    it('when paymentEntity select is KNR', () => {
        const props: PayeeFieldsProps = {
            ...defaultProps,
            // @ts-expect-error: ignore other required props of payeeFormData
            payeeFormData: {
                paymentEntityId: '3',
            },
        };
        jest.spyOn(paymentNameUtil, 'getPaymentEntityNameById').mockReturnValue(
            BRAND_KNR
        );

        renderComponent(props, mockIdentity);
        expect(screen.getByTestId('input-sap-vendor-id')).toBeInTheDocument();
        expect(screen.queryByTestId('payeeFieldsPayoneer')).not.toBe(null);
    });

    it('when paymentEntity select is AWAL', () => {
        const props: PayeeFieldsProps = {
            ...defaultProps,
            // @ts-expect-error: ignore other required props of payeeFormData
            payeeFormData: {
                paymentEntityId: '1',
            },
        };
        jest.spyOn(paymentNameUtil, 'getPaymentEntityNameById').mockReturnValue(
            BRAND_AWAL
        );

        renderComponent(props, mockIdentity);
        expect(screen.queryByTestId('input-sap-vendor-id')).toBe(null);
        expect(screen.getByTestId('payeeFieldsPayoneer')).toBeInTheDocument();
    });

    it('shows SAP field when paymentService prop is SAP', () => {
        jest.spyOn(paymentNameUtil, 'getPaymentEntityNameById').mockReturnValue(
            BRAND_AWAL
        );
        renderComponent(
            { ...defaultProps, paymentService: 'sap' },
            mockIdentity
        );
        expect(screen.getByTestId('input-sap-vendor-id')).toBeInTheDocument();
    });

    it('shows SAP field when selected payment method is SAP', () => {
        jest.spyOn(
            payoneerProgramQuery,
            'usePayoneerProgramsList'
        ).mockReturnValue({
            data: {
                abacusPaymentEntityPayoneerProgramsList: {
                    totalCount: 1,
                    items: [
                        {
                            agreementType: null,
                            paymentCurrency: 'EUR',
                            paymentService: 'SAP',
                            referencePaymentTypeId: 5,
                            referenceAgreementTypeId: null,
                            referencePaymentEntity: {
                                paymentEntityName: 'AWAL-UK',
                                referencePaymentEntityId: '1',
                            },
                            payoneerProgram: null,
                        },
                    ],
                },
            } as GetPaymentEntityPayoneerProgramsListQuery,
            fetchMore: jest.fn(),
            loading: false,
            error: undefined,
            networkStatus: NetworkStatus.ready,
        });
        jest.spyOn(paymentNameUtil, 'getPaymentEntityNameById').mockReturnValue(
            BRAND_AWAL
        );
        const props: PayeeFieldsProps = {
            ...defaultProps,
            payeeFormData: {
                ...({} as IPayeeFormData),
                paymentEntityId: '1',
                referencePaymentTypeId: '5',
            },
        };
        renderComponent(props, mockIdentity);
        expect(screen.getByTestId('input-sap-vendor-id')).toBeInTheDocument();
    });

    it('enables payment entity when paymentEntityId is null', () => {
        const props: PayeeFieldsProps = {
            ...defaultProps,
            payeeFormData: {
                // @ts-expect-error: ignore other required props of paymentEntity
                paymentEntity: {
                    referencePaymentEntityId: '',
                },
            },
        };
        jest.spyOn(paymentNameUtil, 'getPaymentEntityNameById').mockReturnValue(
            null
        );

        const { container } = renderComponent(props, mockIdentity);
        expect(
            container
                .querySelector('.paymentEntity')
                ?.classList.value.includes('is-disabled')
        ).toBe(false);
    });

    it('enables payment entity if the number of contracts is 0 and the agreement type is null', () => {
        const props: PayeeFieldsProps = {
            ...defaultProps,
            payeeFormData: {
                // @ts-expect-error: ignore other required props of paymentEntity
                paymentEntity: {
                    referencePaymentEntityId: '1',
                },
                agreementType: null,
            },
        };
        jest.spyOn(paymentNameUtil, 'getPaymentEntityNameById').mockReturnValue(
            null
        );

        const { container } = renderComponent(props, mockIdentity);
        expect(
            container
                .querySelector('.paymentEntity')
                ?.classList.value.includes('is-disabled')
        ).toBe(false);
    });

    it('shows tooltip for "Paid By" field', async () => {
        renderComponent(defaultProps, mockIdentity);

        const tooltipIcon =
            screen.queryByTestId('HelpTooltip') ?? new Element();
        expect(tooltipIcon).toBeDefined();

        fireEvent.mouseOver(tooltipIcon);

        const tooltipText = await screen.findByText(PAID_BY_TOOLTIP_MSG);
        expect(tooltipText).toBeDefined();
    });

    describe('payment method options', () => {
        it('renders payment method options for selected payment entity', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1', // AWAL-UK
                        referencePaymentTypeId: '',
                    },
                },
                mockIdentity
            );

            expect(
                (
                    container.querySelector('.paymentType')
                        ?.firstChild as HTMLElement
                )?.classList?.contains('Select--is-disabled')
            ).toBe(false);
        });

        it('disables payment method dropdown when no entity selected', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: undefined,
                        referencePaymentTypeId: '',
                    },
                },
                mockIdentity
            );

            expect(
                (
                    container.querySelector('.paymentType')
                        ?.firstChild as HTMLElement
                )?.classList?.contains('Select--is-disabled')
            ).toBe(true);
        });

        it('shows current referencePaymentTypeId as a disabled option when not in available payment methods', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    paymentService: 'paychex',
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1', // AWAL-UK — programs have referencePaymentTypeId 1 and 2
                        referencePaymentTypeId: '10', // not in programs list
                    },
                },
                mockIdentity
            );

            // The selected value label should display 'paychex'
            expect(
                container.querySelector('.paymentType')?.textContent
            ).toContain('paychex');

            // Open the dropdown and verify the 'paychex' option is rendered as disabled
            const input = container
                .querySelector('.paymentType')
                ?.querySelector('input');
            fireEvent.mouseDown(input!);

            const disabledOption = container.querySelector(
                '.Select__option--is-disabled'
            );
            expect(disabledOption).not.toBeNull();
            expect(disabledOption?.textContent).toContain('paychex');
        });

        it('does not add a disabled option when referencePaymentTypeId is in the available options', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    paymentService: 'Payoneer',
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '1', // exists in programs list
                    },
                },
                mockIdentity
            );

            const input = container
                .querySelector('.paymentType')
                ?.querySelector('input');
            fireEvent.mouseDown(input!);

            const disabledOption = container.querySelector(
                '.Select__option--is-disabled'
            );
            expect(disabledOption).toBeNull();
        });

        it('disables payment method dropdown while payoneer programs are loading', () => {
            jest.spyOn(
                payoneerProgramQuery,
                'usePayoneerProgramsList'
            ).mockReturnValue({
                data: undefined,
                fetchMore: jest.fn(),
                loading: true,
                error: undefined,
                networkStatus: NetworkStatus.loading,
            });

            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '',
                    },
                },
                mockIdentity
            );

            expect(
                (
                    container.querySelector('.paymentType')
                        ?.firstChild as HTMLElement
                )?.classList?.contains('Select--is-disabled')
            ).toBe(true);
        });

        it('filters payment method options by selected currency', () => {
            jest.spyOn(
                payoneerProgramQuery,
                'usePayoneerProgramsList'
            ).mockReturnValue({
                data: {
                    abacusPaymentEntityPayoneerProgramsList: {
                        totalCount: 2,
                        items: [
                            {
                                agreementType: 'AWAL Core',
                                paymentCurrency: 'EUR',
                                paymentService: 'Payoneer',
                                referencePaymentTypeId: 1,
                                referenceAgreementTypeId: '1',
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                                payoneerProgram: null,
                            },
                            {
                                agreementType: 'AWAL +',
                                paymentCurrency: 'USD',
                                paymentService: 'Wire',
                                referencePaymentTypeId: 2,
                                referenceAgreementTypeId: '2',
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                                payoneerProgram: null,
                            },
                        ],
                    },
                } as GetPaymentEntityPayoneerProgramsListQuery,
                fetchMore: jest.fn(),
                loading: false,
                error: undefined,
                networkStatus: NetworkStatus.ready,
            });

            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        currencyCode: 'EUR',
                        referencePaymentTypeId: '',
                    },
                },
                mockIdentity
            );

            const input = container
                .querySelector('.paymentType')
                ?.querySelector('input');
            fireEvent.mouseDown(input!);

            expect(screen.getByText('Payoneer')).toBeInTheDocument();
            expect(screen.queryByText('Wire')).toBeNull();
        });
    });

    describe('handlePaymentEntityChange', () => {
        it('resets referencePaymentTypeId and agreementTypeId when new entity has no matching payment method', () => {
            const setPaymentEntityId = jest.fn();
            const setPaymentType = jest.fn();
            const setAgreementTypeId = jest.fn();

            const changeHandlerMock = jest.fn((field: string) => {
                if (field === 'paymentEntityId') return setPaymentEntityId;
                if (field === 'referencePaymentTypeId') return setPaymentType;
                if (field === 'agreementTypeId') return setAgreementTypeId;
                return jest.fn();
            });

            renderComponent(
                {
                    ...defaultProps,
                    changeHandler: changeHandlerMock,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '1',
                        agreementTypeId: '123',
                    },
                },
                mockIdentity
            );

            const selectInput = screen
                .getByTestId('Dropdown_paymentEntity')
                ?.querySelector('input');

            fireEvent.mouseDown(selectInput!);
            fireEvent.click(screen.getByText('AWAL-US'));

            expect(changeHandlerMock).toHaveBeenCalledWith('paymentEntityId');
            expect(setPaymentType).toHaveBeenCalledWith('');
            expect(setAgreementTypeId).toHaveBeenCalledWith('');
        });

        it('resets referencePaymentTypeId and agreementTypeId when entity is cleared', () => {
            const setPaymentEntityId = jest.fn();
            const setPaymentType = jest.fn();
            const setAgreementTypeId = jest.fn();

            const changeHandlerMock = jest.fn((field: string) => {
                if (field === 'paymentEntityId') return setPaymentEntityId;
                if (field === 'referencePaymentTypeId') return setPaymentType;
                if (field === 'agreementTypeId') return setAgreementTypeId;
                return jest.fn();
            });

            renderComponent(
                {
                    ...defaultProps,
                    changeHandler: changeHandlerMock,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '1',
                        agreementTypeId: '123',
                    },
                },
                mockIdentity
            );

            const clearButton = screen
                .getByTestId('Dropdown_paymentEntity')
                ?.querySelector('.Select__clear-indicator');

            expect(clearButton).toBeTruthy();
            fireEvent.mouseDown(clearButton!);

            expect(changeHandlerMock).toHaveBeenCalledWith('paymentEntityId');
            expect(setPaymentType).toHaveBeenCalledWith('');
            expect(setAgreementTypeId).toHaveBeenCalledWith('');
        });
    });

    describe('allowedAgreementTypeIds from selected program', () => {
        let payoneerProgramsSpy: jest.SpyInstance;

        beforeEach(() => {
            payoneerProgramsSpy = jest
                .spyOn(payoneerProgramQuery, 'usePayoneerProgramsList')
                .mockReturnValue({
                    data: {
                        abacusPaymentEntityPayoneerProgramsList: {
                            totalCount: 1,
                            items: [
                                {
                                    agreementType: 'AWAL Core',
                                    paymentCurrency: 'EUR',
                                    paymentService: 'Payoneer',
                                    referencePaymentTypeId: 1,
                                    referenceAgreementTypeId: '1,3',
                                    referencePaymentEntity: {
                                        paymentEntityName: 'AWAL-UK',
                                        referencePaymentEntityId: '1',
                                    },
                                    payoneerProgram: null,
                                },
                            ],
                        },
                    } as GetPaymentEntityPayoneerProgramsListQuery,
                    fetchMore: jest.fn(),
                    loading: false,
                    error: undefined,
                    networkStatus: NetworkStatus.ready,
                });
        });

        const openAgreementTypeDropdown = (container: HTMLElement) => {
            const input = container.querySelector(
                '#agreementTypeDropdown input'
            );
            if (input) fireEvent.keyDown(input, { key: 'ArrowDown' });
        };

        it('filters agreement type options based on selected program referenceAgreementTypeId', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        currencyCode: 'EUR',
                        referencePaymentTypeId: '1',
                    },
                },
                mockIdentity
            );
            openAgreementTypeDropdown(container);
            expect(screen.getByText('AWAL Core')).toBeDefined();
            expect(screen.queryByText('AWAL +')).toBeNull();
            expect(screen.getByText('AWAL Recordings')).toBeDefined();
        });

        it('unions referenceAgreementTypeIds across multiple programs for the same entity+service', () => {
            payoneerProgramsSpy.mockReturnValue({
                data: {
                    abacusPaymentEntityPayoneerProgramsList: {
                        totalCount: 2,
                        items: [
                            {
                                agreementType: 'AWAL Core',
                                paymentCurrency: 'EUR',
                                paymentService: 'Payoneer',
                                referencePaymentTypeId: 7,
                                referenceAgreementTypeId: '1',
                                payoneerProgram: null,
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                            },
                            {
                                agreementType: 'AWAL +,AWAL Recordings',
                                paymentCurrency: 'EUR',
                                paymentService: 'Payoneer',
                                referencePaymentTypeId: 7,
                                referenceAgreementTypeId: '2,3',
                                payoneerProgram: null,
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                            },
                        ],
                    },
                } as GetPaymentEntityPayoneerProgramsListQuery,
                fetchMore: jest.fn(),
                loading: false,
                error: undefined,
                networkStatus: NetworkStatus.ready,
            });

            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        currencyCode: 'EUR',
                        referencePaymentTypeId: '7',
                    },
                },
                mockIdentity
            );
            openAgreementTypeDropdown(container);
            expect(screen.getByText('AWAL Core')).toBeDefined();
            expect(screen.getByText('AWAL +')).toBeDefined();
            expect(screen.getByText('AWAL Recordings')).toBeDefined();
        });

        it('filters by referencePaymentTypeId', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        currencyCode: 'EUR',
                        referencePaymentTypeId: '1',
                    },
                },
                mockIdentity
            );

            openAgreementTypeDropdown(container);

            expect(screen.getByText('AWAL Core')).toBeDefined();
            expect(screen.queryByText('AWAL +')).toBeNull();
            expect(screen.getByText('AWAL Recordings')).toBeDefined();
        });

        it('shows all agreement types for the entity regardless of payment method', () => {
            // There are two different payment methods for the same entity - both agreement types should be visible
            payoneerProgramsSpy.mockReturnValue({
                data: {
                    abacusPaymentEntityPayoneerProgramsList: {
                        totalCount: 2,
                        items: [
                            {
                                agreementType: 'AWAL Core',
                                paymentCurrency: 'EUR',
                                paymentService: 'Payoneer',
                                referencePaymentTypeId: 1,
                                referenceAgreementTypeId: '1',
                                payoneerProgram: null,
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                            },
                            {
                                agreementType: 'AWAL +',
                                paymentCurrency: 'EUR',
                                paymentService: 'Wire',
                                referencePaymentTypeId: 2,
                                referenceAgreementTypeId: '2',
                                payoneerProgram: null,
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                            },
                        ],
                    },
                } as GetPaymentEntityPayoneerProgramsListQuery,
                fetchMore: jest.fn(),
                loading: false,
                error: undefined,
                networkStatus: NetworkStatus.ready,
            });

            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '1', // only matches the first program, but both agreement types should be shown
                    },
                },
                mockIdentity
            );

            openAgreementTypeDropdown(container);

            expect(screen.getByText('AWAL Core')).toBeDefined();
            expect(screen.getByText('AWAL +')).toBeDefined();
        });

        it('shows all agreement types for the entity regardless of currency', () => {
            payoneerProgramsSpy.mockReturnValue({
                data: {
                    abacusPaymentEntityPayoneerProgramsList: {
                        totalCount: 2,
                        items: [
                            {
                                agreementType: 'AWAL Core',
                                paymentCurrency: 'EUR',
                                paymentService: 'Payoneer',
                                referencePaymentTypeId: 1,
                                referenceAgreementTypeId: '1',
                                payoneerProgram: null,
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                            },
                            {
                                agreementType: 'AWAL +',
                                paymentCurrency: 'USD',
                                paymentService: 'Payoneer',
                                referencePaymentTypeId: 1,
                                referenceAgreementTypeId: '2',
                                payoneerProgram: null,
                                referencePaymentEntity: {
                                    paymentEntityName: 'AWAL-UK',
                                    referencePaymentEntityId: '1',
                                },
                            },
                        ],
                    },
                } as GetPaymentEntityPayoneerProgramsListQuery,
                fetchMore: jest.fn(),
                loading: false,
                error: undefined,
                networkStatus: NetworkStatus.ready,
            });

            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '1',
                        currencyCode: 'EUR',
                    },
                },
                mockIdentity
            );
            openAgreementTypeDropdown(container);
            expect(screen.getByText('AWAL Core')).toBeDefined();
            expect(screen.getByText('AWAL +')).toBeDefined(); // for USD
        });

        it('enables agreement type dropdown when entity is selected even without payment method', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '', // method is not selected
                    },
                },
                mockIdentity
            );
            const input = container.querySelector(
                '#agreementTypeDropdown input'
            );
            expect(input).not.toHaveAttribute('disabled');
        });

        it('does not show agreement types for a different entity', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '2', // AWAL-US — there is no program for this entity
                        referencePaymentTypeId: '',
                    },
                },
                mockIdentity
            );
            const input = container.querySelector(
                '#agreementTypeDropdown input'
            );

            expect(input).toHaveAttribute('disabled');
        });
    });

    describe('payoneerProgram resolution', () => {
        const mockPrograms = [
            {
                agreementType: 'AWAL Core',
                paymentCurrency: 'EUR',
                paymentService: 'Payoneer',
                referencePaymentTypeId: 7,
                referenceAgreementTypeId: '1',
                payoneerProgram: {
                    payoneerProgramId: 100176770,
                    fundingCurrency: 'EUR',
                    payoneerProgramName: 'AWAL Core - EUR',
                },
                referencePaymentEntity: {
                    paymentEntityName: 'AWAL-UK',
                    referencePaymentEntityId: '1',
                },
            },
            {
                agreementType: 'AWAL +,AWAL Recordings',
                paymentCurrency: 'EUR',
                paymentService: 'Payoneer',
                referencePaymentTypeId: 7,
                referenceAgreementTypeId: '2,3',
                payoneerProgram: {
                    payoneerProgramId: 100184450,
                    fundingCurrency: 'EUR',
                    payoneerProgramName: 'AWAL UK EUR',
                },
                referencePaymentEntity: {
                    paymentEntityName: 'AWAL-UK',
                    referencePaymentEntityId: '1',
                },
            },
        ];

        beforeEach(() => {
            jest.spyOn(
                payoneerProgramQuery,
                'usePayoneerProgramsList'
            ).mockReturnValue({
                data: {
                    abacusPaymentEntityPayoneerProgramsList: {
                        totalCount: 2,
                        items: mockPrograms,
                    },
                } as GetPaymentEntityPayoneerProgramsListQuery,
                fetchMore: jest.fn(),
                loading: false,
                error: undefined,
                networkStatus: NetworkStatus.ready,
            });
        });

        const baseFormData = {
            paymentEntityId: '1',
            referencePaymentTypeId: '7',
            currencyCode: 'EUR',
        };

        it('resolves payoneerProgram for agreementTypeId matching first program', () => {
            renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        ...baseFormData,
                        agreementTypeId: '1',
                    },
                },
                mockIdentity
            );

            expect(screen.getByText('AWAL Core - EUR')).toBeDefined();
            expect(screen.getByText('100176770')).toBeDefined();
        });

        it('shows hint when no agreementTypeId is selected', () => {
            renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        ...baseFormData,
                    },
                },
                mockIdentity
            );
            expect(
                screen.getAllByTestId('hintEmptyPayoneerProgram').length
            ).toBeGreaterThan(0);
        });

        it('shows hint when currencyCode does not match any program', () => {
            renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        ...baseFormData,
                        currencyCode: 'JPY',
                        agreementTypeId: '1',
                    },
                },
                mockIdentity
            );
            expect(
                screen.getAllByTestId('hintEmptyPayoneerProgram').length
            ).toBeGreaterThan(0);
        });
    });

    describe('KNR entity', () => {
        const knrPaymentEntity = {
            referencePaymentEntityId: '3',
            paymentEntityName: 'KNR-UK',
        };

        it('entity select is enabled for KNR when agreementType is null and there are no contracts', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    contracts: [],
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntity: knrPaymentEntity,
                        agreementType: null,
                    } as IPayeeFormData,
                },
                mockIdentity
            );

            expect(
                container
                    .querySelector('.paymentEntity')
                    ?.classList.value.includes('is-disabled')
            ).toBe(false);
        });

        it('payment method dropdown shows paymentService label for KNR', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    paymentService: 'SAP',
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntity: knrPaymentEntity,
                        referencePaymentTypeId: '99',
                    } as IPayeeFormData,
                },
                mockIdentity
            );

            expect(
                container.querySelector('.paymentType')?.textContent
            ).toContain('SAP');
        });

        it('hides agreement type dropdown for KNR', () => {
            const { container } = renderComponent(
                {
                    ...defaultProps,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntity: {
                            referencePaymentEntityId: '3',
                            paymentEntityName: 'KNR-UK',
                        },
                    } as IPayeeFormData,
                },
                mockIdentity
            );

            expect(
                container.querySelector('#agreementTypeDropdown')
            ).not.toBeInTheDocument();
        });
    });

    describe('handlePaymentMethodChange', () => {
        it('resets agreementTypeId when payment method is cleared', () => {
            const setAgreementTypeId = jest.fn();
            const changeHandlerMock = jest.fn((field: string) => {
                if (field === 'agreementTypeId') return setAgreementTypeId;
                return jest.fn();
            });

            const { container } = renderComponent(
                {
                    ...defaultProps,
                    changeHandler: changeHandlerMock,
                    payeeFormData: {
                        ...({} as IPayeeFormData),
                        paymentEntityId: '1',
                        referencePaymentTypeId: '1',
                    },
                },
                mockIdentity
            );

            const clearButton = container
                .querySelector('.paymentType')
                ?.querySelector(
                    '.Select__clear-indicator, [aria-label="Clear"]'
                );

            expect(clearButton).toBeTruthy();
            fireEvent.mouseDown(clearButton!);
            expect(setAgreementTypeId).toHaveBeenCalledWith('');
        });
    });
});