/**
  * Given a path somewhere within the tree, list the keys found if it is an object.
  *
  * @param command The command received from the reactotron app.
  */
 function requestKeys(command: any) {
   const trackedNode = trackedNodes[command.mstNodeName || "default"]
   const atPath: string = (command && command.payload && command.payload.path) || []
   if (trackedNode && trackedNode.node && atPath) {
     const state = getSnapshot(trackedNode.node)
     if (isNilOrEmpty(atPath)) {
       reactotron.stateKeysResponse(null, keys(state))
     } else {
       const keyList = keys(dotPath(atPath, state))
       reactotron.stateKeysResponse(atPath, keyList)
     }
   }
 }

const extractSchemaMetaData = (typeDefs: string) => {
  if (!cache.schemaMetaData) {
    const scalars = keys(scalarResolversMap)
    const scalarsPresentInSchema = map(hasScalar(typeDefs), scalars)
    cache.schemaMetaData = zipObj(scalars, scalarsPresentInSchema)
  }
  return cache.schemaMetaData
}

 /**
  * Return a immutable model
  * @param model An object with key value pair
  */
 static getImmutableModel(model) {
   let newModel: any = { };
   const getFields = R.keys();
   const assignFields = field => newModel[field] = model[field];
   const prepareModel = R.pipe(getFields, R.forEach(assignFields));
   prepareModel(model);
   return newModel;
 }

export const initAll = (element: any): any => {
  if (Array.isArray(element)) {
    return init(element);
    // Check for length of Object.keys, because Dates and null are objects too
  } else if (typeof element === 'object' && keys(element).length > 0) {
    return map(initAll, element);
  }
  return element;
};

 constructor(operator$: Stream<string>) {
   const xs = Stream;
   operator$.addListener(dummyListener);
   this.operator$ =
     operator$
       .map(operator => xs.of(operators[operator]))
       .flatten();
   this.operators$ =
     xs.of(keys(operators)).remember();
 }

export function getPidByPidCode (pidstring: string) : PID|null {
  let names:Array<string> = keys(PIDS);

  let pidname:string = find((name:string) => {
    let curpid:PID = PIDS[name];

    return curpid.getPid() === pidstring;
  })(names);

  if (pidname) {
    return PIDS[pidname];
  } else {
    return null;
  }
};

 fields.forEach(field => {
   if (!toFilter) {
     if (R.is(Object, field)) {
       const key = R.head(R.keys(field));
       const value = R.values(field);
       if (key === 'eq') {
         toFilter = (obj[value] === query);
       }
     } else {
       if (!R.isNil(obj[field])) {
         toFilter = obj[field].toString()
           .toLowerCase().indexOf(query) > -1
       }
     }
   }
 });

function recordTimings(start: [number, number], name: string, timings: Record<string, [number, number]>, middlewareMetrics: Record<string, [number, number]>) {
  // Capture the total amount of time spent in this middleware
  const end = process.hrtime(start)
  timings[name] = end
  const label = `middleware-${name}`
  metrics.batch(label, end)

  // This middleware has added it's own metrics
  // Just add them to `timings` scoped by the middleware's name and batch them
  const middlewareMetricsKeys: string[] = keys(middlewareMetrics) as string[]
  if (middlewareMetricsKeys.length > 0) {
    forEach((k: string) => {
      const metricEnd = middlewareMetrics[k]
      const metricName = `${label}-${k}`
      timings[metricName] = metricEnd
      metrics.batch(metricName, metricEnd)
    }, middlewareMetricsKeys)
  }
}

export const nativeTypeDefs = (metaData: SchemaMetaData) => reduce(
  (acc, scalar) => !metaData[scalar] ? `${acc}\nscalar ${scalar}\n` : acc,
  '',
  keys(scalarResolversMap)
)

export const process = (user: User): User => {
	return Object.assign({ }, user, {
		$tenants: R.keys(user.tenants),
	});
}