import os, algorithm, parseopt2, times, strutils, sequtils
import exchange, bittrexSimulator, bittrexReal, technicalAnalysis, candlesMonitor


# KIV
let apikey    = "X"
let apisecret = "Y"
# Nik
#let apikey    = "X2"
#let apisecret = "Y2"

when defined simulate:
  var bittrex = newFakeBittrex(parse("2017-12-12t09:00:00", "yyyy-MM-dd'T'HH:mm:ss") + 5.hours, customMarkets = "btc-1st; btc-ada; btc-adx; btc-ardr; btc-ark; btc-bat; btc-bay; btc-bcc; btc-btg; btc-cfi; btc-cpc; btc-cvc; btc-edg; btc-eng; btc-etc; btc-eth; btc-hmq; btc-lsk; btc-ltc; btc-mco; btc-mue; btc-nav; btc-nbt; btc-neo; btc-nxt; btc-omg; btc-pay; btc-pivx; btc-powr; btc-qtum; btc-rcn; btc-rep; btc-rise; btc-salt; btc-strat; btc-sys; btc-trig; btc-unb; btc-vox; btc-vtc; btc-waves; btc-wings; btc-xem; btc-xlm; btc-xmr; btc-xrp; btc-xzc")
else:
  var bittrex = newBittrex(apikey, apisecret)
proc trader(monitor: CandlesMonitor)

var
  order: Order
  buyRate, sellRate: float
  needSell: bool
  bitcoin, altcoin: float

proc updateBalances() =
  GC_fullCollect()
  let response = bittrex.getBalances()
  for i in response:
    if i.currency == "btc":
      bitcoin = i.balance
    if monitors.len > 0 and needSell and (order.marketName.split('-')[1] == i.currency):
      altcoin = i.balance
  if (bitcoin >= 0.1) and not defined(simulate):
    bitcoin = 0.1

proc updateMonitorsList() =
  GC_fullCollect()
  echo getTime()
  echo "-----------------------------------"
  monitors = newSeq[CandlesMonitor]()
  updateBalances()
  echo "Bitcoin: ", formatFloat(bitcoin, ffDecimal, 8)

  stdout.write "Markets: "
  stdout.flushFile()
  for i in bittrex.getMarketsInfo():
    if i.coin1Name == "btc":# and i.volume > 800.0 and i.last > 0.00001:
      newMonitor(bittrex, i.name, hour, trader)
      stdout.write(i.name & "; ")
      stdout.flushFile()
  echo " (", monitors.len div 2, " markets)"
  #echo "Bittrex's time: ", monitors[0].candles.time[^1]
  echo "-----------------------------------"
  echo getTime()

proc buy(market: CandlesMonitor; price: float) =
  bittrex.cancelOrder(order)
  buyRate = price
  let buyQ = (bitcoin/buyRate) * 0.9975
  order = bittrex.trade(market.name, true, buyRate, buyQ)
  if order.isOpen:
    echo market.candles.time[^1], " buy-order ", market.name, " by ", formatFloat(buyRate, ffDecimal, 8)
  else:
    echo "Can't set buy-order"
    updateBalances()

proc sell(market: string; price: float) =
  bittrex.cancelOrder(order)
  sellRate = price
  order = bittrex.trade(market, false, sellRate, altcoin)
  if order.isOpen:
    echo order.openDate, " sell-order ", market, " by ", formatFloat(sellRate, ffDecimal, 8)
  else:
    echo "Can't set sell-order"
    updateBalances()

proc checkOrder() =
  if order.isOpen:
    bittrex.checkOrder(order)
    if not order.isOpen:
      needSell = not needSell
      echo order.closedDate, " closed "
      #keepIf(monitors, proc(x: CandlesMonitor): bool = x.name == order.marketName)
      updateBalances()
      if not order.buyOrder:
        echo "-----------------------------------"
        #echo "Bitcoin: ", formatFloat(bitcoin, ffDecimal, 8)
        echo order.marketName, " profit: ", formatFloat((sellRate/buyRate)*100-100.5, ffDecimal, 2), '%'
        echo "Tickers skipped: ", monitors[0].skippedCounter
        echo "-----------------------------------"
        #updateMonitorsList()

#########################################################
var counter = 0

if not needSell:
  updateMonitorsList()

while true:
  counter += 1
  #echo counter
  checkOrder()
  when defined simulate:
    candlesMonitor.checkAll(toTime bittrex.time)
    bittrex.sleep(60.seconds)
  else:
    candlesMonitor.checkAll(getTime())
    os.sleep(2500)


proc trader(monitor: CandlesMonitor) =
  if not needSell:
    var candles = monitor.candles

    proc myVolumeIndicator(this: DataProvider; index: int): float =
      if index == 0: return 0.0
      if candles.high[index]-candles.low[index] > 0.00000001:
        return this[index-1] + candles.volume[index]*( (candles.close[index]-candles.open[index]) / (candles.high[index]-candles.low[index]) )
      else:
        return this[index-1]
    var
      myVolume = getCustomIndicator(candles, myVolumeIndicator, "myVolumeIndicator")
      bb = getBollingerBands(myVolume, 50, 5.0)

    proc update5(this: DataProvider; index: int): float =
      if index == 0: return 0.0
      if bb.top[index] < myVolume[index] and bb.bot[index-1] < myVolume[index-1] and bb.top[index-1] > myVolume[index-1]:
        for i in 1..24:
          if this[index-i] > 99.0:
            return 0.0
        return 100.0
      return 0.0

    var result = getCustomIndicator(candles, update5, "result")

    if (result[^1] > 99) and (result[^2] < 99):
      #buy(monitor, candles[^1])
      echo "! " & monitor.name

  if needSell and not order.isOpen:
    let close = monitor.candles[^1]
    sell(order.marketName, buyRate * 1.055)

#[proc trader(monitor: CandlesMonitor) =
  if monitor.interval != oneMin: return
  if not needSell:
    let close = monitor.candles[^1]
    var keltnerBot: float
    for m in monitors:
      if (m.name == monitor.name) and (m.interval == thirtyMin):
        keltnerBot = getKeltnerChannel(m.candles, 50, 5).bot[^1]
    if close <= keltnerBot:
      buy(monitor, close)

  if needSell and not order.isOpen and order.marketName == monitor.name:
    let close = monitor.candles[^1]
    sell(monitor, buyRate * 1.015)]#

#[
proc setSellState(marketName: string) =
  # Оставляем только один маркет, на котором надо продать
  markets = newSeq[Market]()
  markets.add(newMarket(marketName))
  current = markets[0]
  # Отменяем ордер на продажу, если есть
  # TODO
  # Находим инфу по покупке
  let order = getOrderHistory(marketname)[0]
  if (order.exchange == marketName) and (order.orderType == "limit_buy"):
    needSell = true
    buyRate = order.rate
    updateBalance()
    echo "Forced sell: ", current.name, ". Buy rate: ", formatFloat(buyRate, ffDecimal, 8)


###############################################################################

for kind, key, val in getopt():
  if kind == cmdArgument:
    setSellState(key.toLowerAscii)]#