import asyncio

class Hige:
  def __init__(self, logger, pair, lot):
    self._logger = logger
    self._pair   = pair
    self._lot    = lot

    self._remain = 0

    self._sell = None
    self._buy  = None

    self._sell_price = 0
    self._buy_price  = 0

    self._total = 0

    asyncio.create_task(self._main())

  async def _main(self):
    self._logger.info("started")
    while True:
      pair  = self._pair
      depth = pair.depth

      if len(depth.bids) == 0 or len(depth.asks) == 0:
        await depth.wait()
        continue

      vol_per_sec = pair.ticker.volume / 24 / 3600
      delta       = 0.001 * pair.ticker.price

      expected_sell_price = depth.asks[0][0] + delta
      expected_buy_price  = depth.bids[0][0] - delta

      if self._sell is not None:
        await asyncio.sleep(0.5)
        await self._sell.update()
        if self._sell.done:
          amount = self._sell.amount - self._sell.remain
          if amount > 0:
            income       = amount*self._sell.price
            self._total += income
            self._logger.info(f"<SELL> {amount} / {income} ({self._total})")
          self._remain -= amount
          self._sell    = None
          continue
        elif self._sell_price != expected_sell_price:
          await self._sell.cancel()
          continue
      elif self._remain >= self._lot*2:
        self._sell_price = expected_sell_price
        self._sell = await pair.sell_limit(self._lot, self._sell_price)

      if self._buy is not None:
        await asyncio.sleep(0.5)
        await self._buy.update()
        if self._buy.done:
          amount = self._buy.amount - self._buy.remain
          if amount > 0:
            outgo        = amount*self._buy.price
            self._total -= outgo
            self._logger.info(f"<BUY> {amount} / {outgo} ({self._total})")
          self._remain += amount
          self._buy     = None
          continue
        elif self._buy_price != expected_buy_price:
          await self._buy.cancel()
          continue
      elif self._remain <= self._lot*3:
        self._buy_price = expected_buy_price
        self._buy = await pair.buy_limit(self._lot, self._buy_price)
      await asyncio.sleep(5)