#!/usr/bin/env python3
"""
ShitcoinBTC exchange — CCXT-compatible client (ccxt 4.x).

Implements the standard CCXT Exchange interface against the ShitcoinBTC
Exchange REST API v1 (https://shitcoinbtc.xyz/api/v1). Drop-in familiar
for anyone who has used ccxt with Binance/Kraken/etc:

    from shitcoinbtc_ccxt import shitcoinbtc

    ex = shitcoinbtc({
        'apiKey': 'scb_live_...',      # optional for public-only use
        'secret': 'scbsk_...',         # optional for public-only use
    })
    print(ex.fetch_ticker('BTC/USDT'))
    print(ex.fetch_balance())
    order = ex.create_order('BTC/USDT', 'limit', 'buy', 0.001, 80000)
    ex.cancel_order(order['id'], 'BTC/USDT')

Requires the `ccxt` package (pip install ccxt). No other dependencies.
Full REST reference: https://shitcoinbtc.xyz/api-docs
"""
import hashlib
import hmac

import ccxt
from ccxt.base.decimal_to_precision import DECIMAL_PLACES
from ccxt.base.types import Entry
from ccxt.base.errors import (
    AuthenticationError, BadRequest, ExchangeError, RateLimitExceeded,
)


class shitcoinbtc(ccxt.Exchange):
    # Implicit REST endpoints (ccxt 4.x Entry descriptors).
    publicGetMarkets = Entry('markets', 'public', 'GET', {'cost': 1})
    publicGetTicker = Entry('ticker', 'public', 'GET', {'cost': 1})
    publicGetOrderbook = Entry('orderbook', 'public', 'GET', {'cost': 1})
    publicGetTrades = Entry('trades', 'public', 'GET', {'cost': 1})
    privateGetAccount = Entry('account', 'private', 'GET', {'cost': 1})
    privateGetOrder = Entry('order', 'private', 'GET', {'cost': 1})
    privateGetOrders = Entry('orders', 'private', 'GET', {'cost': 1})
    privateGetOrdersHistory = Entry('orders/history', 'private', 'GET', {'cost': 1})
    privateGetTradesMine = Entry('trades/mine', 'private', 'GET', {'cost': 1})
    privateGetKeys = Entry('keys', 'private', 'GET', {'cost': 1})
    privatePostOrder = Entry('order', 'private', 'POST', {'cost': 1})
    privatePostKeys = Entry('keys', 'private', 'POST', {'cost': 1})
    privateDeleteOrder = Entry('order', 'private', 'DELETE', {'cost': 1})
    privateDeleteOrders = Entry('orders', 'private', 'DELETE', {'cost': 1})
    privateDeleteKeys = Entry('keys', 'private', 'DELETE', {'cost': 1})

    def describe(self):
        return self.deep_extend(super().describe(), {
            'id': 'shitcoinbtc',
            'name': 'ShitcoinBTC Exchange',
            'countries': ['US'],
            'rateLimit': 200,  # ms between requests (polite default)
            'version': 'v1',
            # Our market precision is "8 decimals", not a tick size.
            'precisionMode': DECIMAL_PLACES,
            'has': {
                'fetchMarkets': True,
                'fetchTicker': True,
                'fetchOrderBook': True,
                'fetchTrades': True,
                'fetchBalance': True,
                'createOrder': True,
                'cancelOrder': True,
                'cancelAllOrders': True,
                'fetchOrder': True,
                'fetchOpenOrders': True,
                'fetchOrders': True,       # order history
                'fetchMyTrades': True,
            },
            'urls': {
                'api': {
                    'public': 'https://shitcoinbtc.xyz/api/v1',
                    'private': 'https://shitcoinbtc.xyz/api/v1',
                },
                'www': 'https://shitcoinbtc.xyz',
                'doc': 'https://shitcoinbtc.xyz/api-docs',
            },
            'timeframes': {},
            'exceptions': {
                'auth_required': AuthenticationError,
                'auth_failed': AuthenticationError,
                'rate_limited': RateLimitExceeded,
                'invalid_symbol': BadRequest,
                'invalid_number': BadRequest,
                'invalid_side': BadRequest,
                'invalid_tif': BadRequest,
                'invalid_limit': BadRequest,
                'invalid_id': BadRequest,
                'invalid_since': BadRequest,
                'invalid_name': BadRequest,
                'invalid_permissions': BadRequest,
                'invalid_key_id': BadRequest,
                'dust_order': BadRequest,
                'unsupported_type': BadRequest,
                'insufficient_funds': ccxt.InsufficientFunds,
                'not_found': ccxt.OrderNotFound,
                'not_open': ccxt.InvalidOrder,
                'cancel_failed': ExchangeError,
                'forbidden': ccxt.PermissionDenied,
            },
        })

    # ------------------------------------------------------------------ sign
    def sign(self, path, api='public', method='GET', params={},
             headers=None, body=None):
        base = self.urls['api'][api].rstrip('/')
        url = base + '/' + path
        headers = dict(headers) if headers else {}
        query = ''
        raw_body = ''
        if method == 'GET':
            if params:
                query = self.urlencode(params)
                url += '?' + query
        else:
            if params:
                raw_body = self.json(params)
        headers['Content-Type'] = 'application/json'
        if api == 'private':
            if self.apiKey and self.secret:
                # HMAC path. Signed payload, five \n-separated lines:
                #   timestamp \n METHOD \n /api/v1/<path> \n <query> \n <body>
                timestamp = str(self.milliseconds())
                payload = '\n'.join([timestamp, method.upper(),
                                     '/api/v1/' + path, query, raw_body])
                signature = hmac.new(self.secret.encode('utf-8'),
                                     payload.encode('utf-8'),
                                     hashlib.sha256).hexdigest()
                headers['X-API-KEY'] = self.apiKey
                headers['X-API-TIMESTAMP'] = timestamp
                headers['X-API-SIGN'] = signature
            elif 'X-User-Token' not in headers:
                raise AuthenticationError(
                    'shitcoinbtc requires apiKey + secret, or a session '
                    'token passed as the X-User-Token header')
        return {'url': url, 'method': method,
                'body': raw_body if raw_body else None, 'headers': headers}

    def handle_errors(self, statusCode, statusText, url, method,
                      responseHeaders, responseBody, response,
                      requestHeaders, requestBody):
        if response is None:
            return None
        if isinstance(response, dict) and response.get('ok') is False:
            err = response.get('error', 'exchange_error')
            msg = response.get('message') or err
            exc = self.exceptions.get(err, ExchangeError)
            raise exc(msg)
        return None

    def _unwrap(self, response, key):
        if not isinstance(response, dict) or not response.get('ok'):
            raise ExchangeError('Unexpected API response: %s' % str(response)[:200])
        return response[key]

    # ------------------------------------------------------------------ public
    def fetch_markets(self, params={}):
        response = self.publicGetMarkets(params)
        return [self.parse_market(m) for m in self._unwrap(response, 'markets')]

    def parse_market(self, market):
        return market  # already CCXT-shaped

    def fetch_ticker(self, symbol, params={}):
        self.load_markets()
        market = self.market(symbol)
        response = self.publicGetTicker(self.extend(
            {'symbol': market['symbol']}, params))
        return self.parse_ticker(self._unwrap(response, 'ticker'), market)

    def parse_ticker(self, ticker, market=None):
        return ticker  # already CCXT-shaped

    def fetch_order_book(self, symbol, limit=None, params={}):
        self.load_markets()
        market = self.market(symbol)
        request = {'symbol': market['symbol']}
        if limit:
            request['limit'] = limit
        response = self.publicGetOrderbook(self.extend(request, params))
        return self.parse_order_book(self._unwrap(response, 'orderbook'),
                                     market['symbol'])

    def fetch_trades(self, symbol, since=None, limit=None, params={}):
        self.load_markets()
        market = self.market(symbol)
        request = {'symbol': market['symbol']}
        if limit:
            request['limit'] = limit
        response = self.publicGetTrades(self.extend(request, params))
        trades = [self.parse_trade(t, market)
                  for t in self._unwrap(response, 'trades')]
        return self.filter_by_since_limit(trades, since, limit)

    def parse_trade(self, trade, market=None):
        return trade  # already CCXT-shaped

    # ------------------------------------------------------------------ private
    def fetch_balance(self, params={}):
        response = self.privateGetAccount(params)
        return self.parse_balance(self._unwrap(response, 'balance'))

    def parse_balance(self, balance):
        # Already CCXT-shaped by the API; normalize defensively.
        result = {'info': self.safe_value(balance, 'info', {})}
        for key in ('free', 'used', 'total'):
            result[key] = self.safe_value(balance, key, {})
        result['timestamp'] = self.safe_integer(balance, 'timestamp')
        result['datetime'] = self.safe_string(balance, 'datetime')
        return result  # already CCXT-shaped; safe_balance() would misread it

    def create_order(self, symbol, type, side, amount, price=None, params={}):
        self.load_markets()
        market = self.market(symbol)
        if type != 'limit':
            raise BadRequest('shitcoinbtc API v1 supports limit orders only')
        if price is None:
            raise BadRequest('limit orders require a price')
        request = {
            'symbol': market['symbol'],
            'side': side,
            'type': 'limit',
            'amount': self.amount_to_precision(symbol, amount),
            'price': self.price_to_precision(symbol, price),
        }
        tif = self.safe_string(params, 'timeInForce')
        if tif:
            request['timeInForce'] = tif
            params = self.omit(params, 'timeInForce')
        response = self.privatePostOrder(self.extend(request, params))
        return self.parse_order(self._unwrap(response, 'order'), market)

    def cancel_order(self, id, symbol=None, params={}):
        response = self.privateDeleteOrder(self.extend({'id': id}, params))
        data = self._unwrap(response, 'cancelled')
        return {'id': str(data), 'info': response}

    def cancel_all_orders(self, symbol=None, params={}):
        request = {}
        if symbol:
            self.load_markets()
            request['symbol'] = self.market(symbol)['symbol']
        response = self.privateDeleteOrders(self.extend(request, params))
        return self._unwrap(response, 'cancelled')

    def fetch_order(self, id, symbol=None, params={}):
        response = self.privateGetOrder(self.extend({'id': id}, params))
        return self.parse_order(self._unwrap(response, 'order'))

    def fetch_open_orders(self, symbol=None, since=None, limit=None, params={}):
        request = self._orders_request(symbol, since, limit, params)
        response = self.privateGetOrders(request)
        orders = [self.parse_order(o)
                  for o in self._unwrap(response, 'orders')]
        return self.filter_by_since_limit(orders, since, limit)

    def fetch_orders(self, symbol=None, since=None, limit=None, params={}):
        # order history
        request = self._orders_request(symbol, since, limit, params)
        response = self.privateGetOrdersHistory(request)
        orders = [self.parse_order(o)
                  for o in self._unwrap(response, 'orders')]
        return self.filter_by_since_limit(orders, since, limit)

    def fetch_my_trades(self, symbol=None, since=None, limit=None, params={}):
        request = self._orders_request(symbol, since, limit, params)
        response = self.privateGetTradesMine(request)
        trades = [self.parse_trade(t)
                  for t in self._unwrap(response, 'trades')]
        return self.filter_by_since_limit(trades, since, limit)

    def _orders_request(self, symbol, since, limit, params):
        request = {}
        if symbol:
            self.load_markets()
            request['symbol'] = self.market(symbol)['symbol']
        if since:
            request['since'] = since
        if limit:
            request['limit'] = limit
        return self.extend(request, params)

    def parse_order(self, order, market=None):
        return order  # already CCXT-shaped

    # ------------------------------------------------------------------ keys
    def create_api_key(self, name, permissions='trade', session_token=None):
        """Create an API key. Needs a web session token (from /api/user/login)."""
        headers = {'X-User-Token': session_token} if session_token else None
        response = self.request('keys', 'private', 'POST',
                                {'name': name, 'permissions': permissions},
                                headers)
        return self._unwrap(response, 'key')

    def fetch_api_keys(self, session_token=None):
        headers = {'X-User-Token': session_token} if session_token else None
        response = self.request('keys', 'private', 'GET', {}, headers)
        return self._unwrap(response, 'keys')

    def revoke_api_key(self, key_id, session_token=None):
        headers = {'X-User-Token': session_token} if session_token else None
        response = self.request('keys', 'private', 'DELETE',
                                {'key_id': key_id}, headers)
        return self._unwrap(response, 'revoked')


if __name__ == '__main__':
    # Smoke test against the live API (public endpoints need no key).
    ex = shitcoinbtc({'enableRateLimit': True})
    print('markets:', len(ex.fetch_markets()))
    print('ticker:', ex.fetch_ticker('BTC/USDT')['last'])
    book = ex.fetch_order_book('BTC/USDT')
    print('book bids/asks:', len(book['bids']), len(book['asks']))
    print('recent trades:', len(ex.fetch_trades('BTC/USDT')))
