// Components
import moldingQuestions from '@/layouts/molding-questions/molding-questions.vue';

// Supporting Files
import { shallowMount } from '@vue/test-utils';
import { getMountOptions } from '@/helpers/unit-test-helper.js';
import { useMainStore } from '@/store';
import vehicleQuestionsMixin from '@/mixins/vehicle-questions-mixin';
import { nextTick } from 'vue';
import baseMixin from '@/mixins/base-mixin';

// Mock our module for promises.
jest.mock('@/helpers/layout-helper.js', () => ({
    settleAllPromises: jest.fn()
}));

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

function setupMocks({
    mountOptionsMockData = {
        router: {
            navigate: jest.fn()
        },
        actionList: [
            {
                actionName: 'saveMoldingQuestionAnswers',
                data: {}
            },
            {
                actionName: 'getPartsOrQuestions',
                data: {}
            }
        ],
        route: {
            query: {
                issPage: 'molding-questions'
            }
        },
        data() {
            return {
                computedSwitcher: [
                    {
                        glassLocation: 'Windshield',
                        glassName: 'Single',
                        answerData: {
                            answerResult: 'FW04848',
                            answeredQuestions: []
                        }
                    }
                ]
            };
        },
        questionsData: {
            get() {
                return this.computedSwitcher;
            },
            set(val) {
                this.computedSwitcher = val;
            }
        }
    }
}) {
    useMainStore().getPartsOrQuestions = jest.fn(() => ({
        data: {
            partsOrQuestions: []
        }
    }));

    const mountOptions = getMountOptions({
        ...mountOptionsMockData,
        mixins: [baseMixin, vehicleQuestionsMixin]
    });
    mountOptions.attachTo = document.body;

    const wrapper = shallowMount(moldingQuestions, mountOptions);

    return { wrapper };
}

const baseStoreGettersPageData = () => ({
    partsOrQuestions: [
        {
            parts: [
                {
                    childPartQuestions: [
                        {
                            questionSequence: 1,
                            questionText:
                                    'Does the rubber seal around your windshield have a chrome strip running through it?',
                            answers: [
                                {
                                    answerResult: 'WKT D1106 C',
                                    answerText: 'Yes',
                                    nextQuestionSequence: null
                                },
                                {
                                    answerResult: 'WKT D1106 B',
                                    answerText: 'No',
                                    nextQuestionSequence: null
                                }
                            ]
                        }
                    ],
                    basePartNumber: 'DW01105',
                    color: 'Green Tint, Blue Shade',
                    requiresRecalibration: false,
                    recalibrationType: '',
                    canSafeliteRecalibrate: false,
                    requiresCapabilityQuestions: false,
                    childParts: null,
                    partNumber: 'DW01105GBNN',
                    description: 'solar',
                    partType: 'WINDSHIELD'
                }
            ],
            partQuestions: [],
            glassLocation: 'Windshield',
            glassName: 'Single',
            answerKey: 'Windshield-Single',
            answerData: null
        }
    ]
});
const baseStoreGettersDamage = () => ({
    partsQuestionAnswers: [
        {
            glassLocation: 'Windshield',
            glassName: 'Single',
            result: 'FW04848',
            answeredQuestions: [
                {
                    questionText:
                            // eslint-disable-next-line max-len
                            'Is your vehicle equipped with the Panoramic Sunroof which can be identified by having a glass panel over the rear seats?',
                    selectedAnswer: '1|nextQuestion|3|Yes',
                    selectedAnswerText: 'Yes',
                    questionNum: 1
                },
                {
                    questionText:
                            // eslint-disable-next-line max-len
                            'Is your vehicle equipped with a heated windshield that melts snow and ice from underneath the windshield wiper blades?',
                    selectedAnswer: '2|nextQuestion|3|Yes',
                    selectedAnswerText: 'Yes',
                    questionNum: 2
                }
            ]
        }
    ]
});

useMainStore().pageData = baseStoreGettersPageData;
useMainStore().damage = baseStoreGettersDamage;

describe('moldingQuestions.vue', () => {
    describe('method arePagePrerequisitesValid...', () => {
        test('Should return true for valid page requisites if pageData exists', () => {
            // Arrange
            const { wrapper } = setupMocks({});

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

            // Assert
            expect(result).toBe(true);

            wrapper.unmount();
        });

        test('Should return false for valid page requisites if partsOrQuestions in pageData is missing', () => {
            // Arrange
            const { wrapper } = setupMocks({});
            useMainStore().pageData = jest.fn(() => undefined);

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

            // Assert
            expect(result).toBeFalsy();

            wrapper.unmount();
        });

        test('Should be at least one item in partsOrQuestions', () => {
            // Arrange
            useMainStore().pageData = jest.fn(() => ({
                partsOrQuestions: []
            }));
            useMainStore().damage = baseStoreGettersDamage;

            const { wrapper } = setupMocks({});

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

            // Assert
            expect(result).toBeFalsy();

            wrapper.unmount();
        });
    });

    describe('watch on selectedAnswers should be set up...', () => {
        test('Should trigger handleAnswerUpdates if watched data changes', async () => {
            // Arrange
            useMainStore().pageData = baseStoreGettersPageData;
            useMainStore().damage = baseStoreGettersDamage;

            const { wrapper } = setupMocks({});
            const spy = jest.spyOn(wrapper.vm, 'handleAnswerUpdates');

            // Act
            wrapper.setData({
                selectedAnswers: {
                    'Windshield-Single': {
                        answerResult: 'FW04848',
                        answeredQuestions: [
                            {
                                questionText:
                                    // eslint-disable-next-line max-len
                                    'Is your vehicle equipped with the Panoramic Sunroof which can be identified by having a glass panel over the rear seats?',
                                selectedAnswer: '1|nextQuestion|3|Yes',
                                selectedAnswerText: 'Yes',
                                questionNum: 1
                            },
                            {
                                questionText:
                                    // eslint-disable-next-line max-len
                                    'Is your vehicle equipped with a heated windshield that melts snow and ice from underneath the windshield wiper blades?',
                                selectedAnswer: '2|nextQuestion|3|Yes',
                                selectedAnswerText: 'Yes',
                                questionNum: 2
                            }
                        ],
                        index: 0
                    }
                }
            });

            await nextTick();

            // Assert
            expect(spy).toHaveBeenCalled();

            wrapper.unmount();
        });
    });

    describe('forwardButtonAction', () => {
        test('Should clear out answerData', () => {
            // Arrange
            const { wrapper } = setupMocks({});

            wrapper.vm.questionsData = [
                {
                    glassLocation: 'Windshield',
                    glassName: 'Single',
                    answerData: {
                        answerResult: 'FW04848',
                        answeredQuestions: []
                    }
                }
            ];
            wrapper.vm.dispatchStoreAction = jest.fn(() => ({
                data: {
                    partsOrQuestions: []
                }
            }));

            // Act
            wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.questionsData[0].answerData).toEqual({});

            wrapper.unmount();
        });

        // TODO: Add () to toHaveBeenCalled and ensure that test passes.
        test.skip('Should save to pinia store', async () => {
            // Arrange
            const { wrapper } = setupMocks({});

            wrapper.vm.questionsData = [
                {
                    glassLocation: 'Windshield',
                    glassName: 'Single',
                    answerData: {
                        answerResult: 'FW04848',
                        answeredQuestions: []
                    }
                }
            ];
            useMainStore().getPartsOrQuestions = jest.fn(() => ({
                data: {
                    partsOrQuestions: []
                }
            }));

            // Act
            wrapper.vm.forwardButtonAction();

            await nextTick();

            // Assert
            expect(wrapper.vm.saveMoldingQuestionAnswers).toHaveBeenCalled;
            wrapper.unmount();
        });

        // TODO: Add () to toHaveBeenCalled and ensure that test passes.
        test.skip('Should call GET_PARTS_OR_QUESTIONS API', async () => {
            // Arrange
            const { wrapper } = setupMocks({});

            wrapper.vm.questionsData = [
                {
                    glassLocation: 'Windshield',
                    glassName: 'Single',
                    answerData: {
                        answerResult: 'FW04848',
                        answeredQuestions: []
                    }
                }
            ];
            useMainStore().getPartsOrQuestions = jest.fn(() => ({
                data: {
                    partsOrQuestions: []
                }
            }));

            // Act
            wrapper.vm.forwardButtonAction();

            await nextTick();

            // Assert
            expect(wrapper.vm.getPartsOrQuestions).toHaveBeenCalled;

            wrapper.unmount();
        });

        test('Should trigger navigateForward', async () => {
            // Arrange
            const { wrapper } = setupMocks({});

            wrapper.vm.questionsData = [
                {
                    glassLocation: 'Windshield',
                    glassName: 'Single',
                    answerData: {
                        answerResult: 'FW04848',
                        answeredQuestions: []
                    }
                }
            ];
            useMainStore().getPartsOrQuestions = jest.fn(() => ({
                data: {
                    partsOrQuestions: []
                }
            }));
            wrapper.vm.navigateForward = jest.fn();

            // Act
            await wrapper.vm.forwardButtonAction();

            // Assert
            expect(wrapper.vm.navigateForward).toHaveBeenCalled();

            wrapper.unmount();
        });
    });
});
