import { storeActions } from "@/constants/store-actions.js";
import { widgetNames } from "@/constants/widget-names.js";
import store from "@/store";

export function fetchCmsContentForPage(fmgPage) {
  return store
    .dispatch(storeActions.GET_PAGE_DATA, { pageName: fmgPage })
    .then((response) => {
      const pageDataFromCms = {};

      response.data.Result.forEach((widget) => {

        let widgetWithReplacements = findAndReplaceGlobalStateValues(widget.Model, widget.Name);

        // If we already have this widget, push it on the collection
        if (widgetWithReplacements.Name in pageDataFromCms) {
          pageDataFromCms[widgetWithReplacements.Name].push(widgetWithReplacements.Model);
          return;
        }

        pageDataFromCms[widgetWithReplacements.Name] = [widgetWithReplacements.Model];
      });

      Object.keys(pageDataFromCms).forEach((key) => {
        if (pageDataFromCms[key].length === 1){
          pageDataFromCms[key] = pageDataFromCms[key][0];
        }
      });

      return pageDataFromCms;
    });
}

// Function to convert a string, into a matching global state item.
function mapStringToState(str) {

  // Pull all matches out of the string.
  const regexExp = new RegExp('{(.*?):(.*?)}', 'g');
  const matches = [...str.matchAll(regexExp)];

  // Our final string value that will be built from the matches.
  let stringBuilder = '';

  for (const match of matches) {

    // Reset store state for each match.
    let storeState = store.state;

    for (const s of match[2].split('.')) {
      if (storeState[s] != undefined) {
        storeState = storeState[s];
      } else {
        return ''; // if we can't map our string to state data, return an empty string.
      }
    }

    const stringWithReplacement = str.replace(match[0], storeState);

    // If we still have values we need to substitute, call this function again.
    if(stringWithReplacement.includes('{globalState:')) {
      return mapStringToState(stringWithReplacement);
    }

    // Concatenate the string.
    stringBuilder = `${stringBuilder} ${stringWithReplacement}`;
  }

  return stringBuilder.trimStart();
}

// Parent function for processWidgetItemForReplacement. This will loop through the parent
// object and pass any objects that need additional processing to the processWidgetItemForReplacement function.
function findAndReplaceGlobalStateValues(widgetModel, widgetName) {

  const objWithReplacements = {
    Name: widgetName,
    Model: {}
  };

  Object.keys(widgetModel).forEach(key => {

    let modelWithReplacements = processWidgetItemForReplacement(widgetModel, key);

    objWithReplacements.Model[key] = modelWithReplacements;
  });

  return objWithReplacements;
}

// This function will process the widget item and replace any global state variables with their values.
// This is a recursive function, it will call itself until it runs out of items to iterate on given the object.
function processWidgetItemForReplacement(widgetModel, key) {
  // If we have a string, and it needs to be replaced.
  if (typeof widgetModel[key] === 'string') {
    if (widgetModel[key].includes('{globalState:')) {
      widgetModel[key] = mapStringToState(widgetModel[key]);
    }
    return widgetModel[key];
  }

  // If we have an object. array, etc
  if (typeof widgetModel[key] === 'object' && Object.keys(widgetModel[key]).length) {
    Object.keys(widgetModel[key]).forEach(item => {
      processWidgetItemForReplacement(widgetModel[key], item);
    });

    return widgetModel[key];
  }

  // If we have something else like a number, boolean, etc. just return it
  return widgetModel[key];

}