import ccxt
import decimal

def exchange_sum(self, *args):
    return sum([arg for arg in args if isinstance(arg, (float, int, decimal.Decimal))])
ccxt.Exchange.sum = exchange_sum
def poloniex_fetch_balance(self, params={}):
    self.load_markets()
    balances = self.privatePostReturnCompleteBalances(self.extend({
        'account': 'all',
        }, params))
    result = {'info': balances}
    currencies = list(balances.keys())
    for c in range(0, len(currencies)):
        id = currencies[c]
        balance = balances[id]
        currency = self.common_currency_code(id)
        account = {
                'free': decimal.Decimal(balance['available']),
                'used': decimal.Decimal(balance['onOrders']),
                'total': decimal.Decimal(0.0),
                }
        account['total'] = self.sum(account['free'], account['used'])
        result[currency] = account
    return self.parse_balance(result)
ccxt.poloniex.fetch_balance = poloniex_fetch_balance

def poloniex_fetch_balance_per_type(self):
    balances = self.privatePostReturnAvailableAccountBalances()
    result = {'info': balances}
    for key, balance in balances.items():
        result[key] = {}
        for currency, amount in balance.items():
            if currency not in result:
                result[currency] = {}
            result[currency][key] = decimal.Decimal(amount)
            result[key][currency] = decimal.Decimal(amount)
    return result
ccxt.poloniex.fetch_balance_per_type = poloniex_fetch_balance_per_type

def poloniex_parse_ticker(self, ticker, market=None):
    timestamp = self.milliseconds()
    symbol = None
    if market:
        symbol = market['symbol']
    return {
        'symbol': symbol,
        'timestamp': timestamp,
        'datetime': self.iso8601(timestamp),
        'high': decimal.Decimal(ticker['high24hr']),
        'low': decimal.Decimal(ticker['low24hr']),
        'bid': decimal.Decimal(ticker['highestBid']),
        'ask': decimal.Decimal(ticker['lowestAsk']),
        'vwap': None,
        'open': None,
        'close': None,
        'first': None,
        'last': decimal.Decimal(ticker['last']),
        'change': decimal.Decimal(ticker['percentChange']),
        'percentage': None,
        'average': None,
        'baseVolume': decimal.Decimal(ticker['quoteVolume']),
        'quoteVolume': decimal.Decimal(ticker['baseVolume']),
        'info': ticker,
    }
ccxt.poloniex.parse_ticker = poloniex_parse_ticker

def poloniex_create_margin_order(self, symbol, type, side, amount, price=None, lending_rate=None, params={}):
    if type == 'market':
        raise ccxt.ExchangeError(self.id + ' allows limit orders only')
    self.load_markets()
    method = 'privatePostMargin' + self.capitalize(side)
    market = self.market(symbol)
    price = float(price)
    amount = float(amount)
    if lending_rate is not None:
        params = self.extend({"lendingRate": lending_rate}, params)
    response = getattr(self, method)(self.extend({
        'currencyPair': market['id'],
        'rate': self.price_to_precision(symbol, price),
        'amount': self.amount_to_precision(symbol, amount),
    }, params))
    timestamp = self.milliseconds()
    order = self.parse_order(self.extend({
        'timestamp': timestamp,
        'status': 'open',
        'type': type,
        'side': side,
        'price': price,
        'amount': amount,
    }, response), market)
    id = order['id']
    self.orders[id] = order
    return self.extend({'info': response}, order)

def poloniex_create_order(self, symbol, type, side, amount, price=None, account="exchange", lending_rate=None, params={}):
    if account == "exchange":
        return self.create_exchange_order(symbol, type, side, amount, price=price, params=params)
    elif account == "margin":
        return self.create_margin_order(symbol, type, side, amount, price=price, lending_rate=lending_rate, params=params)
    else:
        raise NotImplementedError
ccxt.poloniex.create_exchange_order = ccxt.poloniex.create_order
ccxt.poloniex.create_order = poloniex_create_order

market = ccxt.poloniex({
    "apiKey": "XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX",
    "secret": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
    })