export const reducer = (state = defaults, action, root) => {
    switch (action.type) {
        case SET_CLUSTER: {
            const cluster = !isNewItem(action)
                ? cloneDeep(root.list.clusters.get(action._id))
                : Object.assign({}, action.cluster, {
                    _id: -1,
                    space: defaultSpace(root),
                    name: uniqueName('New cluster', [...root.list.clusters.values()], ({name, i}) => `${name} (${i})`)
                });

            return Object.assign({}, state, {
                clusterID: cluster._id,
                cluster,
                newClusterCaches: [],
                oldClusterCaches: existingCaches(root.list.caches, cluster)
            });
        }

        case ADD_NEW_CACHE: {
            const cache = {
                _id: action._id,
                space: defaultSpace(root),
                name: uniqueName('New cache', [...root.list.caches.values(), ...state.newClusterCaches], ({name, i}) => `${name} (${i})`),
                cacheMode: 'PARTITIONED',
                atomicityMode: 'ATOMIC',
                readFromBackup: true,
                copyOnRead: true,
                clusters: [],
                domains: [],
                cacheStoreFactory: {CacheJdbcBlobStoreFactory: {connectVia: 'DataSource'}},
                memoryPolicyName: 'default'
            };

            return Object.assign({}, state, {
                newClusterCaches: [...state.newClusterCaches, cache]
            });
        }

        case REMOVE_CACHE: {
            const cache = action.cache;

            return Object.assign({}, state, {
                newClusterCaches: isNewItem(cache)
                    ? state.newClusterCaches.filter((c) => c._id !== cache._id)
                    : state.newClusterCaches,
                oldClusterCaches: isNewItem(cache)
                    ? state.oldClusterCaches
                    : state.oldClusterCaches.filter((c) => c._id !== cache._id)
            });
        }

        case SET_SELECTED_CACHES: {
            const value = Object.assign({}, state, {
                cluster: Object.assign({}, state.cluster, {
                    caches: [...action.cacheIDs.filter((id) => id)]
                })
            });

            value.oldClusterCaches = existingCaches(root.list.caches, value.cluster);

            return value;
        }

        default:
            return state;
    }
};

 async _formatForTux(entity: any) {
   if (!this.currentLocale) {
     await this.getDefaultLocaleForSpace(this.space)
   }
   const clone = cloneDeep(entity)
   const withoutLocale = extractLocale(clone, this.currentLocale)
   return withoutLocale
 }

 async _formatForApi(entity: any) {
   if (!this.currentLocale) {
     await this.getDefaultLocaleForSpace(this.space)
   }
   const clone = cloneDeep(entity)
   const withFormattedAssets = this._formatAssetsIfFound(clone)
   const withFormattedAssetsAndLocale = injectLocale(clone, this.currentLocale)
   return withFormattedAssetsAndLocale
 }

export const RuntimeConfig = (appConfig: IAppConfig, req: Request) => {
  const runtimeConfig: IAppConfig = cloneDeep(appConfig);

  runtimeConfig.features.disableParticles = req.query.disableParticles
                                            ? Boolean(req.query.disableParticles)
                                            : appConfig.features.disableParticles;

  return runtimeConfig;
};

export function overrideOptions(original: any[], overrides: any[]) {
  let copy = cloneDeep(original);
  overrides.forEach(override => {
    const option = copy.find((opt: any) => opt.name == override.name);
    if (option) {
      Object.assign(option, override);
    }
  });
  return copy;
}

export const sharedSingleStatOptionsCheck = (
  options: Partial<SingleStatBaseOptions> | any,
  prevPluginId: string,
  prevOptions: any
) => {
  for (const k of optionsToKeep) {
    if (prevOptions.hasOwnProperty(k)) {
      options[k] = cloneDeep(prevOptions[k]);
    }
  }
  return options;
};

export function extractLocale(model: ContentfulAdminModel, locale: string) {
  const clone = cloneDeep(model)
  const result: ContentfulEditModel = {
    fields: {},
    sys: { locale, ...clone.sys },
    __fullModel: clone,
  }

  for (const fieldName of Object.keys(model.fields)) {
    const fieldValue = model.fields[fieldName][locale]
    result.fields[fieldName] = fieldValue
  }

  return result
}

 return cluster.caches.map((id) => {
     return cloneDeep(caches.get(id));
 }).filter((v) => v);