const instantiate = curry((
  options: Options,
  schemaRef: string
): InstantiateResult => {
  if (!options.ajv) {
    return {
      hasResult: false,
      error: 'options.ajv is required'
    };
  }

  options = merge({}, defaultOptions, options);

  schemaRef = normalizeSchemaRef(schemaRef, options);

  const validateFunction = options.ajv.getSchema(schemaRef);
  if (!validateFunction) {
    return {
      hasResult: false,
      error: `schema not found: ${schemaRef}`
    };
  }

  const { schemaId } = parseRef(schemaRef);

  return recursiveInstantiate(schemaId, validateFunction.schema, options);
});

function maybeResolveRefs(id: string, def: any, options: Options): any {
  if (!options.resolveDefaultRefs || !isObject(def)) {
    return def;
  }

  if (Array.isArray(def)) {
    return def.map(val => maybeResolveRefs(id, val, options));
  }

  let result = {};

  if (has(def, '$ref')) {
    const { hasResult, result: resolveResult } = resolveRef(id, def, options);
    def = omit(def, '$ref');
    if (hasResult) {
      result = resolveResult;
    }
  }

  const rest = deepMap(def, val =>
    has(val, '$ref') ? resolveRef(id, val, options).result : val
  );

  return merge({}, result, rest);
}

function resolveRef(
  id: string,
  schema: object,
  options: Options
): InstantiateResult {
  const withoutRef = omit(schema, '$ref');

  const { schemaId = id, path } = parseRef(schema['$ref']);
  const validateFunction = options.ajv.getSchema(schemaId);

  if (!validateFunction) {
    return { hasResult: false, error: options.ajv.errors };
  }

  const resolved = get(
    validateFunction.schema,
    path.filter(p => p !== undefined),
    {}
  );
  const result = merge({}, resolved, withoutRef);

  return recursiveInstantiate(schemaId, result, options);
}

export const createArkhamStore = (configuration: ArkhamReduxStoreType): Store<any> => {
  const {
    arkhamMiddleware: middleware = [],
    flux,
    reducers,
    sagas,
    statePath = '',
    reduxMiddleware = [],
    devTools
  } = configuration;

  // Save initial state tree
  const {storage} = Flux.getOptions();
  let store: Store;

  if(storage) {
    const cachedState = Flux.getState(statePath);

    if(devTools) {
      store = createStore(
        devTools(reducers, cachedState),
        applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
    } else {
      store = createStore(
        reducers,
        cachedState,
        applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
    }

    if(cachedState === undefined) {
      const stateTree = store.getState();
      const updatedState = isPlainObject(stateTree) ? merge(stateTree, cachedState) : stateTree;
      Flux.setState(statePath, updatedState);
    }
  } else {
    store = createStore(
      reducers,
      devTools,
      applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux))
    );

    Flux.setState(statePath, store.getState());
  }

  // If saga is being added, run.
  reduxMiddleware.every((item: any) => {
    if(sagas) {
      item.run(sagas);
      return false;
    }

    return true;
  });

  // Add redux middleware to Arkham to relay dispatches to Redux
  middleware.push(new ReduxMiddleware(store, statePath));

  // Initialize ArkhamJS
  Flux.addMiddleware(middleware);

  return store;
};

 (newState: any) => setNewState(isPlainObject(initialState) ? merge(state, newState) : newState)

let _merge = require('lodash/merge');

let common = require('./config.json');

let config = null;
if (ENV === 'production') {
  config = _merge({}, common, require('./config.production.json'));
} else {
  config = _merge({}, common, require('./config.local.json'))
}


export let Config = config;

 return function makeThemeVars<T extends object>(subElementName: string, declaredVars: T): T {
     const subcomponentVars = (componentVars && componentVars[subElementName]) || {};
     return merge(declaredVars, normalizeVariables(subcomponentVars));
 };