const { utils: coinUtils } = require('@lamassu/coins')
const _ = require('lodash/fp')
const ccxt = require('ccxt')
const mem = require('mem')

const { buildMarket, ALL, isConfigValid } = require('../common/ccxt')
const { ORDER_TYPES } = require('./consts')
const logger = require('../../logger')
const { currencies } = require('../../new-admin/config')
const T = require('../../time')

const DEFAULT_PRICE_PRECISION = 2
const DEFAULT_AMOUNT_PRECISION = 8

function trade(side, account, tradeEntry, exchangeName) {
  const { cryptoAtoms, cryptoCode: _cryptoCode, tradeId } = tradeEntry
  try {
    const cryptoCode = coinUtils.getEquivalentCode(_cryptoCode)
    const exchangeConfig = ALL[exchangeName]
    if (!exchangeConfig) throw Error('Exchange configuration not found')

    const {
      USER_REF,
      loadOptions,
      loadConfig = _.noop,
      REQUIRED_CONFIG_FIELDS,
      ORDER_TYPE,
      AMOUNT_PRECISION,
    } = exchangeConfig
    if (!isConfigValid(account, REQUIRED_CONFIG_FIELDS))
      throw Error('Invalid config')

    const selectedFiatMarket = account.currencyMarket
    const symbol = buildMarket(selectedFiatMarket, cryptoCode, exchangeName)
    const precision = _.defaultTo(DEFAULT_AMOUNT_PRECISION, AMOUNT_PRECISION)
    const amount = coinUtils.toUnit(cryptoAtoms, cryptoCode).toFixed(precision)
    const accountOptions = _.isFunction(loadOptions) ? loadOptions(account) : {}
    const withCustomKey = USER_REF ? { [USER_REF]: tradeId } : {}
    const options = _.assign(accountOptions, withCustomKey)
    const exchange = new ccxt[exchangeName](loadConfig(account))

    if (ORDER_TYPE === ORDER_TYPES.MARKET) {
      return exchange.createOrder(
        symbol,
        ORDER_TYPES.MARKET,
        side,
        amount,
        null,
        options,
      )
    }

    return exchange.fetchOrderBook(symbol).then(orderBook => {
      const price = calculatePrice(side, amount, orderBook).toFixed(
        DEFAULT_PRICE_PRECISION,
      )
      return exchange.createOrder(
        symbol,
        ORDER_TYPES.LIMIT,
        side,
        amount,
        price,
        options,
      )
    })
  } catch (e) {
    return Promise.reject(e)
  }
}

function calculatePrice(side, amount, orderBook) {
  const book = side === 'buy' ? 'asks' : 'bids'
  let collected = 0.0
  for (const entry of orderBook[book]) {
    collected += parseFloat(entry[1])
    if (collected >= amount) return parseFloat(entry[0])
  }
  throw new Error('Insufficient market depth')
}

function _getMarkets(exchangeName, availableCryptos) {
  const prunedCryptos = _.compose(
    _.uniq,
    _.map(coinUtils.getEquivalentCode),
  )(availableCryptos)

  try {
    const exchange = new ccxt[exchangeName]()
    const cryptosToQuoteAgainst = ['USDT']
    const currencyCodes = _.concat(
      _.map(it => it.code, currencies),
      cryptosToQuoteAgainst,
    )

    return exchange
      .fetchMarkets()
      .then(_.filter(it => it.type === 'spot' || it.spot))
      .then(res =>
        _.reduce(
          (acc, value) => {
            if (
              _.includes(value.base, prunedCryptos) &&
              _.includes(value.quote, currencyCodes)
            ) {
              if (value.quote === value.base) return acc

              if (_.isNil(acc[value.quote])) {
                return { ...acc, [value.quote]: [value.base] }
              }

              acc[value.quote].push(value.base)
            }
            return acc
          },
          {},
          res,
        ),
      )
  } catch (e) {
    logger.debug(`No CCXT exchange found for ${exchangeName}. ${e}`)
  }
}

const getMarkets = mem(_getMarkets, {
  maxAge: T.week,
  cacheKey: exchangeName => exchangeName,
})

module.exports = { trade, getMarkets }