// Components
import addressLookup from "@/layouts/address-lookup/address-lookup.vue";

// Supporting Files
import { settleAllPromises } from "@/helpers/layout-helper.js";
import { shallowMount } from "@vue/test-utils";
import { getMountOptions } from "@/helpers/unit-test-helper.js";
import { storeActions } from "@/constants/store-actions";
import { storeMutations } from "@/constants/store-mutations";
import { navigationScenarios } from "@/router/router-constants/navigation-scenarios";
import store from "@/store";
import { navigateToHeritageFunnel } from "@/helpers/heritage-integration/navigation-helper";


jest.mock("@/helpers/damage-helper", () => ({
  isGlassAvailableForCarId: jest.fn().mockImplementation(() => true),
  getDamageString: jest.fn()
}));

jest.mock("@/helpers/heritage-integration/navigation-helper", () => ({
  navigateToHeritageFunnel: jest.fn()
}));

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

describe("address-lookup.vue", () => {
  describe("page level alerts", () => {
    test("if the address is not serviceable display the Non-Serviceable Zip Alert", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: false
      });

      store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

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

      // Assert
      expect(wrapper.findComponent({ ref: "alertNonServiceableZip" }).isVisible()).toBe(true);
    });

    test("if the address matches a different vehicle display the Matched Different VehicleAlert", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: true,
        vinVehicles: [
          {
            vehicle: {
              carId: "C00000"
            }
          }
        ]
      });

      store.commit(storeMutations.UPDATE_CAR_ID, "CARID2");

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

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

      // Assert
      expect(wrapper.findComponent({ ref: "alertMatchedDifferentVehicle" }).isVisible()).toBe(true);
    });

    test("if the looking up VIN by address is not allowed in the state selected display the Vin Lookup By HomeAddress Not Allowed Alert", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: true,
        isStatePermissible: false,
        lookupVinbyAddressResponse: {
          isStatePermissible: false,
          vinVehicles: [{
            vin: "TEST_VIN",
            vehicle: {
              carId: "CARID"
            }
          },
          {
            vin: "TEST_VIN2",
            vehicle: {
              carId: "CARID2"
            }
          }]
        }
      });

      store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

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

      // Assert
      expect(wrapper.findComponent({ ref: "alertVinLookupsByHomeAddressNotAllowed" }).isVisible()).toBe(true);

    });

    test("if no vehicles found, display Vin Not Found alert", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: true,
        lookupVinbyAddressResponse: {
          isStatePermissible: true,
          vinVehicles: [] // Return no vehicles
        }
      });

      store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

      wrapper.vm.navigateForward = jest.fn();

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

      // Assert
      expect(wrapper.findComponent({ ref: "alertVinNotFound" }).isVisible()).toBe(true);

    });
  });

  describe("navigation", () => {

    test("if the back button is clicked, navigate back", async () => {
      // Arrange 
      const { wrapper } = setupMocks({
        isZipServiceable: true
      });

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

      // Assert
      expect(wrapper.vm.$router.navigate).toHaveBeenCalled();

    });

    test("if the car entered matches one of the vehicles found and the zip is serviceable, navigate forward", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: true,
        vinVehicles: [
          {
            vehicle: {
              carId: "C11111"
            }
          }
        ]
      });

      await wrapper.setData({
        previouslyEnteredCarId: "C11111",
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

      wrapper.vm.navigateForward = jest.fn();

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

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

    test("if the car entered does not match any of the multiple vehicles found, navigate to address-vehicles page", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: true,
        isStatePermissible: true,
        vinVehicles: [{
          vin: "TEST_VIN",
          vehicle: {
            carId: "CARID"
          }
        },
        {
          vin: "TEST_VIN2",
          vehicle: {
            carId: "CARID2"
          }
        }]
      });

      store.commit(storeMutations.UPDATE_CAR_ID, "CARID_A");

      const carsFound = [{
        vin: "TEST_VIN",
        vehicle: {
          carId: "CARID"
        }
      },
      {
        vin: "TEST_VIN2",
        vehicle: {
          carId: "CARID2"
        }
      }]

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

      wrapper.vm.updateVehicleInfo = jest.fn();

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

      // Assert 
      expect(wrapper.vm.$router.navigate).toHaveBeenCalledWith(navigationScenarios.CONTINUING_WITH_MULTIPLE_VEHICLES, undefined, {}, {}, carsFound);
    });

    test("if the car entered matches one of the vehicles found but the zip is NOT serviceable, do not navigate forward", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: false,
        isStatePermissible: true,
        vinVehicles: [{
          vin: "TEST_VIN",
          vehicle: {
            carId: "CARID"
          }
        },
        {
          vin: "TEST_VIN2",
          vehicle: {
            carId: "CARID2"
          }
        }]  
      });

      store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
      })

      wrapper.vm.navigateForward = jest.fn();

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

      // Assert 
      expect(wrapper.vm.navigateForward).toHaveBeenCalledTimes(0);

    });

    test("if a different vehicle is found than the one entered and the selected glass is not available for that vehicle, navigate back to vehicle-damage page", async () => {
      // Arrange
      const mockRegistrationAddress = {
        streetAddress: "1234 Main St",
        city: "Columbus",
        state: "OH",
        zipCode: "43215"
      }

      const { wrapper } = setupMocks({
        isZipServiceable: true, 
        isStatePermissible: true
      });

      await wrapper.setData({
        customerQuestions: {
          addressQuestions: mockRegistrationAddress
        },
        isCarIdDifferent: true,
        isGlassAvailableForCarId: false,
      })


      let carsFound = [{
        vin: "TEST_VIN2",
        vehicle: {
          carId: "C0000"
        }
      }];

      // Act
      await wrapper.vm.navigateForward(carsFound);

      // Assert 
      expect(wrapper.vm.$router.navigate).toHaveBeenCalledWith(navigationScenarios.SELECTED_VIN_HAS_MISMATCHED_GLASS, undefined, {}, { "displayVehicleChangeAlert": true });

    });

    test("single car was found and matches entered vehicle => navigateForwardWithSingleCarMatch", async () => {
      // Arrange

      const carsFound = [
        {
          vin: "TEST_VIN_2",
          vehicle: {
            carId: "C0000"
          }
        }
      ];

      const { wrapper } = setupMocks({}, {});
      wrapper.vm.navigateForwardWithSingleCarMatch = jest.fn();

      // Act
      wrapper.vm.navigateForward(carsFound);

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

    test("multiple cars were found and one matches entered vehicle => navigateForwardWithSingleCarMatch", async () => {
      // Arrange
      const carsFound = [
        {
          vin: "TEST_VIN_1",
          vehicle: {
            carId: "C0000"
          }
        },
        {
          vin: "TEST_VIN_2",
          vehicle: {
            carId: "CARID2"
          }
        },
        {
          vin: "TEST_VIN_3",
          vehicle: {
            carId: "CARID3"
          }
        }
      ];

      const { wrapper } = setupMocks({});
      wrapper.vm.navigateForwardWithSingleCarMatch = jest.fn();

      // Act
      wrapper.vm.navigateForward(carsFound);

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

  describe("registration and service zips", () => {
    describe("if registration zip is serviceable", () => {
      test("if registration address is provided => update service address on successful continue", async () => {
        // Arrange
        const mockRegistrationAddress = {
          streetAddress: "1234 Main St",
          city: "Columbus",
          state: "OH",
          zipCode: "43215"
        }

        const { wrapper } = setupMocks({
          isZipServiceable: true
        });

        store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

        await wrapper.setData({
          customerQuestions: {
            addressQuestions: mockRegistrationAddress
          }
        })

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

        // Assert 
        expect(wrapper.vm.dispatchStoreAction).toHaveBeenCalledWith("lookupVinByAddress", {"licenseLastName": undefined, "licenseState": "OH", "licenseStreetAddress": "1234 Main St", "licenseZip": "43215"}, false);

        expect(wrapper.vm.dispatchStoreAction).toHaveBeenCalledWith("validateZip", {"zip": "43215"});
      });
    });

    describe("if registration zip is not serviceable", () => {
      test("if registration address is provided and user clicks continue => show non-serviceable zip alert", async () => {
        // Arrange
        const mockRegistrationAddress = {
          streetAddress: "1234 Main St",
          city: "Columbus",
          state: "OH",
          zipCode: "43215"
        }

        const { wrapper } = setupMocks({
          isZipServiceable: false
        });

        store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

        await wrapper.setData({
          customerQuestions: {
            addressQuestions: mockRegistrationAddress
          }
        })

        expect(wrapper.findComponent({ ref: "alertNonServiceableZip" }).exists()).toBe(false);

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

        // Assert 
        expect(wrapper.vm.displayNonServiceableZipAlert).toBe(true);
        expect(wrapper.findComponent({ ref: "alertNonServiceableZip" }).exists()).toBe(true);
        expect(wrapper.findComponent({ ref: "alertNonServiceableZip" }).isVisible()).toBe(true);
      });

      // test.only("if registration address is provided user clicks continue => show service zip field on continue click", async () => {
      //   // Arrange
      //   const mockRegistrationAddress = {
      //     streetAddress: "1234 Main St",
      //     city: "Columbus",
      //     state: "OH",
      //     zipCode: "43215"
      //   }

      //   const { wrapper } = setupMocks({
      //     isZipServiceable: false
      //   }
      //   );

      //   expect(wrapper.vm.showServiceZipField).toBeFalsy();
      //   expect(wrapper.findComponent({ ref: "serviceZip" }).exists()).toBe(false);
      //   store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

      //   await wrapper.setData({
      //     customerQuestions: {
      //       addressQuestions: mockRegistrationAddress
      //     }
      //   })

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

      //   // Assert 
      //   expect(wrapper.vm.showServiceZipField).toBe(true);
      //   expect(wrapper.findComponent({ ref: "serviceZip" }).isVisible()).toBe(true);
      // });

      test("if registration address, service zip are provided, and user clicks continue => don't update service address", async () => {
        // Arrange
        const mockRegistrationAddress = {
          streetAddress: "1234 Main St",
          city: "Columbus",
          state: "OH",
          zipCode: "43215"
        }

        const { wrapper } = setupMocks({
          isZipServiceable: false
        }
        );

        store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

        await wrapper.setData({
          customerQuestions: {
            addressQuestions: mockRegistrationAddress
          }
        })

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

        // Assert 
        expect(wrapper.vm.dispatchStoreAction).not.toHaveBeenCalledWith(storeActions.UPDATE_SERVICE_LOCATION_WITH_VEHICLE_REGISTRATION);
      });

      test("if registration address, service zip are provided, and user clicks continue => both zips are saved and are different", async () => {
        // Arrange
        const mockRegistrationAddress = {
          streetAddress: "1234 Main St",
          city: "Columbus",
          state: "OH",
          zipCode: "43215"
        }

        const { wrapper } = setupMocks({});
        wrapper.vm.navigateForwardWithSingleCarMatch = jest.fn();

        store.commit(storeMutations.UPDATE_CAR_ID, "CARID");

        wrapper.vm.dispatchStoreAction = jest.fn();
        wrapper.vm.dispatchStoreAction.mockImplementation((actionName, value) => {
          let data = {};
          if (actionName == storeActions.VALIDATE_ZIP) {
            if (value == "43215") {
              data = {
                isServiceable: false
              };
            }
            else {
              data = {
                isServiceable: true
              }
            }
          }
          else if (actionName == storeActions.LOOKUP_VIN_BY_ADDRESS) {
            data = {
              isStatePermissible: true,
              vinVehicles: [{
                vin: "TEST_VIN",
                vehicle: {
                  carId: "CARID"
                }
              }]
            }
          }

          return Promise.resolve({ data });
        })

        await wrapper.setData({
          customerQuestions: {
            addressQuestions: mockRegistrationAddress
          }
        })

        await wrapper.vm.forwardButtonAction();
        await wrapper.setData({
          serviceZipCode: "12345"
        })

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

        // // Assert 
        expect(wrapper.vm.$store.getters.order.serviceLocation.zipCode).not.toEqual(wrapper.vm.$store.getters.vehicle.registration.zipCode);
        expect(wrapper.vm.$store.getters.vehicle.registration.zipCode).toEqual("12345");
        expect(wrapper.vm.$store.getters.order.serviceLocation.zipCode).toEqual("11111");
      });
    });
  });
});

function setupMocks({ isZipServiceable = true, lookupVinbyAddressResponse, partsOrQuestions = [], isStatePermissible = true, vinVehicles =[], carId = 'C0000'}) {
  store.commit(storeMutations.RESET_STATE);
  const wrapper = shallowMount(addressLookup, getMountOptions({
    actionList: [
      {
        actionName: storeActions.VALIDATE_ZIP,
        data: {
          isServiceable: isZipServiceable
        }
      },
      {
        actionName: storeActions.LOOKUP_VIN_BY_ADDRESS,
        data: lookupVinbyAddressResponse ? lookupVinbyAddressResponse : {
          isStatePermissible: true,
          vinVehicles: [{
            vin: "TEST_VIN",
            vehicle: {
              carId: "CARID"
            }
          }]
        }
      },
      {
        actionName: storeActions.GET_PARTS_OR_QUESTIONS,
        data: {
          partsOrQuestions: partsOrQuestions
        }
      },
    ],
    router: {
      navigate: jest.fn(),
      navigate: jest.fn()
    },
    store: {
      getters: {
        vehicle: {
          carId: carId,
          registration: {
            licensePlate: "TESTPLATE",
            zipCode: "12345"
          }
        },
        order: {
          customer: {
            emailAddress: "test@test.com"
          },
          serviceLocation: {
            zipCode: "11111"
          }
        }
      }
    },
  }));

  const apiResponses = {
    serviceZipValidationResponse:{
      isServiceable: isZipServiceable
    },
    vinLookupResponse: {
      isStatePermissible: isStatePermissible,
      vinVehicles: vinVehicles
    },
  };

  settleAllPromises.mockImplementation(() => apiResponses);

  wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => "");
  wrapper.vm.setCmsContent = jest.fn();
  wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
  wrapper.vm.$refs.funnelFooter.removeLoader = jest.fn();
  wrapper.vm.$refs.loadingModal.showModal = jest.fn();

  return { wrapper };
}