export const clean = (obj) => {
	const nilEmpty: any = R.mapObjIndexed((x , key) => (R.isEmpty(x)) ? undefined : x);
	const nilComputed: any = R.mapObjIndexed((x , key) => (key.indexOf('$') >= 0) ? undefined : x);
	const trimProps = R.map((n: any) => R.is(String, n) ? R.trim(n) : n);
	const cleanNil = R.reject(R.isNil);
	return R.pipe(nilEmpty, nilComputed, trimProps, cleanNil)(obj);
}

export function method<
  ClientsT extends IOClients = IOClients,
  StateT = void,
  CustomT = void
>(options: MethodOptions<ClientsT, StateT, CustomT>) {
  const handlers = mapObjIndexed(
    handler => compose(Array.isArray(handler) ? handler : [handler]),
    options as Record<
      string,
      | RouteHandler<ClientsT, StateT, CustomT>
      | Array<RouteHandler<ClientsT, StateT, CustomT>>
    >
  )

  return async (
    ctx: ServiceContext<ClientsT, StateT, CustomT>,
    next: () => Promise<any>
  ) => {
    const verb = ctx.method.toUpperCase()
    const handler = handlers[verb] || handlers.DEFAULT

    if (handler) {
      await handler(ctx)
    }

    await next()
  }
}

function countPerOrigin (obj: { [key: string]: any[] }) {
  try {
    return mapObjIndexed(val => val.length, obj)
  } catch (_) {
    return {}
  }
}

export const associationDecorator = ({ modelName, fields }: { modelName: string; fields }) => {
  const TAG = '[associationDecorator]';
  logger.log(TAG, { fields });

  // prettier-ignore
  const associationFields = R.filter(R.compose(R.not, R.isNil, R.prop('associations')))(fields);
  logger.log(TAG, { associationFields }, R.not(R.isEmpty(associationFields)));
  if (R.not(R.isEmpty(associationFields))) {
    const wrapForeignOpt = R.map(opt => ({
      ...opt,
      association: AppContext.adapters.models.getAssociationConfigs(opt.modelName),
    }));
    const withAssociations = R.mapObjIndexed(field => ({
      ...field,
      foreignOpts: wrapForeignOpt(field.foreignOpts),
    }))(associationFields);
    logger.debug(TAG, { withAssociations, wrapForeignOpt });

    const wrappedFields = R.mergeDeepRight(fields, withAssociations);
    logger.debug(TAG, { wrappedFields });

    return { modelName, fields: wrappedFields };
  }

  return { modelName, fields };
};

 private overrideConfigKeyFromEnv() {
   this.configMap = R.mapObjIndexed((value: string, key: string, config: any) => {
     if (process.env[key]) {
       config[key] = process.env[key];
     }
     return config[key];
   }, this.configMap);
 }

  /**
   * Convert a object to array
   * @param obj The object to be converted to array
   */
  static toArray(obj) {
    let array = [];
    if (obj) {
      const toArray = R.mapObjIndexed((val, key) => array.push({ $key: key, value: val }));
      const loadArray = toArray(obj)
    }

    return array;
  }

const runTests = <S, F>(
  assert: (
    fixture: ExerciseFixture<S, F>,
    /* tslint:disable-next-line:no-any */
    exercise: AbstractExercise<any, S, F>
  ) => void
) => {
  const resolver = new MockAssetResolver();
  const factory = new EntityFactory(resolver);

  const cases = values(
    mapObjIndexed(
      (
        E: {
          fixtures: Array<ExerciseFixture<S, F>>;
          /* tslint:disable-next-line:no-any */
          new (p: any): AbstractExercise<any, S, F>;
        },
        type
      ) => () => {
        forEach(fixture => {
          try {
            const exercise = factory.createExercise(
              type as ExerciseTypes,
              fixture.props
            );

            // Catch test failures so that we can pass a custom message
            assert(fixture, exercise);
          } catch (e) {
            throw new Error(`${type} › ${fixture.name}:\n${e.message}`);
          }
        }, E.fixtures);
      },
      Exercises
    )
  );

  // Execute the test runners
  forEach(runTestCases => runTestCases(), cases);

  // Check that each test case was run
  const numberOfAssertions = sum(
    values(
      map<
        { [type: string]: { fixtures: Array<ExerciseFixture<S, F>> } },
        { [type: string]: number }
      >(
        (E: { fixtures: Array<ExerciseFixture<S, F>> }) => E.fixtures.length,
        Exercises
      )
    )
  );
  expect.assertions(numberOfAssertions);
};

let transformReq = curryN(2, (req: Request, multipart: boolean) => ifElse(
  () => multipart,
  pipe<any, any, any, any>(
    mapObjIndexed((v: any, k: string) => v
      ? req[propOr(false, 'path', v) ? 'attach' : 'field'](k, v)
      : req),
    values,
    last
  ),
  req.send.bind(req)
))

 /**
  * Return a clean part of the model for updating to database
  */
 static clean(model) {
   const removeComputedProps = R.pipe(
     R.mapObjIndexed((x , key) => {
       if (key.indexOf('$') >= 0) { return undefined }
       return x;
     }),
     R.reject(R.isNil)
   );
   const trimValues = R.map(n => { return R.is(String, n) ? R.trim(n) : n });
   const removeNullFields = R.reject(R.isNil)
   return R.pipe(removeComputedProps, trimValues, removeNullFields)(model);
 }

], (active, byName) => {
    // TODO We might want to use the selected preset values (pass from host frame or content canvas) instead of individual dimension values
    if (active !== null) {
        return mapObjIndexed((dimensionValues, name) => {
            const dimensionConfiguration = byName[name];
            const presets = dimensionConfiguration.presets;
            const activePreset = Object.keys(presets).find(dimensionName => presets[dimensionName].values === dimensionValues);
            const presetName = activePreset || dimensionConfiguration.defaultPreset;
            const finalActivePreset = presets[presetName];
            return Object.assign({}, finalActivePreset, {name: presetName});
        }, active);
    }
    return {};
});

  function telegramDriver (sourceRequest: Observable<Observable<DriverSink>>, runSA: StreamAdapter): DriverExecution {
    let adapt = adapter(runSA)
    let request = sourceRequest.map(x => convertStream(x, runSA, RxAdapter))

    if (isWebhookResponse(request, options)) {
      handleWebhook(token, request, proxyWebHook)
    }

    let responses = handleRequest(token, request as Observable<Observable<TcombRequest>>).share()
    responses.subscribeOnError((err: any) => console.error('request error: ', err))

    return Object.assign(
      {
        token,
        dispose: () => disposable.dispose()
      },
      mapObjIndexed(adapt, {
        events: makeEventsSelector(sources),
        updates,
        responses
      })) as DriverExecution
  }