// Components
import coverageStatement from '@/layouts/coverage-statement/coverage-statement.vue';

// Supporting Files
import { nextTick } from 'vue';
import { mount } from '@vue/test-utils';
import { getMountOptions } from '@/helpers/unit-test-helper.js';
import { createTestingPinia } from '@pinia/testing';
import navigationScenarios from '@/router/router-constants/navigation-scenarios.js';
import { getRandomString, getRandomInt } from '@/helpers/data-generation.js';
import settleAllPromises from '@/helpers/layout-helper.js';
import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
import routerParams from '@/router/router-constants/router-params';
import { useMainStore } from '@/store/index.js';

jest.mock('@/helpers/layout-helper.js', () => jest.fn());

jest.mock('@/helpers/cms-content-helper', () => ({
    fetchCmsContentForPage: jest.fn(),
    setupModalLinks: jest.fn(),
    processIfStatements: jest.fn()
}));

const mockMixin = {
    methods: {
        getCmsContent: jest.fn().mockImplementation(() => ''),
        setCmsContent: jest.fn()
    }
};

const footerStub = {
    render: () => {},
    methods: {
        updateButtonText: jest.fn()
    }
};

const loadingModalStub = {
    render: () => {},
    methods: {
        showModal: jest.fn(),
        hideModal: jest.fn()
    }
};

function getMountedComponent(mainInitialState = {}, initialData = {}, methodToRun = () => {}) {
    const mountOptions = getMountOptions({
        router: {
            navigate: jest.fn()
        }
    });

    mountOptions.global.stubs = {
        siteFooter: footerStub,
        siteHeader: true,
        recalModal: true,
        contentGroupModal: true,
        alert: true,
        loadingModal: loadingModalStub
    };
    const testingPinia = createTestingPinia({
        initialState: {
            main: mainInitialState
        }
    });
    useMainStore(testingPinia);
    methodToRun();

    mountOptions.global.plugins = [testingPinia];
    mountOptions.mixins = [mockMixin];
    mountOptions.data = () => (
        initialData
    );

    const apiResponses = {
        supportingItems: []
    };
    const apiPromise = Promise.resolve(apiResponses);
    settleAllPromises.mockImplementation(() => apiPromise);
    fetchCmsContentForPage.mockImplementation(() => Promise.resolve());

    const wrapper = mount(coverageStatement, mountOptions);
    return { wrapper };
}

describe.skip('coverageStatement.vue', () => {
    describe('method arePagePrerequisitesValid...', () => {
        test('Should return true for valid page requisites if vin exists', () => {
            // Arrange
            const { wrapper } = getMountedComponent({
                order: {
                    vehicle: {
                        vin: getRandomString(5, 20)
                    }
                }
            });

            // Act
            const arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();

            // Assert
            expect(arePagePrerequisitesValid).toBeTruthy();
        });
        test('Should return false for valid page requisites if vin is missing', () => {
            // Arrange
            const { wrapper } = getMountedComponent({
                order: {
                    vehicle: {
                        vin: null
                    }
                }
            });

            // Act
            const arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();

            // Assert
            expect(arePagePrerequisitesValid).not.toBeTruthy();
        });
    });
    describe('Rendering', () => {
        test('Should render site header', () => {
            // Arrange
            const { wrapper } = getMountedComponent({});

            // Act
            const siteHeader = wrapper.findComponent({ ref: 'siteHeader' });

            // Assert
            expect(siteHeader.exists()).toBe(true);
        });
        test('Should render site subheader', () => {
            // Arrange
            const { wrapper } = getMountedComponent({});

            // Act
            const subheader = wrapper.find({ ref: 'siteSubHeader' });

            // Assert
            expect(subheader.exists()).toBe(true);
        });

        test('Should render explanatory text', () => {
            // Arrange
            const { wrapper } = getMountedComponent({});

            // Act
            const explanatoryText = wrapper.find({ ref: 'explanatoryText' });

            // Assert
            expect(explanatoryText.exists()).toBe(true);
        });
        test('Should render secondary text', () => {
            // Arrange
            const { wrapper } = getMountedComponent({});

            // Act
            const secondaryText = wrapper.find({ ref: 'secondaryText' });

            // Assert
            expect(secondaryText.exists()).toBe(true);
        });
        test('Should render site footer', () => {
            // Arrange
            const { wrapper } = getMountedComponent({});

            // Act
            const footer = wrapper.findComponent({ ref: 'siteFooter' });

            // Assert
            expect(footer.exists()).toBe(true);
        });
    });
    describe('Verified ITAC scenario', () => {
        test('If policy lookup successful, not No Comp, and deductible > service price, verifiedITAC returns true', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice + 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        },
                        policyLookupSuccessful: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]
            });

            // Assert
            expect(wrapper.vm.verifiedITAC).toBeTruthy();
        });
        test('If policy lookup unsuccessful, verifiedITAC returns false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        policyLookupSuccessful: false
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.verifiedITAC).toBeFalsy();
        });
        test('If No Comp, verifiedITAC returns false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.verifiedITAC).toBeFalsy();
        });
        test('If deductible < service price, verifiedITAC returns false', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice - 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        }
                    }
                }
            };

            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]
            });

            // Assert
            expect(wrapper.vm.verifiedITAC).toBeFalsy();
        });
    });
    describe('Verified Deductible scenario', () => {
        test('If policy lookup successful, not No Comp, and service price > deductible, verifiedITAC returns true', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice - 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        },
                        policyLookupSuccessful: true
                    }
                }
            };

            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]
            });

            // Assert
            expect(wrapper.vm.verifiedDeductible).toBeTruthy();
        });
        test('If policy lookup unsuccessful, verifiedDeductible returns false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        policyLookupSuccessful: false
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.verifiedDeductible).toBeFalsy();
        });
        test('If No Comp, verifiedDeductible returns false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.verifiedDeductible).toBeFalsy();
        });
        test('If service price < deductible, verifiedDeductible returns false', () => {
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice + 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        }
                    }
                }
            };

            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]
            });

            // Assert
            expect(wrapper.vm.verifiedDeductible).toBeFalsy();
        });
        test('If deductible is null, verifiedDeductible returns false', () => {
            const sellingPrice = getRandomInt(100, 500);
            const deductible = null;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        }
                    }
                }
            };

            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]
            });

            // Assert
            expect(wrapper.vm.verifiedDeductible).toBeFalsy();
        });
    });
    describe('No Comp scenario', () => {
        test('If noCoverage = true, verifiedNoComp returns true', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: true,
                        policyLookupSuccessful: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.verifiedNoComp).toBeTruthy();
        });
        test('If noCoverage = false, verifiedNoComp returns false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.verifiedNoComp).toBeFalsy();
        });
    });
    describe('Unverified scenario', () => {
        test('If policyLookupSuccessful false, unverified returns true', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        policyLookupSuccessful: false
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.unverified).toBeTruthy();
        });
        test('If policyLookupSuccessful is true, unverified returns false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        policyLookupSuccessful: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.unverified).toBeFalsy();
        });
    });
    describe('Navigation', () => {
        test('If Unverified, navigate forward with CLICKED_FORWARD scenario', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        policyLookupSuccessful: false
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.$router.navigate)
                .toHaveBeenCalledWith(
                    navigationScenarios.CLICKED_FORWARD,
                    undefined,
                    {},
                    { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                );
        });
        test('If Verified Deductible, navigate forward with CLICKED_FORWARD scenario', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice - 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        },
                        policyLookupSuccessful: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]
            });

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.$router.navigate)
                .toHaveBeenCalledWith(
                    navigationScenarios.CLICKED_FORWARD,
                    undefined,
                    {},
                    { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                );
        });
        test('If Verified ITAC and selected Safelite, navigate forward with CLICKED_FORWARD_WITH_SAFELITE scenario', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice + 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        },
                        policyLookupSuccessful: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ],
                selectedProvider: 'Safelite'
            });

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.$router.navigate)
                .toHaveBeenCalledWith(
                    navigationScenarios.CLICKED_FORWARD_WITH_SAFELITE,
                    undefined,
                    {},
                    { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                );
        });
        test('If Verified ITAC, selected other shop, and TPA enabled, navigate forward w/ CLICKED_FORWARD_WITH_TPA_ENABLED', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice + 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        },
                        policyLookupSuccessful: true
                    }
                },
                issConfig: {
                    enableTPAFlow: true
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ],
                selectedProvider: 'Other'
            });

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.$router.navigate)
                .toHaveBeenCalledWith(
                    navigationScenarios.CLICKED_FORWARD_WITH_TPA_ENABLED,
                    undefined,
                    {},
                    { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                );
        });
        test('If Verified ITAC, selected other shop, and TPA disabled, navigate forward w/ CLICKED_FORWARD_WITH_TPA_DISABLED', () => {
            // Arrange
            const sellingPrice = getRandomInt(100, 500);
            const deductible = sellingPrice + 1;
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        },
                        policyLookupSuccessful: true
                    }
                },
                issConfig: {
                    enableTPAFlow: false
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                availableLineItems: [
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ],
                selectedProvider: 'Other'
            });

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.$router.navigate)
                .toHaveBeenCalledWith(
                    navigationScenarios.CLICKED_FORWARD_WITH_TPA_DISABLED,
                    undefined,
                    {},
                    { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                );
        });
        test('If No Comp and selected Safelite, navigate forward with CLICKED_FORWARD scenario', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    },
                    policy: {
                        noCoverage: true,
                        policyLookupSuccessful: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);
            wrapper.setData({
                isVerified: false,
                selectedProvider: 'Safelite'
            });

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.$router.navigate)
                .toHaveBeenCalledWith(
                    navigationScenarios.CLICKED_FORWARD_WITH_SAFELITE,
                    undefined,
                    {},
                    { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                );
        });
    });
    describe('ADAS', () => {
        test('if Replace and parts require recalibration, isADAS should return true', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: false
                    },
                    lineItems: {
                        glassParts: [
                            {
                                requiresRecalibration: true
                            }
                        ]
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.isADAS).toBeTruthy();
        });
        test('if Replace and parts do not require recalibration, isADAS should return false', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: false
                    },
                    lineItems: {
                        glassParts: [
                            {
                                requiresRecalibration: false
                            }
                        ]
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.isADAS).toBeFalsy();
        });
        test('if Repair, isADAS should return true', () => {
            // Arrange
            const mainInitialState = {
                order: {
                    damage: {
                        isRepair: true
                    }
                }
            };
            const { wrapper } = getMountedComponent(mainInitialState);

            // Assert
            expect(wrapper.vm.isADAS).toBeFalsy();
        });
    });
    describe('claim registration api call', () => {
        it('claim registration not required => method not called', async () => {
            // Arrange
            const { wrapper } = getMountedComponent({
                issConfig: {
                    isClaimRegistrationRequired: false
                }
            });

            // Assert
            expect(wrapper.vm.mainStore.registerClaim).not.toHaveBeenCalled();
        });

        it('claim registration required => register claim method called', async () => {
            // Arrange
            const sellingPrice = getRandomInt(50, 100);
            const deductible = sellingPrice - 1;
            const initialStore = {
                order: {
                    policy: {
                        policyLookupSuccessful: true,
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        }
                    },
                    damage: {
                        isRepair: true
                    }
                },
                issConfig: {
                    isClaimRegistrationRequired: true
                }
            };
            const mockStoreActions = () => {
                useMainStore().getWipers = jest.fn().mockImplementation(() => Promise.resolve());
                useMainStore().getRainDefense = jest.fn().mockImplementation(() => Promise.resolve());
                useMainStore().getSupportingItems = jest.fn().mockImplementation(() => Promise.resolve());
                useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]));
            };
            const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
            const next = (method) => { method(wrapper.vm); };

            // Act
            coverageStatement.beforeRouteEnter.call(wrapper.vm, undefined, undefined, next);
            for (let i = 0; i < 7; i++) {
                // eslint-disable-next-line no-await-in-loop
                await nextTick();
            }

            // Assert
            expect(wrapper.vm.mainStore.registerClaim).toHaveBeenCalled();
        });
    });
});

describe('coverageStatement.vue-working', () => {
    describe('ITAC flag', () => {
        test('ITAC flag updated once component is initialized', async () => {
            // Arrange
            const mainInitialState = {
                order: {
                    policy: {
                        isITAC: null
                    }
                }
            };
            const mockStoreActions = () => {
                useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([]));
            };
            const { wrapper } = getMountedComponent(mainInitialState, {}, mockStoreActions);

            // Act
            wrapper.vm.initializeComponent();

            // Assert
            expect(wrapper.vm.mainStore.updatePolicyITACFlag)
                .toHaveBeenCalledTimes(1);
        });

        it('Loaded duplicate with previously registered claim  => claim registration is not called', async () => {
            // Arrange
            const sellingPrice = getRandomInt(50, 100);
            const deductible = sellingPrice - 1;
            const initialStore = {
                order: {
                    policy: {
                        policyLookupSuccessful: true,
                        noCoverage: false,
                        deductible: {
                            repair: deductible
                        }
                    },
                    damage: {
                        isRepair: false
                    },
                    payment: {
                        insuranceCoverage: {
                            claimNumber: getRandomString(10, 10)
                        }
                    }
                },
                issConfig: {
                    isClaimRegistrationRequired: true
                }
            };
            const mockStoreActions = () => {
                useMainStore().getWipers = jest.fn().mockImplementation(() => Promise.resolve());
                useMainStore().getRainDefense = jest.fn().mockImplementation(() => Promise.resolve());
                useMainStore().getSupportingItems = jest.fn().mockImplementation(() => Promise.resolve());
                useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([
                    {
                        sellingPrice,
                        kitPrice: 0,
                        laborAmount: 0
                    }
                ]));
            };
            const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
            const next = (method) => { method(wrapper.vm); };

            // Act
            coverageStatement.beforeRouteEnter.call(wrapper.vm, undefined, undefined, next);
            for (let i = 0; i < 7; i++) {
                // eslint-disable-next-line no-await-in-loop
                await nextTick();
            }

            // Assert
            expect(wrapper.vm.mainStore.registerClaim).toHaveBeenCalledTimes(0);
        });
    });
});