export const strategyLoader = (strategyName: string) => {
  try {
    if (strategyName === null || strategyName === undefined || !strategyName.length) throw new Error('No strategy given.')
    logger.verbose(`Loading ${strategyName}....`)
    const strategyModule = require(`./${strategyName}`)
    if (!strategyModule.strategy) throw Error("Wrong exported strategy. Export Strategy as field 'strategy'.")
    logger.silly(`Loaded ${strategyName} successfully.`)
    return strategyModule.strategy
  } catch (e) {
    throw new Error(`Strategy-Module ${strategyName} has thrown an error when loaded! Error-Message: ${e}`)
  }
}

  public async fetchTicker(symbol: string) {
    const fn = () => this.exchangeConnection.fetchTicker(symbol)
    const res = await this.bottleneck.schedule(fn)

    const debug = { name: 'fetchTicker', req: { symbol }, res }
    logger.debug(JSON.stringify(debug))

    return res
  }

  public async cancelOrder(orderId: string) {
    const fn = () => this.exchangeConnection.cancelOrder(orderId)
    const res = await this.bottleneck.schedule(fn)

    const debug = { name: 'cancelOrder', req: { orderId }, res }
    logger.debug(JSON.stringify(debug))

    return res
  }

  public async checkOrder(orderId: string): Promise<OrderWithTrades> {
    const fn = () => this.exchangeConnection.fetchOrder(orderId)
    const res: any = await this.bottleneck.schedule(fn)

    const debug = { name: 'checkOrder', req: { orderId }, res }
    logger.debug(JSON.stringify(debug))

    return res
  }

  public async createOrder(symbol: string, type: string, side: string, amount: number, price: number): Promise<Order> {
    const fn = () => this.exchangeConnection.createOrder(symbol, type, side, amount, price)
    const res = await this.bottleneck.schedule(fn)

    const debug = { name: 'createOrder', req: { symbol, type, side, amount, price }, res }
    logger.debug(JSON.stringify(debug))

    return res
  }

  public async fetchBalance() {
    const fn = () => this.exchangeConnection.fetchBalance()
    const res = await this.bottleneck.schedule(fn)

    const debug = { name: 'fetchBalance', req: {}, res }
    logger.debug(JSON.stringify(debug))

    return res
  }

const run = async () => {
  try {
    logger.info('Starting magic8bot...')

    await dbDriver.connect('mongo')

    wsServer.init()
    await server.init()
    await core.init()
  } catch (e) {
    console.error(e)
  }
}

 public error(error: string) {
   logger.error(error)
   return { error: `Core Error: ${error}` }
 }