import { useMainStore } from '@/store';
import { createApp } from 'vue';
import { setActivePinia, createPinia } from "pinia";
import globalMethods from "@/global-methods";
import App from '@/App';
import { getRandomString, getRandomGuid, getRandomInt, getRandomBoolean } from '@/helpers/data-generation';
import { coverageStatuses } from "@/constants/coverage-statuses.js";

describe("Store", () => {

    let store;

    const vueApp = createApp(App);
    
    beforeEach(() => {
        const pinia = createPinia();
        setActivePinia(pinia);
        vueApp.use(pinia);
        store = useMainStore();
        store.applicationUser.eventBus = [];
        jest.resetAllMocks();
    });
    
        
    it("Should Store Vehicle Year", () => {
        let testYear = "2001";
        store.updateVehicleYear(testYear);
        expect(store.order.vehicle.year).toEqual(testYear);
    });

    it("Should add events to the bus", () => {
        // Arrange
        const category = getRandomString(1, 25);
        const subCategory = getRandomString(5, 20);
        const isDismissible = getRandomBoolean();
        const copy = getRandomString(5, 25);
        const headline = getRandomString(5, 25);
        const type = getRandomString(5, 15);
        let event = {
            category: category,
            subCategory: subCategory,
            eventValue: {
                isDismissible: isDismissible,
                messageCopy: copy,
                messageHeadline: headline,
                type: type,
            },
        };

        // Act
        store.addEventToBus(event);

        // Assert
        expect(store.applicationUser.eventBus[0]).toEqual(event);
    });

    it("Should remove events from the bus", () => {
        // Arrange
        const category = getRandomString(1, 25);
        const subCategory = getRandomString(5, 20);
        const isDismissible = getRandomBoolean();
        const copy = getRandomString(5, 25);
        const headline = getRandomString(5, 25);
        const type = getRandomString(5, 15);
        let event = {
            category: category,
            subCategory: subCategory,
            eventValue: {
                isDismissible: isDismissible,
                messageCopy: copy,
                messageHeadline: headline,
                type: type,
            },
        };

        store.addEventToBus(event);

        expect(store.applicationUser.eventBus.length).toBe(1);

        // Act
        store.removeEventFromBus({ category: event.category, subCategory: event.subCategory })

        // Assert
        expect(store.applicationUser.eventBus.length).toBe(0);
    });

    it("Should return correct event using the getter function eventBusItem", () => {
        // Arrange
        const category = getRandomString(1, 25);
        const subCategory = getRandomString(5, 20);
        const isDismissible = getRandomBoolean();
        const copy = getRandomString(5, 25);
        const headline = getRandomString(5, 25);
        const type = getRandomString(5, 15);
        let event = {
            category: category,
            subCategory: subCategory,
            eventValue: {
                isDismissible: isDismissible,
                messageCopy: copy,
                messageHeadline: headline,
                type: type,
            },
        };

        store.addEventToBus(event);

        // Act
        const actual = store.eventBusItem(event.category, event.subCategory)

        // Assert
        expect(actual).toEqual(event.eventValue);
    });

    it("UpdateVehicle should merge vehicle with response object", () => {
        // Arrange
        const carId = getRandomString(10,14);
        const category = getRandomString(3,7);
        const year = getRandomInt(1960, 2023);
        const make = getRandomString(4,10);
        const model = getRandomString(4,10);
        const style = getRandomString(4,15);
        const imageUrl = getRandomString(50,100);
        const imageVifNumber = getRandomInt(10000,99999).toString();
        const imageColor = getRandomString(4,10);
        const providedVehicle = {
            carId: carId,
            category: category,
            year: year,
            make: make,
            model: model,
            style: style,
            imageUrl: imageUrl,
            imageVifNumber: imageVifNumber,
            imageVifColor: imageColor
        };

        const expectedVehicle = {
            carId: carId,
            category: category,
            year: year,
            make: make,
            model: model,
            style: style,
            imageUrl: imageUrl,
            imageVifNumber: imageVifNumber,
            imageColor: imageColor
        }

        // Act
        store.updateVehicle(providedVehicle);

        // Assert
        expect(store.order.vehicle).toMatchObject(expectedVehicle);
    });

    it("UpdateVehicle should set policy values appropriately with repair waived", () => {
        // Arrange
        const noCompensation = getRandomBoolean();
        const deductible = getRandomInt(1,500);
        const vehicle = {
            noCoverage: noCompensation,
            deductible: deductible,
            repairWaived: true
        };

        const expectedPolicy = {
            noCompensation: noCompensation,
            deductible: {
                replace: deductible,
                repair: 0
            }
        };

        // Act
        store.updateVehicle(vehicle);

        // Assert
        expect(store.order.policy).toMatchObject(expectedPolicy);
    });

    it("UpdateVehicle should set policy values appropriately with repair not waived", () => {
        // Arrange
        const noCompensation = getRandomBoolean();
        const deductible = getRandomInt(1,500);
        const vehicle = {
            noCoverage: noCompensation,
            deductible: deductible,
            repairWaived: false
        };

        const expectedPolicy = {
            noCompensation: noCompensation,
            deductible: {
                replace: deductible,
                repair: deductible
            }
        };

        // Act
        store.updateVehicle(vehicle);

        // Assert
        expect(store.order.policy).toMatchObject(expectedPolicy);
    });

    // TODO update test to work also checking store values
    it("setVehicle should call globalMethods.callHttpClient", () => {
        // Arrange
        const carId = getRandomString(10,14);
        const category = getRandomString(3,7);
        const year = getRandomInt(1960, 2023);
        const make = getRandomString(4,10);
        const model = getRandomString(4,10);
        const style = getRandomString(4,15);
        const imageUrl = getRandomString(50,100);
        const imageVifNumber = getRandomInt(10000,99999).toString();
        const imageColor = getRandomString(4,10);
        const response = {
            data: {
                carId: carId,
                category: category,
                year: year,
                make: make,
                model: model,
                style: style,
                imageUrl: imageUrl,
                imageVifNumber: imageVifNumber,
                imageVifColor: imageColor
            }
        };

        globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));

        // Act
        const returned = store.setVehicle();

        // Assert
        expect(globalMethods.callHttpClient).toHaveBeenCalled();
        expect(returned).resolves.toMatchObject(response);
    });

    it("saveVehicleDamage with windshield repair should update damage with number of chips not null", () => {
        // Arrange
        const glassName = getRandomString(4,10);
        const glassLocation = getRandomString(5,15);
        const isWindshieldRepair = true;
        const selectedGlassToReplace = [{
            glassName: glassName,
            glassLocation: glassLocation
        }];
        const chipCount = getRandomInt(0,3);

        // Act
        store.saveVehicleDamage(isWindshieldRepair, selectedGlassToReplace, chipCount);

        // Assert
        expect(store.order.damage.glassToReplace).toEqual(selectedGlassToReplace);
        expect(store.order.damage.isRepair).toEqual(isWindshieldRepair);
        expect(store.order.damage.numberOfChips).toEqual(chipCount);
    });

    it("saveVehicleDamage without windshield repair should update damage with number of chips null", () => {
        // Arrange
        const glassName = getRandomString(4,10);
        const glassLocation = getRandomString(5,15);
        const isWindshieldRepair = false;
        const selectedGlassToReplace = [{
            glassName: glassName,
            glassLocation: glassLocation
        }];
        const chipCount = getRandomInt(0,3);

        const expectedChipCount = null;

        // Act
        store.saveVehicleDamage(isWindshieldRepair, selectedGlassToReplace, chipCount);

        // Assert
        expect(store.order.damage.glassToReplace).toEqual(selectedGlassToReplace);
        expect(store.order.damage.isRepair).toEqual(isWindshieldRepair);
        expect(store.order.damage.numberOfChips).toEqual(expectedChipCount);
    });

    it("should return registration data if available", () => {
        //Arrange
        const streetAddress = getRandomString(5,15);
        const city = getRandomString(5,15);
        const state = getRandomString(5,10);
        const zipCode = getRandomInt(10000,99999).toString();
        const firstName = getRandomString(5,20);
        const lastName = getRandomString(5,20);
        const expected = {
            addressQuestions: {
                streetAddress: streetAddress,
                city: city,
                state: state,
                zipCode: zipCode,
            },
            firstName: firstName,
            lastName: lastName,
        }

        store.order.vehicle.registration = {
            licensePlate: null,
            address: streetAddress,
            city: city,
            state: state,
            zipCode: zipCode,
            firstName: firstName,
            lastName: lastName,
        };

        //Act
        const actual = store.customerData;

        //Assert
        expect(actual).toEqual(expected);
    });

    it("should return customer data if registration data unavailable", () => {
        //Arrange
        const address = getRandomString(1,25);
        const city = getRandomString(5,20);
        const state = getRandomString(4,20);
        const zipCode = getRandomInt(10000, 99999).toString();
        const firstName = getRandomString(5,25);
        const lastName = getRandomString(5,25);
        const expected = {
            addressQuestions: {
                streetAddress: address,
                city: city,
                state: state,
                zipCode: zipCode,
            },
            firstName: firstName,
            lastName: lastName,
        }

        store.order.vehicle.registration.address = null;

        store.order.customer = {
            address: {
                streetAddress: address,
                city: city,
                state: state,
                zipCode: zipCode
            },
            firstName: firstName,
            lastName: lastName
        };

        //Act
        const actual = store.customerData;

        //Assert
        expect(actual).toMatchObject(expected);
    });

    describe("registerClaim method", () => {
        it("successful response with no coverage => isVerified true and coverage status no comp", async () => {
            // Arrange
            const response = {
                data: {
                    claimantId: null,
                    claimNumber: getRandomString(9, 9),
                    correlationId: getRandomGuid(),
                    isSuccess: true,
                    isError: false,
                    successMessage: getRandomString(9, 9),
                    deductible: 0
                }
            };
            store.policy.noCompensation = true;

            globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));

            // Act
            await store.registerClaim();

            // Asserts
            expect(globalMethods.callHttpClient).toHaveBeenCalled();
            expect(store.payment.insuranceCoverage.isVerified).toBe(true);
            expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.NO_COMP);
        });

        it("successful response with coverage => isVerified true and coverage status verified", async () => {
            // Arrange
            const response = {
                data: {
                    claimantId: null,
                    claimNumber: getRandomString(9, 9),
                    correlationId: getRandomGuid(),
                    isSuccess: true,
                    isError: false,
                    successMessage: getRandomString(9, 9),
                    deductible: 0
                }
            };
            store.policy.noCompensation = false;

            globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));

            // Act
            await store.registerClaim();

            // Asserts
            expect(globalMethods.callHttpClient).toHaveBeenCalled();
            expect(store.payment.insuranceCoverage.isVerified).toBe(true);
            expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED);
        })

        it("Call to client returns exception, resulting in object with error property being returned", async () => {
            // Arrange
            globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject());

            // Act
            await store.registerClaim();

            // Asserts
            expect(globalMethods.callHttpClient).toHaveBeenCalled();
            expect(store.payment.insuranceCoverage.isVerified).toBe(false);
            expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.PENDING);
        });
    });

    describe('updateContactInfo method', () => {
        it('UpdateContactInfo updates contact info in store', () => {
            // Arrange
            const firstName = getRandomString(4, 10);
            const lastName = getRandomString(5, 15);
            const emailAddress = false;
            const phoneNumber = getRandomInt(1000000000, 9999999999);
            const requestTextUpdates = getRandomBoolean();
            const notesForTechnician = getRandomString(50, 150);

            // Act
            store.updateContactInfo({ firstName,
                lastName,
                emailAddress,
                phoneNumber,
                requestTextUpdates,
                notesForTechnician });

            // Assert
            expect(store.contactInfo.firstName).toEqual(firstName);
            expect(store.contactInfo.lastName).toEqual(lastName);
            expect(store.contactInfo.emailAddress).toEqual(emailAddress);
            expect(store.contactInfo.phoneNumber).toEqual(phoneNumber);
            expect(store.contactInfo.requestTextUpdates).toEqual(requestTextUpdates);
            expect(store.contactInfo.notesForTechnician).toEqual(notesForTechnician);
        });
        it('All null values => contact info set in store to all nulls', () => {
            // Act
            store.updateContactInfo({});

            // Assert
            expect(store.contactInfo.firstName).toEqual('');
            expect(store.contactInfo.lastName).toEqual('');
            expect(store.contactInfo.emailAddress).toEqual('');
            expect(store.contactInfo.phoneNumber).toEqual('');
            expect(store.contactInfo.requestTextUpdates).toEqual(false);
            expect(store.contactInfo.notesForTechnician).toEqual('');
        });
    });
});