import { defineStore } from "pinia";
import { endpoints } from "@/constants/endpoints.js";
import { getDateForSavedSessionTimeout } from "@/helpers/session-helper";
import globalMethods from "@/global-methods";
import { applicationConfig } from "@/constants/application-config";

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

export const state = getDefaultState();

export const useMainStore = defineStore({
    id: storeId,
    state: () => state,
    getters: {
      vehicle: (state) => state.order.vehicle,
      damage: (state) => state.order.damage,
      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];
      },      
      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), {}) ?? {}
    },
    actions:
    {
        // Content API Actions
      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: {},
        });
      },
      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;
          });
      },

      updateVehicle(vehicle) {
        this.order.vehicle.carId = vehicle.carId;
        this.order.vehicle.category = vehicle.category;
        this.order.vehicle.imageUrl = vehicle.imageUrl;
        this.order.vehicle.imageVifNumber = vehicle.imageVifNumber;
        this.order.vehicle.imageColor = vehicle.imageColor;
      },

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

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

      updateVehicleMake(make) {
        if(this.order.vehicle.make != make)
        {
          const year = this.order.vehicle.year;
          
          this.resetVehicleState();
          
          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.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.order.vehicle.year = year;
          this.order.vehicle.make = make;
          this.order.vehicle.model = model;
          this.order.vehicle.style = style;
        }
      },
     
      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;
      },

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

    },
    persist: true
});