import { createStore, Store } from "vuex";
import { endpoints } from "@/constants/endpoints.js";
import { storeMutations } from "@/constants/store-mutations";
import { getDateForSavedSessionTimeout } from "@/helpers/heritage-integration/session-helper";
import createPersistedState from "vuex-persistedstate";
import globalMethods from "@/global-methods";
import { storeActions } from "@/constants/store-actions";
import { applicationConfig } from "@/constants/application-config";
import { experimentTriggers } from "@/constants/experiments";
import { damageLocationsSelected } from "@/constants/damage-locations-selected";
import { fmgPageValues } from "@/router/router-constants/fmgPage-values";

// Export State
const getDefaultState = () => {
  return {
    order: {
      vehicle: {
        year: null,
        make: null,
        model: null,
        style: null,
        carId: null,
        category: null,
        vin: null,
        imageUrl: null,
        imageVifNumber: null,
        imageColor: null,
        registration: {
          licensePlate: null,
          address: null,
          city: null,
          state: null,
          zipCode: null,
          firstName: null,
          lastName: null,
        },
      },
      serviceLocation: {
        address: null,
        city: null,
        state: null,
        zipCode: null,
      },
      customer: {
        emailAddress: null,
      },
      damage: {
        isRepair: null,
        numberOfChips: null,
        glassToReplace: null,
        partQuestionAnswers: null,
        moldingQuestionAnswers: null,
        capabilityQuestionAnswers: null,
      },
      lineItems: {
        glassParts: null,
      },
      payment: {
        isInsurance: null,
        insuranceCoverage: {
          isVerified: null,
        },
      },
      referralNumber: null,
      referralDate: null,
      referralCorrelationId: null,
      accountNumber: 0,
      eon: null,
    },
    applicationUser: {
      eventBus: [],
      pageData: {},
      savedSessionTimeout: getDateForSavedSessionTimeout(),
      saveSessionPromise: null,
      savedSessionId: null,
      crmCustomerId: null,
      lastPageVisited: null,
      experiments: [],
      triggeredSiteEntry: false,
    },
    // gaClickInformation: {
    //   currentlySelectedValues: {},
    //   firedGaClickEventValues: {},
    //   lastFocusedInputGroup: "",
    //   wasLastFocusedInputMultiselect: undefined,
    // },
  };
};

export const state = getDefaultState();

// Export Mutations
export const mutations = {
  // VEHICLE MUTATIONS
  updateYear(state, year) {
    state.order.vehicle.year = year;
  },
  updateMake(state, make) {
    state.order.vehicle.make = make;
  },
  updateModel(state, model) {
    state.order.vehicle.model = model;
  },
  updateStyle(state, style) {
    state.order.vehicle.style = style;
  },
  updateCarId(state, carId) {
    state.order.vehicle.carId = carId;
  },
  updateVehicleCategory(state, category) {
    state.order.vehicle.category = category;
  },
  updateVehicleImageUrl(state, imageUrl) {
    state.order.vehicle.imageUrl = imageUrl;
  },
  updateVehicleImageVifNumber(state, imageVifNumber) {
    state.order.vehicle.imageVifNumber = imageVifNumber;
  },
  updateVehicleImageColor(state, imageColor) {
    state.order.vehicle.imageColor = imageColor;
  },
  updateVehicleVin(state, vin) {
    state.order.vehicle.vin = vin;
  },
  updateIsRepair(state, isRepair) {
    state.order.damage.isRepair = isRepair;
  },
  updateNumberOfChips(state, numberOfChips) {
    state.order.damage.numberOfChips = numberOfChips;
  },
  updateGlassToReplace(state, glassToReplace) {
    state.order.damage.glassToReplace = glassToReplace;
  },
  updatePartQuestionAnswers(state, answersArray) {
    state.order.damage.partQuestionAnswers = answersArray;
  },
  updateMoldingQuestionAnswers(state, answersArray) {
    state.order.damage.moldingQuestionAnswers = answersArray;
  },
  updateCapabilityQuestionAnswers(state, answersArray) {
    state.order.damage.capabilityQuestionAnswers = answersArray;
  },
  updateGlassParts(state, partsData) {
    state.order.lineItems.glassParts = partsData;
  },
  updateOtherParts(state, partsData) {
    state.order.lineItems.otherParts = partsData;
  },
  updatePageData(state, pageData) {
    state.applicationUser.pageData[pageData.page] = pageData.data;
  },
  updateReferralCorrelationId(state, referralCorrelationId) {
    state.order.referralCorrelationId = referralCorrelationId;
  },
  updateReferralNumber(state, referralNumber) {
    state.order.referralNumber = referralNumber;
  },
  updateReferralDate(state, referralDate) {
    state.order.referralDate = referralDate;
  },
  updateParentAcctNumber(state, parentAcctNumber) {
    state.order.accountNumber = parentAcctNumber;
  },
  updateEON(state, eon) {
    state.order.eon = eon;
  },
  updateIsInsurance(state, isInsurance) {
    state.order.payment.isInsurance = isInsurance;
  },
  updateInsuranceVerifiedStatus(state, isVerified) {
    state.order.payment.insuranceCoverage.isVerified = isVerified;
  },
  updateRegistrationLicensePlate(state, licensePlate) {
    state.order.vehicle.registration.licensePlate = licensePlate;
  },
  updateRegistrationAddress(state, registrationAddress) {
    state.order.vehicle.registration.address = registrationAddress;
  },
  updateRegistrationCity(state, registrationCity) {
    state.order.vehicle.registration.city = registrationCity;
  },
  updateRegistrationState(state, registrationState) {
    state.order.vehicle.registration.state = registrationState;
  },
  updateRegistrationZipCode(state, registrationZipCode) {
    state.order.vehicle.registration.zipCode = registrationZipCode;
  },
  updateServiceLocationZipCode(state, serviceLocationZip) {
    state.order.serviceLocation.zipCode = serviceLocationZip;
  },
  updateServiceLocationState(state, serviceLocationState) {
    state.order.serviceLocation.state = serviceLocationState;
  },
  updateRegistrationFirstName(state, firstName) {
    state.order.vehicle.registration.firstName = firstName;
  },
  updateRegistrationLastName(state, lastName) {
    state.order.vehicle.registration.lastName = lastName;
  },
  updateCustomerEmailAddress(state, customerEmailAddress) {
    state.order.customer.emailAddress = customerEmailAddress;
  },
  updateVehicle(state, vehicleInfo) {
    state.order.vehicle.year = vehicleInfo.year;
    state.order.vehicle.make = vehicleInfo.make;
    state.order.vehicle.model = vehicleInfo.model;
    state.order.vehicle.style = vehicleInfo.style;
    state.order.vehicle.carId = vehicleInfo.carId;
    state.order.vehicle.category = vehicleInfo.category;
    state.order.vehicle.vin = vehicleInfo.vin;

    state.order.vehicle.imageUrl = vehicleInfo.imageUrl;
    state.order.vehicle.imageVifNumber = vehicleInfo.imageVifNumber;
    state.order.vehicle.imageColor = vehicleInfo.imageVifColor;
  },
  updateRegistration(state, registrationInfo) {
    state.order.vehicle.registration.licensePlate =
      registrationInfo?.licensePlate;
    state.order.vehicle.registration.address = registrationInfo?.address;
    state.order.vehicle.registration.city = registrationInfo?.city;
    state.order.vehicle.registration.state = registrationInfo?.state;
    state.order.vehicle.registration.zipCode = registrationInfo?.zipCode;
    state.order.vehicle.registration.firstName = registrationInfo?.firstName;
    state.order.vehicle.registration.lastName = registrationInfo?.lastName;
  },
  updateServiceLocation(state, serviceLocationInfo) {
    state.order.serviceLocation.address = serviceLocationInfo.address;
    state.order.serviceLocation.city = serviceLocationInfo.city;
    state.order.serviceLocation.state = serviceLocationInfo.state;
    state.order.serviceLocation.zipCode = serviceLocationInfo.zipCode;
  },

  // applicationUser MUTATIONS
  updateSaveSessionPromise(state, saveSessionPromise) {
    state.applicationUser.saveSessionPromise = saveSessionPromise;
  },
  updateSavedSessionId(state, savedSessionId) {
    state.applicationUser.savedSessionId = savedSessionId;
  },
  updateCrmCustomerId(state, crmCustomerId) {
    state.applicationUser.crmCustomerId = crmCustomerId;
  },
  updateLastPageVisited(state, lastPageVisited) {
    state.applicationUser.lastPageVisited = lastPageVisited;
  },
  // EVENT BUS MUTATIONS
  addEventToBus(state, event) {
    state.applicationUser.eventBus.push(event);
  },
  removeEventFromBus(state, eventData) {
    const matchedEvent = state.applicationUser.eventBus.find(
      ({ category, subCategory }) =>
        category === eventData.category && subCategory === eventData.subCategory
    );
    const itemIndex = state.applicationUser.eventBus.indexOf(matchedEvent);

    // If the item exists, remove it.
    if (itemIndex > -1) {
      state.applicationUser.eventBus.splice(itemIndex, 1);
    }
  },

  // RESET DEPENDENCY MUTATIONS
  resetVehicleState(state) {
    state.order.vehicle.year = null;
    state.order.vehicle.make = null;
    state.order.vehicle.model = null;
    state.order.vehicle.style = null;
    state.order.vehicle.carId = null;
    state.order.vehicle.category = null;
    state.order.vehicle.vin = null;
    state.order.vehicle.imageUrl = null;
    state.order.vehicle.imageVifNumber = null;
    state.order.vehicle.imageColor = null;
  },
  resetDamageState(state) {
    state.order.damage.isRepair = null;
    state.order.damage.numberOfChips = null;
    state.order.damage.glassToReplace = null;
  },
  resetRegistrationState(state) {
    state.order.vehicle.registration.licensePlate = null;
    state.order.vehicle.registration.address = null;
    state.order.vehicle.registration.city = null;
    state.order.vehicle.registration.state = null;
    state.order.vehicle.registration.zipCode = null;
    state.order.vehicle.registration.firstName = null;
    state.order.vehicle.registration.lastName = null;
  },
  resetGlassPartsState(state) {
    state.order.lineItems.glassParts = null;
    state.order.damage.partQuestionAnswers = null;
    state.order.damage.moldingQuestionAnswers = null;
    state.order.damage.capabilityQuestionAnswers = null;
    state.applicationUser.pageData[fmgPageValues.PART_QUESTIONS] = null;
    state.applicationUser.pageData[fmgPageValues.VEHICLE_PARTS] = null;
    state.applicationUser.pageData[fmgPageValues.MOLDING_QUESTIONS] = null;
    state.applicationUser.pageData[fmgPageValues.CAPABILITY_QUESTIONS] = null;
  },
  resetState(state) {
    Object.assign(state, getDefaultState());
  },
  resetSaveSessionPromise(state) {
    state.applicationUser.saveSessionPromise = null;
  },
  // Misc Mutations
  updateStateWithOrderInformation(state, orderInformation) {
    state.order.referralNumber = orderInformation.referralNumber;
    state.order.referralDate = orderInformation.referralDate;
    state.order.referralCorrelationId = orderInformation.referralCorrelationId;
    state.order.eon = orderInformation.eon;

    if (state.order.vehicle.vin !== orderInformation.vehicle?.vin) {
      state.applicationUser.pageData[fmgPageValues.PART_QUESTIONS] = null;
      state.applicationUser.pageData[fmgPageValues.VEHICLE_PARTS] = null;
      state.applicationUser.pageData[fmgPageValues.MOLDING_QUESTIONS] = null;
      state.applicationUser.pageData[fmgPageValues.CAPABILITY_QUESTIONS] = null;
    }

    state.order.vehicle = Object.assign(state.order.vehicle, {
      year: orderInformation.vehicle?.year,
      make: orderInformation.vehicle?.make,
      model: orderInformation.vehicle?.model,
      style: orderInformation.vehicle?.style,
      vin: orderInformation.vehicle?.vin,
      carId: orderInformation.vehicle?.carId,
      category: orderInformation.vehicle?.category,
      imageUrl: orderInformation.vehicle?.imageUrl,
      imageVifNumber: orderInformation.vehicle?.imageVifNumber,
      imageColor: orderInformation.vehicle?.imageVifColor,
      registration: {
        firstName: orderInformation.vehicle.registration.firstName,
        lastName: orderInformation.vehicle.registration.lastName,
        address: orderInformation.vehicle.registration.streetAddress,
        city: orderInformation.vehicle.registration.city,
        state: orderInformation.vehicle.registration.state,
        zipCode: orderInformation.vehicle.registration.zipCode,
        licensePlate: orderInformation.vehicle.registration.licensePlateNumber,
      },
    });

    state.order.damage.glassToReplace = orderInformation.damage.glassToReplace;
    state.order.damage.isRepair = orderInformation.damage.isRepair;
    state.order.damage.numberOfChips = orderInformation.damage.numberOfChips;

    state.order.lineItems.glassParts = orderInformation.parts;
    state.order.accountNumber = orderInformation.accountNumber;
    (state.order.serviceLocation.address =
      orderInformation.serviceLocation.streetAddress),
      (state.order.serviceLocation.city =
        orderInformation.serviceLocation.city),
      (state.order.serviceLocation.state =
        orderInformation.serviceLocation.state),
      (state.order.serviceLocation.zipCode =
        orderInformation.serviceLocation.zipCode);

    state.order.payment.isInsurance = orderInformation.IsInsuranceOrder;
    state.order.payment.insuranceCoverage.isVerified =
      orderInformation?.insuranceInfo.coverageVerified;

    state.order.customer.emailAddress = orderInformation.customer.emailAddress;
    state.applicationUser.experiments = orderInformation.experiments;
  },
  updateExperiments(state, experiments) {
    state.applicationUser.experiments = experiments;
  },
  updateTriggeredSiteEntry(state, wasSiteEntryTriggered) {
    state.applicationUser.triggeredSiteEntry = wasSiteEntryTriggered;
  },
  // START GA click event mutations
  // updateCurrentlySelectedValues(state, groupName, value) {
  //   state.gaClickInformation.currentlySelectedValues[groupName] = value;
  // },
  // updateFiredGaClickEventValues(state, groupName, value) {
  //   state.gaClickInformation.firedGaClickEventValues[groupName] = value;
  // },
  // updateLastFocusedInputGroup(state, groupName) {
  //   state.gaClickInformation.lastFocusedInputGroup = groupName;
  // },
  // updateWasLastFocusedInputMultiselect(state, wasLastFocusedInputMultiselect) {
  //   state.gaClickInformation.wasLastFocusedInputMultiselect =
  //     wasLastFocusedInputMultiselect;
  // },
  // END GA click event mutations
};

// Export Getters
export const getters = {
  vehicle: (state) => state.order.vehicle,
  eventBusItem: (state) => (eventCategory, eventSubCategory) => {
    const matchedEvent = state.applicationUser.eventBus.find(
      ({ category, subCategory }) =>
        category === eventCategory && subCategory === eventSubCategory
    );

    return matchedEvent !== undefined ? matchedEvent.eventValue : undefined;
  },
  eventBus: (state) => state.applicationUser.eventBus,
  damage: (state) => state.order.damage,
  lineItems: (state) => state.order.lineItems,
  pageData: (state) => (page) => {
    return state.applicationUser.pageData[page];
  },
  applicationUser: (state) => state.applicationUser,
  order: (state) => state.order,
  payment: (state) => state.order.payment,
  experimentOrder: (state) => {
    return {
      funnelVehicleYear: state.order.vehicle.year,
      funnelVehicleMake: state.order.vehicle.make,
      funnelVehicleModel: state.order.vehicle.model,
      funnelVehicleStyle: state.order.vehicle.style,
      funnelIsRepair: state.order.damage.isRepair,
      funnelNumberOfChips: state.order.damage.numberOfChips,
      funnelCarId: state.order.vehicle.carId,
      funnelServiceCity: state.order.serviceLocation.city,
      funnelServiceState: state.order.serviceLocation.state,
      funnelServiceZipCode: state.order.serviceLocation.zipCode,
      funnelParentAccountNumber: state.order.accountNumber,
      funnelIsCoverageVerified:
        state.order.payment.insuranceCoverage.isVerified,
      funnelHasRecalibrationPart: getHasRecalibrationPart(state),
      funnelSelectedMultiGlass: state.order.damage.glassToReplace?.length > 1,
      funnelSelectedWindshieldGlass: getNonFalseValuesOfPropertyInArrayOfObjects(state.order.damage.glassToReplace, "glassLocation").includes(damageLocationsSelected.WINDSHIELD),
      funnelSelectedBackGlass: getNonFalseValuesOfPropertyInArrayOfObjects(state.order.damage.glassToReplace, "glassLocation").includes(damageLocationsSelected.REAR),
      funnelSelectedDriverSideGlass: getNonFalseValuesOfPropertyInArrayOfObjects(state.order.damage.glassToReplace, "glassLocation").includes(damageLocationsSelected.DRIVER),
      funnelSelectedPassengerSideGlass: getNonFalseValuesOfPropertyInArrayOfObjects(state.order.damage.glassToReplace, "glassLocation").includes(damageLocationsSelected.PASSENGER),

      funnelOrderPartNumbers: [...getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.glassParts, "partNumber"), ...getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.otherParts, "partNumber")],

      funnelOrderPartTypes: [...getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.glassParts, "recalibrationType"), ...getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.otherParts, "recalibrationType")],
    }
  },
  experimentSettings: (state) =>
    state.applicationUser.experiments
      .map((x) => x.settings)
      .reduce((r, c) => Object.assign(r, c), {}) ?? {},
  // gaClickInformation: (state) => state.gaClickInformation,
};

function getNonFalseValuesOfPropertyInArrayOfObjects(array, propertyName) {
  return (array ?? []).map(x => x[propertyName]).filter(x => x);
}

// Export Actions
export const actions = {
  // Vehicle API Actions
  getVehicleYears(context) {
    return globalMethods.callHttpClient({
      method: endpoints.GetVehicleYears.method,
      endpoint: endpoints.GetVehicleYears.url,
      payload: {},
    });
  },
  lookupVehicleByYmms(context, { year, make, model, style }) {
    return globalMethods.callHttpClient({
      method: endpoints.LookupVehicleByYmms.method,
      endpoint: `${endpoints.LookupVehicleByYmms.url}/${year}/${make}/${model}/${style}`,
      payload: {},
    });
  },
  lookupVehicleByVin(context, { vin }) {
    return globalMethods.callHttpClient({
      method: endpoints.LookupVehicleByVin.method,
      endpoint: endpoints.LookupVehicleByVin.url,
      payload: {
        vin: vin, // EX "1J4GW58S4XC541166"
      },
    });
  },
  lookupVinByPlate(context, { licensePlate, licenseState }) {
    return globalMethods.callHttpClient({
      method: endpoints.LookupVinByPlate.method,
      endpoint: endpoints.LookupVinByPlate.url,
      payload: {
        licensePlate: licensePlate,
        licenseState: licenseState,
      },
    });
  },
  lookupVinByAddress(
    context,
    { licenseLastName, licenseStreetAddress, licenseZip, licenseState }
  ) {
    return globalMethods.callHttpClient({
      method: endpoints.LookupVinByAddress.method,
      endpoint: endpoints.LookupVinByAddress.url,
      payload: {
        licenseLastName: licenseLastName,
        licenseStreetAddress: licenseStreetAddress,
        licenseZip: licenseZip,
        licenseState: licenseState,
      },
    });
  },
  getVehicleMakes(context, { year }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetVehicleMakes.method,
      endpoint: `${endpoints.GetVehicleMakes.url}/${year}`,
      payload: {},
    });
  },
  getVehicleModels(context, { year, make }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetVehicleModels.method,
      endpoint: `${endpoints.GetVehicleModels.url}/${year}/${make}`,
      payload: {},
    });
  },
  getVehicleStyles(context, { year, make, model }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetVehicleStyles.method,
      endpoint: `${endpoints.GetVehicleStyles.url}/${year}/${make}/${model}`,
      payload: {},
    });
  },
  setVehicle(context, { year, make, model, style }) {
    return globalMethods
      .callHttpClient({
        methods: endpoints.GetVehicle.method,
        endpoint: `${endpoints.GetVehicle.url}/${year}/${make}/${model}/${style}`,
        payload: {},
      })
      .then((response) => {
        context.commit(storeMutations.UPDATE_CAR_ID, response.data.carId);
        context.commit(
          storeMutations.UPDATE_VEHICLE_CATEGORY,
          response.data.category
        );
        context.commit(
          storeMutations.UPDATE_VEHICLE_IMAGE_URL,
          response.data.imageUrl
        );
        context.commit(
          storeMutations.UPDATE_VEHICLE_IMAGE_VIF_NUMBER,
          response.data.imageVifNumber
        );
        context.commit(
          storeMutations.UPDATE_VEHICLE_IMAGE_COLOR,
          response.data.imageVifColor
        );
        return response;
      });
  },
  getDamageOptions(context, { carId }) {
    return globalMethods.callHttpClient({
      methods: endpoints.GetDamageOptions.method,
      endpoint: `${endpoints.GetDamageOptions.url}/${carId}`,
      payload: {},
    });
  },
  validateZip(context, { zip }) {
    return globalMethods.callHttpClient({
      methods: endpoints.ValidateZip.method,
      endpoint: `${endpoints.ValidateZip.url}/${zip}`,
    });
  },

  // Dependency Actions
  resetVehicleAndDependencies(context) {
    context.commit(storeMutations.RESET_VEHICLE_STATE);
    context.commit(storeMutations.RESET_DAMAGE_STATE);
    context.commit(storeMutations.RESET_REGISTRATION_STATE);
  },
  resetDamageAndDependencies(context) {
    context.commit(storeMutations.RESET_DAMAGE_STATE);
    context.commit(storeMutations.RESET_GLASS_PARTS_STATE);
  },
  resetRegistrationAndDependencies(context) {
    context.commit(storeMutations.RESET_REGISTRATION_STATE);
    context.commit(storeMutations.RESET_GLASS_PARTS_STATE);
  },
  resetPartsAndDependencies(context) {
    context.commit(storeMutations.RESET_GLASS_PARTS_STATE);
  },
  resetState(context) {
    context.commit(storeMutations.RESET_STATE);
  },
  resetSaveSessionPromise(context) {
    context.commit(storeMutations.RESET_SAVE_SESSION_PROMISE);
  },

  // Content API Actions
  getRouteInfo(context, { pageName }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetRouteInfo.method,
      endpoint: endpoints.GetRouteInfo.url(applicationConfig.APPLICATION_ABBREVIATION),
      payload: {
        pageName: pageName,
      },
    });
  },
  getHomepageName(context) {
    return globalMethods.callHttpClient({
      method: endpoints.GetHomepageInfo.method,
      endpoint: endpoints.GetHomepageInfo.url(applicationConfig.APPLICATION_ABBREVIATION),
    });
  },
  getPageData(context, { pageName }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetPageData.method,
      endpoint: endpoints.GetPageData.url(applicationConfig.APPLICATION_ABBREVIATION, pageName),
      payload: {},
    });
  },

  // Analytics Actions
  logExperimentExposure(context, { userId, sessionKey, pageName, experiment }) {
    return globalMethods.callHttpClient({
      method: endpoints.LogExperimentExposureIfAssigned.method,
      endpoint: endpoints.LogExperimentExposureIfAssigned.url,
      payload: {
        experimentForLogging: {
          userId: userId,
          experimentUniverseId: experiment.universeId,
          experimentUniverseName: experiment.universeName,
          experimentTestId: experiment.testId,
          experimentTestName: experiment.testName,
          experimentVariationId: experiment.variationId,
          experimentVariationName: experiment.variationName,
          enabled: experiment.isActive,
          isExposed: experiment.isExposed,
          userPartitionNumber: experiment.userPartitionNumber,
          assignmentId: experiment.assignmentId,
          sessionKey: sessionKey,
          pageName: pageName,
        },
      },
    });
  },

  // Misc Actions
  updateStoreWithSaveSessionResponse(context, { referralNumber, referralDate, referralCorrelationId, eon, accountNumber, savedSessionId, crmCustomerId }) {
    context.commit(storeMutations.UPDATE_REFERRAL_NUMBER, referralNumber);
    context.commit(storeMutations.UPDATE_REFERRAL_DATE, referralDate);
    context.commit(
      storeMutations.UPDATE_REFERRAL_CORRELATION_ID,
      referralCorrelationId
    );
    context.commit(storeMutations.UPDATE_EON, eon);
    context.commit(storeMutations.UPDATE_PARENT_ACCT_NUMBER, accountNumber);
    context.commit(storeMutations.UPDATE_SAVED_SESSION_ID, savedSessionId);
    context.commit(storeMutations.UPDATE_CRM_CUSTOMER_ID, crmCustomerId);
  },
  logPageView(
    context,
    {
      userId,
      sessionKey,
      pageName,
      sessionId,
      action,
      event,
      shouldUseSessionId,
      experimentsForUser,
    }
  ) {
    var payload = {
      userId: userId,
      sessionKey: sessionKey,
      sessionId: sessionId,
      pageName: pageName,
      applicationName: applicationConfig.APPLICATION_NAME,
      action: action,
      event: event,
      shouldUseSessionId: shouldUseSessionId,
      experimentsForUser: experimentsForUser,
    };

    return globalMethods.callHttpClient({
      method: endpoints.LogPageView.method,
      endpoint: endpoints.LogPageView.url,
      payload: payload,
      logApiCall: false,
    });
  },
  logCustomEvent(
    context,
    {
      userId,
      sessionKey,
      pageName,
      sessionId,
      category,
      action,
      label,
      value,
      shouldUseSessionId,
      experimentsForUser,
    }
  ) {
    var payload = {
      userId: userId,
      sessionKey: sessionKey,
      sessionId: sessionId,
      pageName: pageName,
      applicationName: applicationConfig.APPLICATION_NAME,
      category: category,
      action: action,
      label: label,
      value: value,
      shouldUseSessionId: shouldUseSessionId,
      experimentsForUser: experimentsForUser,
    };

    return globalMethods.callHttpClient({
      method: endpoints.LogCustomEvent.method,
      endpoint: endpoints.LogCustomEvent.url,
      payload: payload,
      logApiCall: false,
    });
  },
  initializeSession(context, { userId, sessionId, userAgent, referrer }) {
    var payload = {
      applicationName: applicationConfig.APPLICATION_NAME,
      userId: userId,
      deviceId: userId,
      sessionId: sessionId,
      userAgent: userAgent,
      operatorId: "WEB",
      userName: "SafeliteConceptFunnel",
      referrer: referrer,
    };

    return globalMethods.callHttpClient({
      method: endpoints.InitializeSession.method,
      endpoint: endpoints.InitializeSession.url,
      payload: payload,
      logApiCall: false,
    });
  },

  // Misc Actions
  setReferralInformation(
    context,
    { referralNumber, referralDate, referralCorrelationId, eon }
  ) {
    context.commit(storeMutations.UPDATE_REFERRAL_NUMBER, referralNumber);
    context.commit(storeMutations.UPDATE_REFERRAL_DATE, referralDate);
    context.commit(
      storeMutations.UPDATE_REFERRAL_CORRELATION_ID,
      referralCorrelationId
    );
    context.commit(storeMutations.UPDATE_EON, eon);
  },

  GetExperimentsByUser(context, { userId }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetExperimentsByUser.method,
      endpoint: `${endpoints.GetExperimentsByUser.url}/${userId}`,
      payload: {},
    });
  },

  async runExperimentsForTrigger(
    context,
    { userId, triggerEvent, triggerValue }
  ) {
    if (triggerEvent == experimentTriggers.SITE_ENTRY) {
      context.commit(storeMutations.UPDATE_TRIGGERED_SITE_ENTRY, true);
    }

    var payload = {
      applicationName: applicationConfig.APPLICATION_NAME,
      userId: userId,
      triggerEvent: triggerEvent,
      triggerValue: triggerValue,
      experimentOrder: context.getters.experimentOrder,
    };

    const response = await globalMethods.callHttpClient({
      method: endpoints.RunExperimentsForTrigger.method,
      endpoint: endpoints.RunExperimentsForTrigger.url,
      payload: payload,
    });

    context.commit(
      storeMutations.UPDATE_EXPERIMENTS,
      response.data.experiments
    );
  },

  getEvoxImage(context, { relativeUrl }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetPageData.method,
      endpoint: relativeUrl,
      payload: {},
    });
  },

  // PartsOrQuestions API Actions
  getPartsOrQuestions(context) {
    const vehicle = context.getters.vehicle;
    const damage = context.getters.damage;
    const order = context.state.order;

    const carId = vehicle.carId;
    const glassArray = damage.glassToReplace;
    const zipCode = order.serviceLocation.zipCode;
    const vin = vehicle.vin;

    return globalMethods.callHttpClient({
      method: endpoints.GetPartsOrQuestions.method,
      endpoint: endpoints.GetPartsOrQuestions.url,
      payload: {
        carId: carId,
        glass: glassArray ?? [],
        zip: zipCode,
        vin: vin,
      },
    });
  },

  // Parts API Actions
  getParts(context) {
    const vehicle = context.getters.vehicle;
    const damage = context.getters.damage;
    const order = context.state.order;

    const carId = vehicle.carId;
    const glassArray = damage.glassToReplace;
    const resultsArray = damage.partQuestionAnswers;
    const zipCode = order.serviceLocation.zipCode;
    const vin = vehicle.vin;

    return globalMethods.callHttpClient({
      method: endpoints.GetParts.method,
      endpoint: endpoints.GetParts.url,
      payload: {
        carId: carId,
        glass: glassArray,
        answerResults: resultsArray,
        zip: zipCode,
        vin: vin,
      },
    });
  },

  getCapabilityQuestions(context, { carId, partNumber }) {
    return globalMethods.callHttpClient({
      method: endpoints.GetCapabilityQuestions.method,
      endpoint: `${endpoints.GetCapabilityQuestions.url}/${carId}/${partNumber}`,
    });
  },

  getPartFromCapabilityQuestionAnswer(context, glassLocation) {
    const pageData = context.getters.pageData(
      fmgPageValues.CAPABILITY_QUESTIONS
    );

    const part = pageData.partsOrQuestions.find(
      (x) => x.glassLocation === glassLocation
    ).parts[0];
    const capabilityQuestionAnswers =
      context.getters.damage.capabilityQuestionAnswers;
    const capabilityQuestionAnswersForPart = capabilityQuestionAnswers.find(
      (x) => x.glassLocation === glassLocation
    );

    return globalMethods.callHttpClient({
      method: endpoints.GetPartFromCapabilityAnswer.method,
      endpoint: endpoints.GetPartFromCapabilityAnswer.url,
      payload: {
        part,
        capabilityAnswerResults: capabilityQuestionAnswersForPart,
      },
    });
  },

  // Session API Actions
  saveSession(context) {
    const vehicle = context.getters.vehicle;
    const damage = context.getters.damage;
    const order = context.state.order;
    const applicationUser = context.getters.applicationUser;
    const lineItems = context.state.order.lineItems;

    return globalMethods.callHttpClient({
      method: endpoints.SaveSession.method,
      endpoint: endpoints.SaveSession.url,
      payload: {
        vehicle: {
          carId: vehicle.carId,
          year: vehicle.year,
          make: vehicle.make,
          model: vehicle.model,
          style: vehicle.style,
          vin: vehicle.vin,
          registration: {
            firstName: vehicle.registration.firstName,
            lastName: vehicle.registration.lastName,
            streetAddress: vehicle.registration.address,
            city: vehicle.registration.city,
            state: vehicle.registration.state,
            zipCode: vehicle.registration.zipCode,
            licensePlateNumber: vehicle.registration.licensePlate,
          },
        },
        damage: {
          numberOfChips: damage.numberOfChips,
          glassToReplace: damage.glassToReplace,
          isRepair: damage.isRepair,
        },
        customer: {
          emailAddress: order.customer.emailAddress,
        },
        lineItems: {
          glassParts: lineItems.glassParts,
        },
        serviceLocation: {
          streetAddress: order.serviceLocation.address,
          city: order.serviceLocation.city,
          state: order.serviceLocation.state,
          zipCode: order.serviceLocation.zipCode,
        },
        referralNumber: order.referralNumber?.toString(), // TODO It'd be nice to save these as strings in the first place
        referralDate: order.referralDate,
        accountNumber: order.accountNumber?.toString(),
        existingPromoCode: null,
        lastPage: applicationUser.lastPageVisited,
        crmCustomerId: applicationUser.crmCustomerId,
        savedSessionId: applicationUser.savedSessionId,
        experiments: applicationUser.experiments,
      },
    });
  },
  loadSession(context, { referralNumber, referralDate, referralCorrelationId, accountNumber }) {
    return globalMethods.callHttpClient({
      method: endpoints.LoadSession.method,
      endpoint: endpoints.LoadSession.url,
      payload: {
        referralNumber: referralNumber?.toString(),
        referralDate: referralDate,
        referralCorrelationId: referralCorrelationId,
        accountNumber: accountNumber?.toString()
      },
    }).then((response) => {
      // clear the state if the existing EON does not equal what is returned from loadSession
      if (context.state.order.eon && context.state.order.eon != response.data.eon) {
        context.commit(storeMutations.RESET_STATE);
      }
      context.commit(storeMutations.UPDATE_STATE_WITH_ORDER_INFORMATION, response.data);
      return response;
    });
  },

  // Business domain actions

  // Vehicle
  saveVehicleYear(context, year) {
    //Reset dependent state when changing
    if (context.state.order.vehicle.year !== year) {
      context.commit(storeMutations.UPDATE_MAKE, null);
      context.commit(storeMutations.UPDATE_MODEL, null);
      context.commit(storeMutations.UPDATE_STYLE, null);
      context.commit(storeMutations.UPDATE_CAR_ID, null);
      context.commit(storeMutations.UPDATE_VEHICLE_CATEGORY, null);
      context.commit(storeMutations.UPDATE_VEHICLE_VIN, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_URL, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_VIF_NUMBER, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_COLOR, null);

      context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);

      //Save new values
      context.commit(storeMutations.UPDATE_YEAR, year);
    }
  },
  saveVehicleMake(context, make) {
    //Reset dependent state when changing
    if (context.state.order.vehicle.make !== make) {
      context.commit(storeMutations.UPDATE_MODEL, null);
      context.commit(storeMutations.UPDATE_STYLE, null);
      context.commit(storeMutations.UPDATE_CAR_ID, null);
      context.commit(storeMutations.UPDATE_VEHICLE_CATEGORY, null);
      context.commit(storeMutations.UPDATE_VEHICLE_VIN, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_URL, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_VIF_NUMBER, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_COLOR, null);

      context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);

      //Save new values
      context.commit(storeMutations.UPDATE_MAKE, make);
    }
  },
  saveVehicleModel(context, model) {
    //Reset dependent state when changing
    if (context.state.order.vehicle.model !== model) {
      context.commit(storeMutations.UPDATE_STYLE, null);
      context.commit(storeMutations.UPDATE_CAR_ID, null);
      context.commit(storeMutations.UPDATE_VEHICLE_CATEGORY, null);
      context.commit(storeMutations.UPDATE_VEHICLE_VIN, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_URL, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_VIF_NUMBER, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_COLOR, null);

      context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);

      //Save new values
      context.commit(storeMutations.UPDATE_MODEL, model);
    }
  },
  saveVehicleStyle(context, style) {
    //Reset dependent state when changing
    if (context.state.order.vehicle.style !== style) {
      context.commit(storeMutations.UPDATE_CAR_ID, null);
      context.commit(storeMutations.UPDATE_VEHICLE_CATEGORY, null);
      context.commit(storeMutations.UPDATE_VEHICLE_VIN, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_URL, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_VIF_NUMBER, null);
      context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_COLOR, null);

      context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);

      //Save new values
      context.commit(storeMutations.UPDATE_STYLE, style);
    }
  },
  saveVehicleDamage(
    context,
    { isWindshieldRepair, selectedGlassToReplace, selectedWindshieldChipCount }
  ) {
    const selectedGlassPassedInSorted = selectedGlassToReplace.slice().sort();
    const isGlassToReplaceTheSame =
      context.state.order.damage.glassToReplace?.length ===
        selectedGlassToReplace.length &&
      context.state.order.damage.glassToReplace
        .slice()
        .sort()
        .every(
          (obj, index) =>
            obj.glassLocation ===
              selectedGlassPassedInSorted[index].glassLocation &&
            obj.glassName === selectedGlassPassedInSorted[index].glassName
        );
    const isWindshieldRepairTheSame =
      isWindshieldRepair === context.state.order.damage.isRepair;
    const isChipCountTheSame = Array.isArray(selectedWindshieldChipCount) //TODO: fix the underlying components so this is never an array
      ? selectedWindshieldChipCount[0] ===
        context.state.order.damage.numberOfChips
      : selectedWindshieldChipCount ===
        context.state.order.damage.numberOfChips;

    const isDamageChanging =
      !isGlassToReplaceTheSame ||
      !isWindshieldRepairTheSame ||
      (isWindshieldRepair && !isChipCountTheSame);

    if (isDamageChanging) {
      //Reset dependent state when changing
      context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);

      // Save new values
      context.commit(storeMutations.UPDATE_IS_REPAIR, isWindshieldRepair);
      context.commit(
        storeMutations.UPDATE_NUMBER_OF_CHIPS,
        isWindshieldRepair ? parseInt(selectedWindshieldChipCount) : null
      );
      context.commit(
        storeMutations.UPDATE_GLASS_TO_REPLACE,
        selectedGlassToReplace
      );
    }
  },

  // Vin lookup
  saveVinLookup(
    context,
    { isSelectedGlassAvailableForVehicle, vehicleInfo, registrationInfo }
  ) {
    //Reset dependent state when changing
    if (vehicleInfo.vin !== context.state.order.vehicle.vin) {
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);
      context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);

      if (!isSelectedGlassAvailableForVehicle) {
        context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
      }

      //Save new values
      context.commit(storeMutations.UPDATE_VEHICLE, vehicleInfo);
      context.commit(storeMutations.UPDATE_REGISTRATION, registrationInfo);
    }
  },
  saveRegistrationLicensePlateLookup(
    context,
    { isSelectedGlassAvailableForVehicle, vehicleInfo, registrationInfo }
  ) {
    //Reset dependent state when changing
    if (
      registrationInfo?.licensePlate !==
      context.state.order.vehicle.registration?.licensePlate
    ) {
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);

      if (!isSelectedGlassAvailableForVehicle) {
        context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
        context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);
      }

      //Save new values
      context.commit(storeMutations.UPDATE_VEHICLE, vehicleInfo);
      context.commit(storeMutations.UPDATE_REGISTRATION, registrationInfo);
    }
  },
  saveRegistrationAddressLookup(
    context,
    { isSelectedGlassAvailableForVehicle, vehicleInfo, registrationInfo }
  ) {
    //Reset dependent state when changing
    if (
      registrationInfo?.address !==
        context.state.order.vehicle.registration?.address ||
      registrationInfo?.city !==
        context.state.order.vehicle.registration?.city ||
      registrationInfo?.state !==
        context.state.order.vehicle.registration?.state ||
      registrationInfo?.zipCode !==
        context.state.order.vehicle.registration?.zipCode ||
      registrationInfo?.firstName !==
        context.state.order.vehicle.registration?.firstName ||
      registrationInfo?.lastName !==
        context.state.order.vehicle.registration?.lastName
    ) {
      context.dispatch(storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES);

      if (!isSelectedGlassAvailableForVehicle) {
        context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
        context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);
      }

      //Save new values
      context.commit(storeMutations.UPDATE_VEHICLE, vehicleInfo);
      context.commit(storeMutations.UPDATE_REGISTRATION, registrationInfo);
    }
  },
  savePartQuestionAnswers(context, partQuestionAnswersArray) {
    // if part question answers have changed, reset subsequent question answers
    const sortedPreviousResultsArray = sortArrayOfObjectsByPropertyValue(
      context.getters.damage.partQuestionAnswers,
      "result"
    );
    const sortedPartQuestionAnswersArray = sortArrayOfObjectsByPropertyValue(
      partQuestionAnswersArray,
      "result"
    );
    const havePartQuestionAnswersChanged =
      sortedPreviousResultsArray?.length !==
        sortedPartQuestionAnswersArray.length ||
      !sortedPreviousResultsArray?.every(
        (x, i) => x.result === sortedPartQuestionAnswersArray[i].result
      );

    if (havePartQuestionAnswersChanged) {
      context.commit(storeMutations.UPDATE_GLASS_PARTS, null);
      context.commit(storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS, null);
      context.commit(storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null);
      context.commit(storeMutations.UPDATE_PAGE_DATA, {
        page: fmgPageValues.VEHICLE_PARTS,
        data: null,
      });
      context.commit(storeMutations.UPDATE_PAGE_DATA, {
        page: fmgPageValues.MOLDING_QUESTIONS,
        data: null,
      });
      context.commit(storeMutations.UPDATE_PAGE_DATA, {
        page: fmgPageValues.CAPABILITY_QUESTIONS,
        data: null,
      });
    }

    //Save new values
    context.commit(
      storeMutations.UPDATE_PART_QUESTION_ANSWERS,
      partQuestionAnswersArray
    );
  },
  resetMoldingAndCapabilityQuestionAnswersIfNeeded(context, matchedParts) {
    const partsOrQuestionsDataToCompareWith =
      context.getters.pageData(fmgPageValues.MOLDING_QUESTIONS)
        ?.partsOrQuestions ??
      context.getters.pageData(fmgPageValues.CAPABILITY_QUESTIONS)
        ?.partsOrQuestions ??
      [];

    function getAllPartNumbers(partsOrQuestions) {
      return partsOrQuestions[0]?.parts
        ? [...partsOrQuestions]
            .map((glass) => glass.parts)
            .flat()
            .map((part) => part.partNumber)
            .filter((partNumber) => !partNumber.toUpperCase().includes("FEE"))
            .sort()
            .join(",")
        : [];
    }

    const previouslySelectedPartNumbers = getAllPartNumbers(
      partsOrQuestionsDataToCompareWith
    );
    const currentlySelectedPartNumbers = getAllPartNumbers(matchedParts);

    const haveSelectedVehiclePartsChanged =
      previouslySelectedPartNumbers !== currentlySelectedPartNumbers;

    if (haveSelectedVehiclePartsChanged) {
      context.commit(storeMutations.UPDATE_GLASS_PARTS, null);
      context.commit(storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS, null);
      context.commit(storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null);
      context.commit(storeMutations.UPDATE_PAGE_DATA, {
        page: fmgPageValues.MOLDING_QUESTIONS,
        data: null,
      });
      context.commit(storeMutations.UPDATE_PAGE_DATA, {
        page: fmgPageValues.CAPABILITY_QUESTIONS,
        data: null,
      });
    }
  },
  saveMoldingQuestionAnswers(context, moldingQuestionAnswers) {
    const sortedPreviousResultsArray = sortArrayOfObjectsByPropertyValue(
      context.getters.damage.moldingQuestionAnswers,
      "partNum"
    );
    const sortedMoldingQuestionAnswersArray = sortArrayOfObjectsByPropertyValue(
      moldingQuestionAnswers,
      "partNum"
    );
    const haveMoldingQuestionAnswersChanged =
      sortedPreviousResultsArray?.length !==
        sortedMoldingQuestionAnswersArray.length ||
      !sortedPreviousResultsArray?.every(
        (x, i) => x.partNum === sortedMoldingQuestionAnswersArray[i].partNum
      );

    if (haveMoldingQuestionAnswersChanged) {
      context.commit(storeMutations.UPDATE_GLASS_PARTS, null);
      context.commit(storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null);
      context.commit(storeMutations.UPDATE_PAGE_DATA, {
        page: fmgPageValues.CAPABILITY_QUESTIONS,
        data: null,
      });
    }

    //Save new values
    context.commit(
      storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS,
      moldingQuestionAnswers
    );
  },
  saveCapabilityQuestionAnswers(context, capabilityQuestionAnswers) {
    const sortedPreviousResultsArray = sortArrayOfObjectsByPropertyValue(
      context.getters.damage.capabilityQuestionAnswers,
      "result"
    );
    const sortedCapabilityQuestionAnswersArray =
      sortArrayOfObjectsByPropertyValue(capabilityQuestionAnswers, "result");
    const haveCapabilityQuestionAnswersChanged =
      sortedPreviousResultsArray?.length !==
        sortedCapabilityQuestionAnswersArray.length ||
      !sortedPreviousResultsArray?.every(
        (x, i) => x.result === sortedCapabilityQuestionAnswersArray[i].result
      );

    if (haveCapabilityQuestionAnswersChanged) {
      context.commit(storeMutations.UPDATE_GLASS_PARTS, null);
    }

    //Save new values
    context.commit(
      storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS,
      capabilityQuestionAnswers
    );
  },
  // Misc order actions
  saveServiceLocation(context, serviceLocationInfo) {
    context.commit(storeMutations.UPDATE_SERVICE_LOCATION, serviceLocationInfo);
  },
  saveEmail(context, email) {
    context.commit(storeMutations.UPDATE_CUSTOMER_EMAIL_ADDRESS, email);
  },
  saveVin(context, { isSelectedGlassAvailableForVehicle, vehicleInfo }) {
    //Reset dependent state when changing
    if (vehicleInfo.vin !== context.state.order.vehicle.vin) {
      if (!isSelectedGlassAvailableForVehicle) {
        context.dispatch(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES);
        context.dispatch(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES);
      }

      //Save new values
      context.commit(storeMutations.UPDATE_VEHICLE, vehicleInfo);
    }
  },
  saveGlassParts(context, parts) {
    context.commit(storeMutations.UPDATE_GLASS_PARTS, parts);
  },
  clearVin(context) {
    context.commit(storeMutations.UPDATE_VEHICLE_VIN, null);
  },
};

export default createStore({
  plugins: [createPersistedState()],
  // IMPORTANT: Be VERY careful when modifying these fields for at least a few reasons:
  //    * The CMS can reference the fields by name
  //    * Return users may have a previous "version" of the model, and we don't want
  //      them to have a breaking experience, because the model might have changed.
  state,
  mutations,
  getters,
  actions,
});

// Private Functions

function getHasRecalibrationPart(state) {
  var hasRequiresRecalibration = getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.glassParts, "requiresRecalibration")?.length > 0;
  var hasRecalibrationType = getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.glassParts, "recalibrationType")?.length > 0;

  if (hasRequiresRecalibration) {
    if (hasRecalibrationType) { // Has both 'requiresRecalibration' and 'recalibrationType' and 'recalibrationType'
      return getNonFalseValuesOfPropertyInArrayOfObjects(state.order.lineItems.glassParts, "recalibrationType")[0].toLowerCase() != "unknown";
    } else { // Has 'requiresRecalibration' but no 'recalibrationType' at all
      return true;
    }
  } else {
    // Does not have 'requiresRecalibration'
    return false;
  }
}

function sortArrayOfObjectsByPropertyValue(arrayOfObjects, propertyName) {
  if (!arrayOfObjects) return null;

  return arrayOfObjects.sort((a, b) => {
    if (a[propertyName] < b[propertyName]) return -1;
    else if (a[propertyName] > b[propertyName]) return 1;
    else return 0;
  });
}