import { defineStore } from "pinia";
import { endpoints } from "@/constants/endpoints.js";
import { getDateForSavedSessionTimeout } from "@/helpers/session-helper";
import globalMethods from "@/global-methods";
import { experimentTriggers } from "@/constants/experiments";
import { applicationConfig } from "@/constants/application-config";
import { issPageValues } from "@/router/router-constants/issPage-values";
import { damageLocationsSelected } from "@/constants/damage-locations-selected";

const storeId = 'main';

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,
        },
      },
      damage: {
        isRepair: null,
        numberOfChips: null,
        glassToReplace: null,
        partQuestionAnswers: null,
        moldingQuestionAnswers: null,
        capabilityQuestionAnswers: null,
      },
      policy: {
        policyNumber: null,
        dateOfLoss: null,
        damageCause: null,
        damageState: null,
        damageCity: null,
        isDamageGlassOnly: null,
      },
      customer: {
        address: {
          streetAddress: null,
          streetAddress2: null,
          city: null,
          state: null,
          zipCode: null,
        },
        firstName: null,
        lastName: null,
        emailAddress: null,
        phoneNumber: null,
      },
      serviceLocation: {
        address: null,
        city: null,
        state: null,
        zipCode: null,
        zipCodeCtu: null
      },
      lineItems: {
        glassParts: null,
        otherParts: null,
        supportingItems: null,
        vaps: null
      },
      payment: {
        isInsurance: true,
        insuranceCoverage: {
            isVerified: false,
        },
      },
      referralNumber: null,
      referralDate: null,
      accountNumber: 0,
    },
    applicationUser: {
      lastPageVisited: null,
      experiments: [],
      triggeredSiteEntry: false,
      eventBus: [],
      pageData: {},
      savedSessionTimeout: getDateForSavedSessionTimeout(),
      saveSessionPromise: null,
      savedSessionId: null,
      crmCustomerId: null,
      lastPageVisited: null,
      triggeredSiteEntry: false,
    },
    issConfig: {
      clientName: "",
      accountNumber: 0,
      styleSheet: "",
    }
  };
};

export const state = getDefaultState();

export const useMainStore = defineStore({
    id: storeId,
    state: () => state,
    getters: {
      vehicle: (state) => state.order.vehicle,
      damage: (state) => state.order.damage,
      lineItems: (state) => state.order.lineItems,
      eventBusItem: (state) => ( eventCategory, eventSubCategory) => {
        
        const matchedEvent = state.applicationUser.eventBus.find(
            ( { category, subCategory } ) =>
                category === eventCategory && subCategory === eventSubCategory
        );
        return matchedEvent?.eventValue;
      },
      eventBus: (state) => state.applicationUser.eventBus,
      applicationUserObj: (state) => state.applicationUser,
      pageData: (state) => (page) => {
          return state.applicationUser.pageData[page];
      },
      customerData: (state) => {
        if (state.order.vehicle.registration.address)
        {
          const registration = state.order.vehicle.registration;
          return {
            addressQuestions: {
              streetAddress: registration.address,
              city: registration.city,
              state: registration.state,
              zipCode: registration.zipCode,
            },
            firstName: registration.firstName,
            lastName: registration.lastName,
          }
        }
        else {
          const address = state.order.customer.address;
          return {
            addressQuestions: {
              streetAddress: address.streetAddress,
              city: address.city,
              state: address.state,
              zipCode: address.zipCode,
            },
            firstName: state.order.customer.firstName,
            lastName: state.order.customer.lastName,
          }
        }
      },      
      experimentOrder: (state) => {
        return {
            issVehicleYear: state.order.vehicle.year,
            issVehicleMake: state.order.vehicle.make,
            issVehicleModel: state.order.vehicle.model,
            issVehicleStyle: state.order.vehicle.style,
            issIsRepair: state.order.damage.isRepair,
            issNumberOfChips: state.order.damage.numberOfChips,
            issCarId: state.order.vehicle.carId,
            issServiceCity: state.order.serviceLocation.city,
            issServiceState: state.order.serviceLocation.state,
            issServiceZipCode: state.order.serviceLocation.zipCode,
            issParentAccountNumber: state.order.accountNumber,
            issIsCoverageVerified: state.order.payment.insuranceCoverage.isVerified,
            issHasRecalibrationPart: getHasRecalibrationPart(state),
            issSelectedMultiGlass: state.order.damage.glassToReplace?.length > 1,
            issSelectedWindshieldGlass: getNonFalseValuesOfPropertyInArrayOfObjects(
                state.order.damage.glassToReplace,
                "glassLocation"
            ).includes(damageLocationsSelected.WINDSHIELD),
            issSelectedBackGlass: getNonFalseValuesOfPropertyInArrayOfObjects(
                state.order.damage.glassToReplace,
                "glassLocation"
            ).includes(damageLocationsSelected.REAR),
            issSelectedDriverSideGlass: getNonFalseValuesOfPropertyInArrayOfObjects(
                state.order.damage.glassToReplace,
                "glassLocation"
            ).includes(damageLocationsSelected.DRIVER),
            issSelectedPassengerSideGlass: getNonFalseValuesOfPropertyInArrayOfObjects(
                state.order.damage.glassToReplace,
                "glassLocation"
            ).includes(damageLocationsSelected.PASSENGER),
            issOrderPartNumbers: [
                ...getNonFalseValuesOfPropertyInArrayOfObjects(
                    state.order.lineItems.glassParts,
                    "partNumber"
                ),
                ...getNonFalseValuesOfPropertyInArrayOfObjects(
                    state.order.lineItems.otherParts,
                    "partNumber"
                ),
            ],

            issOrderPartTypes: [
                ...getNonFalseValuesOfPropertyInArrayOfObjects(
                    state.order.lineItems.glassParts,
                    "recalibrationType"
                ),
                ...getNonFalseValuesOfPropertyInArrayOfObjects(
                    state.order.lineItems.otherParts,
                    "recalibrationType"
                ),
            ],
        };
      },
      experimentSettings: (state) => {
        return state.applicationUser.experiments
              .map((x) => x.settings)
              .reduce((r, c) => Object.assign(r, c), {}) ?? {}
      }
    },
    actions:
    {
      // Content API Actions
      
      lookupVinByAddress({ licenseLastName, licenseStreetAddress, licenseZip, licenseState }) {
          return globalMethods.callHttpClient({
              method: endpoints.LookupVinByAddress.method,
              endpoint: endpoints.LookupVinByAddress.url,
              payload: {
                  licenseLastName: licenseLastName,
                  licenseStreetAddress: licenseStreetAddress,
                  licenseZip: licenseZip,
                  licenseState: licenseState,
              },
          });
      },

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

       // Vehicle API Actions
      getVehicleYears() {
        return globalMethods.callHttpClient({
          method: endpoints.GetVehicleYears.method,
          endpoint: endpoints.GetVehicleYears.url,
          payload: {},
        });
      },

      getVehicleMakes() {
        return globalMethods.callHttpClient({
          method: endpoints.GetVehicleMakes.method,
          endpoint: endpoints.GetVehicleMakes.url + this.order.vehicle.year,
          payload: {},
        });
      },

      getVehicleModels() {
        return globalMethods.callHttpClient({
          method: endpoints.GetVehicleModels.method,
          endpoint: `${endpoints.GetVehicleModels.url}/${this.order.vehicle.year}/${this.order.vehicle.make}`,
          payload: {},
        });
      },

      getVehicleStyles() {
        return globalMethods.callHttpClient({
          method: endpoints.GetVehicleStyles.method,
          endpoint: `${endpoints.GetVehicleStyles.url}/${this.order.vehicle.year}/${this.order.vehicle.make}/${this.order.vehicle.model}`,
          payload: {},
        });
      },

      getDamageOptions(carId) {
        return globalMethods.callHttpClient({
            methods: endpoints.GetDamageOptions.method,
            endpoint: `${endpoints.GetDamageOptions.url}/${carId}`,
            payload: {},
        });
      },

      async lookupVinByPlate(licensePlate, licenseState) {
      try {
        const response = await globalMethods.callHttpClient({
          method: endpoints.LookupVinByPlate.method,
          endpoint: endpoints.LookupVinByPlate.url,
          payload: {
            licensePlate: licensePlate,
            licenseState: licenseState, 
          },
        });

        return response;
      } catch (responseError) {
        return {
          error: {
            status: responseError.status,
          },
        };
      }
      },

      // PartsOrQuestions API Actions
      async getPartsOrQuestions() {
        const vehicle = this.vehicle;
        const damage = this.damage;
        const order = this.order;

        const carId = vehicle.carId;
        const glassArray = damage.glassToReplace;
        const zipCode = vehicle.registration.zipCode ? vehicle.registration.zipCode : order.customer.address.zipCode;
        const vin = vehicle.vin;

        // create a new array to avoid mutating state
        const glassArrayForPayload = convertGlassPieceNamingForApi(glassArray);

        const response = await globalMethods.callHttpClient({
            method: endpoints.GetPartsOrQuestions.method,
            endpoint: endpoints.GetPartsOrQuestions.url,
            payload: {
                carId: carId,
                glassPieces: glassArrayForPayload,
                zip: zipCode,
                vin: vin,
            },
        });

        // Flatten location and name properties
        response.data.partsOrQuestions = convertGlassPieceNamingFromApi(
          response.data.partsOrQuestions
        );

        return response;
      },

      async getParts() {
        const vehicle = this.order.vehicle;
        const damage = this.order.damage;
        const order = this.order;

        const carId = vehicle.carId;
        const glassArray = damage.glassToReplace;
        const resultsArray = damage.partQuestionAnswers;
        const zipCode = vehicle.registration.zipCode ? vehicle.registration.zipCode : order.customer.address.zipCode;
        const vin = vehicle.vin;

        // create a new array to avoid mutating state
        const glassArrayForPayload = convertGlassPieceNamingForApi(glassArray);
        const resultsArrayForPayload = convertResultsForApi(resultsArray);

        const response = await globalMethods.callHttpClient({
            method: endpoints.GetParts.method,
            endpoint: endpoints.GetParts.url,
            payload: {
                carId: carId,
                glassPieces: glassArrayForPayload,
                answerResults: resultsArrayForPayload,
                zip: zipCode,
                vin: vin,
            },
        });

        // Flatten location and name properties
        response.data.glassPieceParts = convertGlassPieceNamingFromApi(
            response.data.glassPieceParts
        );

        return response;
      },

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

      setVehicle() {
        return globalMethods
          .callHttpClient({
              methods: endpoints.GetVehicle.method,
              endpoint: `${endpoints.GetVehicle.url}/${this.order.vehicle.year}/${this.order.vehicle.make}/${this.order.vehicle.model}/${this.order.vehicle.style}`,
              payload: {},
          })
          .then((response) => {
            this.updateVehicle(response.data);
            return response;
          });
      },

      saveVehicleDamage(isWindshieldRepair, selectedGlassToReplace, selectedWindshieldChipCount) {
        const selectedGlassPassedInSorted = selectedGlassToReplace.slice().sort();
        const isGlassToReplaceTheSame =
            this.order.damage.glassToReplace?.length === selectedGlassToReplace.length &&
            this.order.damage.glassToReplace
                .slice()
                .sort()
                .every(
                    (obj, index) =>
                        obj.glassLocation === selectedGlassPassedInSorted[index].glassLocation &&
                        obj.glassName === selectedGlassPassedInSorted[index].glassName
                );
        const isWindshieldRepairTheSame =
            isWindshieldRepair === this.order.damage.isRepair;

        const isChipCountTheSame =
            selectedWindshieldChipCount === this.order.damage.numberOfChips;

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

        if (isDamageChanging) {
            //Reset dependent state when changing
            this.resetGlassPartsState();

            // Save new values
            this.updateIsRepair(isWindshieldRepair);
            this.updateNumberOfChips(isWindshieldRepair ? parseInt(selectedWindshieldChipCount) : null);
            this.updateGlassToReplace(selectedGlassToReplace);
        }
      },

      updateRegistration(registrationInfo) {
        this.order.vehicle.registration.licensePlate = registrationInfo?.licensePlate;
        this.order.vehicle.registration.address = registrationInfo?.address;
        this.order.vehicle.registration.city = registrationInfo?.city;
        this.order.vehicle.registration.state = registrationInfo?.state;
        this.order.vehicle.registration.zipCode = registrationInfo?.zipCode;
        this.order.vehicle.registration.firstName = registrationInfo?.firstName;
        this.order.vehicle.registration.lastName = registrationInfo?.lastName;
      },

      updateServiceLocation(serviceLocationInfo) {
        this.order.serviceLocation.address = serviceLocationInfo.address;
        this.order.serviceLocation.city = serviceLocationInfo.city;
        this.order.serviceLocation.state = serviceLocationInfo.state;
        this.order.serviceLocation.zipCode = serviceLocationInfo.zipCode;
        this.order.serviceLocation.zipCodeCtu = serviceLocationInfo.zipCodeCtu;
      },

      resetRegistrationState() {
        this.order.vehicle.registration.licensePlate = null;
        this.order.vehicle.registration.address = null;
        this.order.vehicle.registration.city = null;
        this.order.vehicle.registration.state = null;
        this.order.vehicle.registration.zipCode = null;
        this.order.vehicle.registration.firstName = null;
        this.order.vehicle.registration.lastName = null;
      },

      resetISSConfigState()
      {
        this.issConfig.clientName = "";
        this.issConfig.accountNumber = 0;
        this.issConfig.styleSheet = "";
      },

      updateSupportingItems(partsData) {
        this.order.lineItems.supportingItems = partsData;
      },

      updateVaps(partsData) {
        this.order.lineItems.vaps = partsData;
      },

      updateVehicle(vehicle) {
        // Assuming that the method caller pass all the properties.
        //   otherwise need to check for undefined for every property.
        
        this.order.vehicle.carId = vehicle.carId;
        this.order.vehicle.category = vehicle.category;
        this.order.vehicle.year = vehicle.year;
        this.order.vehicle.make = vehicle.make;
        this.order.vehicle.model = vehicle.model;
        this.order.vehicle.style = vehicle.style;
        this.order.vehicle.vin = vehicle.vin;
        this.order.vehicle.imageUrl = vehicle.imageUrl;
        this.order.vehicle.imageVifNumber = vehicle.imageVifNumber;
        this.order.vehicle.imageColor = vehicle.imageVifColor;
      },

      updateVehicleVin(vin) {
        this.order.vehicle.vin = vin;
      },

      resetVehicleState()
      {
        this.order.vehicle.year = null;
        this.order.vehicle.make = null;
        this.order.vehicle.model = null;
        this.order.vehicle.style = null;
        this.order.vehicle.carId = null;
        this.order.vehicle.category = null;
        this.order.vehicle.vin = null;
        this.order.vehicle.imageUrl = null;
        this.order.vehicle.imageVifNumber = null;
        this.order.vehicle.imageColor = null;
      },

      resetGlassPartsState() {
        this.order.lineItems.glassParts = null;
        this.order.damage.partQuestionAnswers = null;
        this.order.damage.moldingQuestionAnswers = null;
        this.order.damage.capabilityQuestionAnswers = null;
        this.applicationUser.pageData[issPageValues.PART_QUESTIONS] = null;
        this.applicationUser.pageData[issPageValues.VEHICLE_PARTS] = null;
        this.applicationUser.pageData[issPageValues.MOLDING_QUESTIONS] = null;
        this.applicationUser.pageData[issPageValues.CAPABILITY_QUESTIONS] = null;
      },

      resetSupportingItemsState() {
        this.order.lineItems.supportingItems = null;
      },

      resetDamageState() {
        this.order.damage.isRepair = null;
        this.order.damage.numberOfChips = null;
        this.order.damage.glassToReplace = null;
      },

      resetMoldingAndCapabilityQuestionAnswersIfNeeded(matchedParts) {
        const partsOrQuestionsDataToCompareWith =
            this.pageData(issPageValues.MOLDING_QUESTIONS)?.partsOrQuestions ??
            this.pageData(issPageValues.CAPABILITY_QUESTIONS)?.partsOrQuestions ??
            [];

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

        const haveSelectedVehiclePartsChanged =
            previouslySelectedPartNumbers !== currentlySelectedPartNumbers;

        if (haveSelectedVehiclePartsChanged) {
          this.updateGlassParts(null);
          this.resetSupportingItemsState();
          this.updateMoldingQuestionAnswers(null);
          this.updateCapabilityQuestionAnswers(null);
          this.updatePageData({ page: issPageValues.MOLDING_QUESTIONS, data: null});
          this.updatePageData({ page: issPageValues.CAPABILITY_QUESTIONS, data: null});
        }
    },

      updateVehicleYear(year) {
        if(this.order.vehicle.year != year)
        {
          this.resetVehicleState();
          this.resetDamageState();
          this.order.vehicle.year = year;
        }
      },

      updateVehicleMake(make) {
        if(this.order.vehicle.make != make)
        {
          const year = this.order.vehicle.year;
          
          this.resetVehicleState();
          this.resetDamageState();
          
          this.order.vehicle.year = year;
          this.order.vehicle.make = make;
        }
      },

      updateVehicleModel(model) {
        if(this.order.vehicle.model != model)
        {
          const year = this.order.vehicle.year;
          const make = this.order.vehicle.make;

          this.resetVehicleState();
          this.resetDamageState();

          this.order.vehicle.year = year;
          this.order.vehicle.make = make;
          this.order.vehicle.model = model;
        }
      },
      

      updateVehicleStyle(style) {
        if(this.order.vehicle.style != style)
        {
          const year = this.order.vehicle.year;
          const make = this.order.vehicle.make;
          const model = this.order.vehicle.model;

          this.resetVehicleState();
          this.resetDamageState();

          this.order.vehicle.year = year;
          this.order.vehicle.make = make;
          this.order.vehicle.model = model;
          this.order.vehicle.style = style;
        }
      },

      updateIsRepair(isRepair) {
        this.order.damage.isRepair = isRepair;
      },

      updateNumberOfChips(numberOfChips) {
        this.order.damage.numberOfChips = numberOfChips;
      },

      updateGlassToReplace(glassToReplace) {
        this.order.damage.glassToReplace = glassToReplace;
      },

      updateGlassParts(partsData) {
        this.order.lineItems.glassParts = partsData;
      },

      updateMoldingQuestionAnswers(answersArray) {
        this.order.damage.moldingQuestionAnswers = answersArray;
      },

      updateCapabilityQuestionAnswers(answersArray) {
        this.order.damage.capabilityQuestionAnswers = answersArray;
      },

      updatePartQuestionAnswers(answersArray) {
        this.order.damage.partQuestionAnswers = answersArray;
      },

      updatePageData(pageData) {
        this.applicationUser.pageData[pageData.page] = pageData.data;
      },
      updatePolicyData(welcomePageModel)
      {
        this.order.policy.policyNumber = welcomePageModel?.policyNumber;
        this.order.policy.dateOfLoss = welcomePageModel?.dateOfLoss;
        this.order.policy.damageCause = welcomePageModel?.damageCause;
        this.order.policy.damageState = welcomePageModel?.damageState;
        this.order.policy.damageCity = welcomePageModel?.damageCity;
        this.order.policy.isDamageGlassOnly = welcomePageModel?.isDamageGlassOnly;
        this.order.customer.phoneNumber = welcomePageModel?.phoneNumber;
        this.order.customer.emailAddress = welcomePageModel?.email;
      },
      updatePolicyHolderDetails(customerQuestions)
      {
        this.order.customer.address.streetAddress = customerQuestions.addressQuestions.streetAddress;
        this.order.customer.address.streetAddress2 = customerQuestions.addressQuestions.streetAddress2;
        this.order.customer.address.city = customerQuestions.addressQuestions.city;
        this.order.customer.address.state = customerQuestions.addressQuestions.state;
        this.order.customer.address.zipCode = customerQuestions.addressQuestions.zipCode;
        this.order.customer.firstName = customerQuestions.firstName;
        this.order.customer.lastName = customerQuestions.lastName;
      },
      savePartQuestionAnswers(partQuestionAnswersArray) {
        // if part question answers have changed, reset subsequent question answers
        const sortedPreviousResultsArray = sortArrayOfObjectsByPropertyValue(
            this.order.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) {
            this.updateGlassParts(null);
            this.updateMoldingQuestionAnswers(null);
            this.updateCapabilityQuestionAnswers(null);
            this.updatePageData({ page: issPageValues.VEHICLE_PARTS, data: null});
            this.updatePageData({ page: issPageValues.MOLDING_QUESTIONS, data: null});
            this.updatePageData({ page: issPageValues.CAPABILITY_QUESTIONS, data: null});
        }

        //Save new values
        this.updatePartQuestionAnswers(partQuestionAnswersArray);
      },
      saveMoldingQuestionAnswers(moldingQuestionAnswersArray) {
        const sortedPreviousResultsArray = sortArrayOfObjectsByPropertyValue(
          this.order.damage.moldingQuestionAnswers, 
          "result"
        );
        const sortedMoldingQuestionAnswersArray = sortArrayOfObjectsByPropertyValue(
          moldingQuestionAnswersArray, 
          "result"
        );
        const haveMoldingQuestionAnswersChanged = 
          sortedPreviousResultsArray?.length !== sortedMoldingQuestionAnswersArray.length ||
          !sortedPreviousResultsArray?.every(
            (x, i) => x.result === sortedMoldingQuestionAnswersArray[i].result
          );
        
        if (haveMoldingQuestionAnswersChanged) {
          this.updateGlassParts(null);
          this.updateSupportingItems(null);
          this.updateCapabilityQuestionAnswers(null);
          this.updatePageData({
            page: issPageValues.CAPABILITY_QUESTIONS,
            data: null,
          });
        }

        // Save new values
        this.updateMoldingQuestionAnswers(moldingQuestionAnswersArray);
      },
      saveCapabilityQuestionAnswers(capabilityQuestionAnswersArray) {
        const sortedPreviousResultsArray = sortArrayOfObjectsByPropertyValue(
          this.order.damage.capabilityQuestionAnswers, 
          "result"
        );
        const sortedCapabilityQuestionAnswersArray = sortArrayOfObjectsByPropertyValue(
          capabilityQuestionAnswersArray, 
          "result"
        );
        const haveCapabilityQuestionAnswersChanged = 
          sortedPreviousResultsArray?.length !== sortedCapabilityQuestionAnswersArray.length ||
          !sortedPreviousResultsArray?.every(
            (x, i) => x.result === sortedCapabilityQuestionAnswersArray[i].result
          );
        
        if (haveCapabilityQuestionAnswersChanged) {
          this.updateGlassParts(null);
          this.updateSupportingItems(null);
        }

        // Save new values
        this.updateCapabilityQuestionAnswers(capabilityQuestionAnswersArray);
      },
     
      addEventToBus (event) {
        this.applicationUser.eventBus.push(event);
      },
      removeEventFromBus (eventData) {
          const matchedEvent = this.applicationUser.eventBus.find(
              ( {category, subCategory } ) =>
                  category === eventData.category && subCategory === eventData.subCategory
          );
          const itemIndex = this.applicationUser.eventBus.indexOf(matchedEvent);

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

      // populate initial state
      populateInitialState()
      {
        if(!localStorage.getItem(storeId)) {
          this.$state = state;
        }
      },

      // Analytics Actions
      logExperimentExposure({ 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,
                },
            },
        });
      },
      logPageView({ 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({ userId, sessionKey, pageName, sessionId, category, action, label, value, shouldUseSessionId, experimentsForUser})
      {
          if ( pageName == null || pageName.length == 0 )
            pageName = "none";

          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({ userId, sessionId, userAgent, referrer }) {
          var payload = {
              applicationName: applicationConfig.APPLICATION_NAME,
              userId: userId,
              deviceId: userId,
              sessionId: sessionId,
              userAgent: userAgent,
              operatorId: "WEB",
              userName: "SafeliteISS",
              referrer: referrer,
          };

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

      updateLastPageVisited(lastPageVisited) {
        this.applicationUser.lastPageVisited = lastPageVisited;
      },

      updateExperiments(experiments) {
        this.applicationUser.experiments = experiments;
      },
      updateTriggeredSiteEntry(wasSiteEntryTriggered) {
        this.applicationUser.triggeredSiteEntry = wasSiteEntryTriggered;
      },

      GetExperimentsByUser(userId) {
        return globalMethods.callHttpClient({
            method: endpoints.GetExperimentsByUser.method,
            endpoint: `${endpoints.GetExperimentsByUser.url}/${userId}`,
            payload: {},
        });
      },
      
      async runExperimentsForTrigger({ userId, triggerEvent, triggerValue }) {
        if (triggerEvent == experimentTriggers.SITE_ENTRY) {
            this.updateTriggeredSiteEntry(true);
        }

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

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

        this.updateExperiments(response.data.experiments);
      },

      async validateZip({ zip }) {
        return await globalMethods.callHttpClient({
            methods: endpoints.ValidateZip.method,
            endpoint: `${endpoints.ValidateZip.url}/${zip}`,
        });
      },

      async validateClientTag(clientTag) {
        return await globalMethods.callHttpClient({
            methods: endpoints.ValidateClientTag.method,
            endpoint: `${endpoints.ValidateClientTag.url}/${clientTag}`,
        });
      },

      saveServiceLocation(serviceLocationInfo) {
        this.updateServiceLocation(serviceLocationInfo);
      },

      saveRegistrationAddressLookup({ isSelectedGlassAvailableForVehicle, vehicleInfo, registrationInfo }) {
        //Reset dependent state when changing
        if 
        (
            registrationInfo?.address !== this.order.vehicle.registration?.address ||
            registrationInfo?.city !== this.order.vehicle.registration?.city ||
            registrationInfo?.state !== this.order.vehicle.registration?.state ||
            registrationInfo?.zipCode !== this.order.vehicle.registration?.zipCode ||
            registrationInfo?.firstName !== this.order.vehicle.registration?.firstName ||
            registrationInfo?.lastName !== this.order.vehicle.registration?.lastName
        ) 
        {
            this.resetRegistrationAndDependencies();

            if (!isSelectedGlassAvailableForVehicle) {
                this.resetDamageAndDependencies();
                this.resetPartsAndDependencies();
            }

            //Save new values
            this.updateVehicle(vehicleInfo);
            this.updateRegistration(registrationInfo);
        }
      },
      saveVin({ isSelectedGlassAvailableForVehicle, vehicleInfo }) {
        //Reset dependent state when changing
        if (vehicleInfo.vin !== this.order.vehicle.vin) {
          this.resetRegistrationAndDependencies();

          if (!isSelectedGlassAvailableForVehicle) {
            this.resetDamageAndDependencies();
            this.resetPartsAndDependencies();
          }
          
          //Save new values
          this.updateVehicle(vehicleInfo);
        }
      },
      saveRegistrationLicensePlateLookup({ isSelectedGlassAvailableForVehicle, vehicleInfo, registrationInfo }) {
        //Reset dependent state when changing
        if 
        (
            registrationInfo?.licensePlate !== this.order.vehicle.registration?.licensePlate ||
            registrationInfo?.state !== this.order.vehicle.registration?.state
        )
        {
            this.resetRegistrationAndDependencies();

            if (!isSelectedGlassAvailableForVehicle) {
              this.resetDamageAndDependencies();
              this.resetPartsAndDependencies();
            }

            //Save new values
            this.updateVehicle(vehicleInfo);
            this.updateRegistration(registrationInfo);
        }
      },

      resetRegistrationAndDependencies() {
        this.resetRegistrationState();
        this.resetGlassPartsState();
        this.updateSupportingItems(null);
      },

      resetDamageAndDependencies() {
        this.resetDamageState();
        this.resetGlassPartsState();
        this.updateSupportingItems(null);
        this.updateVaps(null);
      },

      resetPartsAndDependencies() {
        this.resetGlassPartsState();
        this.updateSupportingItems(null);
      },
    },
    persist: true
});


// 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 getNonFalseValuesOfPropertyInArrayOfObjects(array, propertyName) {
  return (array ?? []).map((x) => x[propertyName]).filter((x) => x);
}


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;
  });
}

function convertGlassPieceNamingForApi(glassArray) {
  if (!glassArray || glassArray.length === 0) return [];

  // check if array already converted.  (likely when a session has been saved previously and then reloaded)
  if (glassArray[0].location !== undefined) {
      return glassArray;
  }

  const converted = [];
  glassArray.forEach((glass) => {
      converted.push({
          location: glass.glassLocation,
          name: glass.glassName,
      });
  });
  return converted;
}

function convertResultsForApi(resultsArray) {
  if (!resultsArray) return [];
  const converted = [];
  resultsArray.forEach((answer) => {
      converted.push({
          location: answer.glassLocation,
          name: answer.glassName,
          result: answer.result,
      });
  });
  return converted;
}

function convertGlassPieceNamingFromApi(glassArray) {
  glassArray.forEach((glass) => {
      glass.glassLocation = glass.glassPiece.location;
      glass.glassName = glass.glassPiece.name;
      delete glass.glassPiece;
      return glass;
  });
  return glassArray;
}

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(",")
      : [];
}