from threading import Thread
from itertools import accumulate
import time

def proper_round(x, precision):
    return float(f"%.{precision}f" % round(x, precision))

def str_round(x, precision):
    return f"%.{precision}f" % round(x, precision)


class MarketMaking:
    def __init__(self, cooldown = 2.5, ema_gamma = 0., prev_mid = 0):
        self.cooldown = cooldown
        self.params = []
        self.ema_gamma = 0.0
        self.prev_mid = prev_mid
        self.zi = 0

    def log(self, params, name, obj):
        params['log'].write(f'{int(time.time() * 1000)} {name} {obj}\n')
        params['log'].flush()

    def make_zone(self,
                  bound = 1500,
                  total_base = None,
                  total_quote = None,
                  qty_step = 2000,
                  n_levels = 20,
                  protection = False
                  ):
        zone = {}
        zone['zone'] = float(bound)
        zone['n_levels'] = int(n_levels)
        zone['total_base'] = float(total_base) if total_base != None else None
        zone['total_quote'] = float(total_quote) if total_quote != None else None
        zone['protection'] = bool(protection)
        zone['qty_step'] = float(qty_step) / 10000
        return zone

    # def add_market(self, market, levels, margins, bal_cut, zero_pos, min_bal, n_sup=4, ask_sup_cut=0.05, bid_sup_cut=0.05, cancel_on_start=False, ask_bal_cut=None, bid_bal_cut=None):
    def add_market(self,
                   market,
                   spread_size = 200,
                   zero_base = None,
                   zero_quote = None,
                   taker_buyback_price = None,
                   taker_buyback_funds = 0,
                   drop_base_offset = 0,
                   drop_quote_offset = 0,
                   ask_zones = [],
                   bid_zones = [],
                   cancel_on_start = False,
                   retain = False):
        params = {}
        info = market.get_info()
        if len(ask_zones) == 0:
            ask_zones = [self.make_zone(total_base = info['balance']['base'] * 0.2)]
        if len(bid_zones) == 0:
            bid_zones = [self.make_zone(total_quote = info['balance']['quote'] * 0.2)]
        ask_zones = sorted(ask_zones, key = lambda x: x['zone'])
        bid_zones = sorted(bid_zones, key = lambda x: x['zone'])
        params['market'] = market

        add = spread_size // 2
        params['min_order_size'] = 5 # todo: заполнять начать
        params['retain'] = retain
        params['drop_base_offset'] = params['min_pos_base'] = drop_base_offset
        params['taker_buyback_price'] = taker_buyback_price
        params['taker_buyback_funds'] = taker_buyback_funds
        params['total_sell_base'] = 0
        sm = 0
        for zone in ask_zones:
            zone['total_base'] -= sm
            sm += zone['total_base']
            if not 'protection' in zone or zone['protection'] != True:
                params['min_pos_base'] += zone['total_base']
                params['total_sell_base'] += zone['total_base']
            print(zone['total_base'])
            zone['min_level_base'] = zone['total_base'] / (zone['n_levels'] * (1 + zone['qty_step'] * (zone['n_levels'] - 1) / 2))
            zone['price_step'] = (zone['zone'] - add + spread_size) // zone['n_levels']
            zone['levels'] = [add + zone['price_step'] * i for i in range(zone['n_levels'])]
            zone['prev'] = [0 for lvl in zone['levels']]
            zone['margins'] = [zone['price_step'] // 2 for i in range(zone['n_levels'])]
            add = zone['zone'] + zone['price_step']
        if zero_base == None or zero_base == 0:
            zero_base = info['balance']['base']
        params['zero_base'] = zero_base
        params['ask_zones'] = ask_zones
        params['stopped'] = False

        add = spread_size // 2
        params['drop_quote_offset'] = params['max_pos_quote'] = drop_quote_offset
        params['total_buy_quote'] = 0
        sm = 0
        for zone in bid_zones:
            zone['total_quote'] -= sm
            sm += zone['total_quote']
            if not 'protection' in zone or zone['protection'] != True:
                params['max_pos_quote'] += zone['total_quote']
                params['total_buy_quote'] += zone['total_quote']
            zone['min_level_quote'] = zone['total_quote'] / (zone['n_levels'] * (1 + zone['qty_step'] * (zone['n_levels'] - 1) / 2))
            zone['price_step'] = (zone['zone'] - add + spread_size) // zone['n_levels']
            zone['levels'] = [add + zone['price_step'] * i for i in range(zone['n_levels'])]
            zone['prev'] = [0 for lvl in zone['levels']]
            zone['margins'] = [zone['price_step'] // 2 for i in range(zone['n_levels'])]
            if add == spread_size // 2:
                zone['margins'][0] = 0
            add = zone['zone'] + zone['price_step']
        if zero_quote == None or zero_quote == 0:
            zero_quote = info['balance']['quote']
        params['zero_quote'] = zero_quote
        params['bid_zones'] = bid_zones
        params['cnt'] = 0

        params['cancel_on_start'] = cancel_on_start
        params['log'] = open(f"/mnt/mm_telemetry/{market.symbol[1].upper()}_{market.symbol[2].upper()}_{market.market}", "a")
        self.log(params, "alert", {'op': 'start'})
        self.params.append(params)

    def build_grid(self, params, mid_price):
        info = params['market'].get_info()
        self.log(params, 'book', info['book'])
        self.log(params, 'balance', info['balance'])
        #print(info)
        print(f'{params['market'].market}: cur balances: {info['balance']}, zero base: {params['zero_base']}, zero quote: {params['zero_quote']}')
        print(f'mid price: {mid_price}')
        precision = params['market'].symbol[3]
        real_ask = info['book']['ask_price']
        real_bid = info['book']['bid_price']
        if real_ask == 0:
            real_ask = mid_price
        # ask_mid = max(mid_price, real_bid)
        # bid_mid = min(mid_price, real_ask)
        # print(f'ask_mid={ask_mid} bid_mid={bid_mid}')

        price_step = proper_round(0.1 ** precision, precision)
        asks = []
        bids = []

        base_balance = info['balance']['base']
        quote_balance = info['balance']['quote']
        ask_bound = bid_bound = mid_price
        cur_pos_base = (base_balance - params['zero_base'])
        print(f'{cur_pos_base} ~~~ {-params['min_pos_base']}')
        if cur_pos_base < -params['min_pos_base']:
            params['stopped'] = True
            self.log(params, 'alert', {'op': 'stop'})
            raise Exception(f"{params['market'].market} stopped")

        cur_pos_quote = (params['zero_quote'] - quote_balance)
        print(f'{cur_pos_quote} -- {params['max_pos_quote']}')
        if cur_pos_quote > params['max_pos_quote']:
            params['stopped'] = True
            self.log(params, 'alert', {'op': 'stop'})
            raise Exception(f"{params['market'].market} stopped")

        bound = mid_price
        if base_balance > params['zero_base'] + 1 / mid_price:
            bound = ask_bound = max(mid_price, (params['zero_quote'] - quote_balance) / (base_balance - params['zero_base']))
        elif base_balance < params['zero_base'] - 1 / mid_price:
            bound = bid_bound = min(mid_price, (quote_balance - params['zero_quote']) / (params['zero_base'] - base_balance))
        print(f'ask_bound={ask_bound} bid_bound={bid_bound} <<<<<<')
        position_info = {'bound': bound, 'zero_base': params['zero_base'], 'zero_quote': params['zero_quote']}
        self.log(params, 'position', position_info)

        available_sell = []
        cur_total_sell = max(0, params['total_sell_base'] + min(0, cur_pos_base + params['drop_base_offset']))
        sell_coef = cur_total_sell / params['total_sell_base']
        norm_coef = min(base_balance, cur_total_sell) / cur_total_sell
        for zone in reversed(params['ask_zones']):
            # if zone['protection']:
            #     delta = zone['total_base']
            # else:
            #     delta = min(cur_total_sell, zone['total_base'])
                # cur_total_sell -= delta
            available_sell.append(zone['total_base'])
        available_sell = list(reversed(available_sell))

        zi = 0
        for zone in params['ask_zones']:
            min_qty = zone['min_level_base']
            qty_step = zone['qty_step']
            if min_qty * zone['n_levels'] >= available_sell[zi]:
                min_qty = available_sell[zi] / zone['n_levels']
                qty_step = 0
            else:
                qty_step = (available_sell[zi] / (min_qty * zone['n_levels']) - 1) * 2 / (zone['n_levels'] - 1)
            for i in range(zone['n_levels']):
                suggest_ask = proper_round(mid_price * (1 + zone['levels'][i] / 10000), precision)
                if abs(zone['prev'][i] / suggest_ask - 1) <= zone['margins'][i] / 10000:
                    suggest_ask = zone['prev'][i]
                if len(asks) > 0 and asks[-1][0] >= suggest_ask:
                    suggest_ask = asks[-1][0] + price_step
                zone['prev'][i] = suggest_ask
                qty = min_qty * (1 + i * qty_step) * norm_coef
                if not zone['protection']:
                    qty *= sell_coef
                asks.append([float(str_round(suggest_ask, precision)), qty])

            zi += 1

        available_buy = []
        cur_total_buy = params['total_buy_quote'] - max(0, cur_pos_quote - params['drop_quote_offset'])
        buy_coef = cur_total_buy / params['total_buy_quote']
        norm_coef = min(quote_balance, cur_total_buy) / cur_total_buy
        for zone in reversed(params['bid_zones']):
            # if zone['protection']:
            #     delta = zone['total_quote']
            # else:
            #     delta = min(cur_total_buy, zone['total_quote'])
            #     cur_total_buy -= delta
            available_buy.append(zone['total_quote'])
        available_buy = list(reversed(available_buy))

        zi = 0
        for zone in params['bid_zones']:
            min_qty = zone['min_level_quote']
            qty_step = zone['qty_step']
            if min_qty * zone['n_levels'] >= available_buy[zi]:
                min_qty = available_buy[zi] / zone['n_levels']
                qty_step = 0
            else:
                qty_step = (available_buy[zi] / (min_qty * zone['n_levels']) - 1) * 2 / (zone['n_levels'] - 1)

            for i in range(zone['n_levels']):
                suggest_bid = proper_round(mid_price * (1 - zone['levels'][i] / 10000), precision)
                if abs(zone['prev'][i] / suggest_bid - 1) <= zone['margins'][i] / 10000:
                    suggest_bid = zone['prev'][i]
                if len(bids) > 0 and bids[-1][0] <= suggest_bid:
                    suggest_bid = bids[-1][0] - price_step
                zone['prev'][i] = suggest_bid
                qty = (min_qty * (1 + i * qty_step)) / suggest_bid * norm_coef
                if not zone['protection']:
                    qty *= buy_coef
                bids.append([float(str_round(suggest_bid, precision)), qty])

            zi += 1
        # print(asks)
        # print(bids)
        # quit()
        if not params['retain']:
            ask_bound = max(ask_bound, real_bid + price_step)
            bid_bound = min(bid_bound, real_ask - price_step)
        min_ask_price = 1e9
        for ask in asks:
            min_ask_price = min(min_ask_price, ask[0])
        if min_ask_price < ask_bound:
            for ask in asks:
                ask[0] += ask_bound - min_ask_price
                ask[0] = float(str_round(ask[0], precision))
        max_bid_price = 0
        for bid in bids:
            max_bid_price = max(max_bid_price, bid[0])
        if max_bid_price > bid_bound:
            for bid in bids:
                bid[0] -= max_bid_price - bid_bound
                bid[0] = float(str_round(bid[0], precision))
        print(sorted([ask[0] for ask in asks]))

        actual_asks, actual_bids = [], []
        asks_less_than_min_size, bids_less_than_min_size = 0, 1 # в quote из-за умножения больше неточность
        for ask in asks:
            if ask[0] * ask[1] >= params['min_order_size'] + 0.1:
                actual_asks.append(ask)
            else:
                asks_less_than_min_size += ask[1]

        for bid in bids:
            if bid[0] * bid[1] >= params['min_order_size'] + 0.1:
                actual_bids.append(bid)
            else:
                bids_less_than_min_size += (bid[0] * bid[1])

        if cur_pos_base < -params['min_pos_base'] + asks_less_than_min_size:
            params['stopped'] = True
            self.log(params, 'alert', {'op': 'stop'})
            raise Exception(f"{params['market'].market} stopped")

        if cur_pos_quote + bids_less_than_min_size > params['max_pos_quote']:
            params['stopped'] = True
            self.log(params, 'alert', {'op': 'stop'})
            raise Exception(f"{params['market'].market} stopped")

        if cur_pos_base > 0: # открыта long позиция -> закрываем продажей
            price = real_ask - price_step
            if price <= real_bid:
                price = real_ask
            if cur_pos_base * price >= params['min_order_size'] + 0.1:
                actual_asks.append([float(str_round(price, precision)), cur_pos_base])
        elif cur_pos_base < 0: # открыта short позиция -> закрываем покупкой
            price = real_bid + price_step
            if price >= real_ask:
                price = real_bid
            if -cur_pos_base * price >= params['min_order_size'] + 0.1:
                actual_bids.append([float(str_round(price, precision)), -cur_pos_base])

        return (actual_asks, actual_bids)

    def process_grid(self, params, mid_price):
        new_grid = self.build_grid(params, mid_price)
        print('built')
        print(new_grid)
        new_ask_grid = {float(ask[0]): ask[1] for ask in new_grid[0]}
        print(params['market'].symbol[3])
        print(str_round(0.000001, 6))
        new_bid_grid = {float(bid[0]): bid[1] for bid in new_grid[1]}
        orders = params['market'].get_orders()
        self.log(params, 'public_trades', params['market'].get_new_public_trades())
        self.log(params, 'private_trades', params['market'].get_new_private_trades())
        self.log(params, 'orders', orders)
        params['cnt'] += 1
        if params['cnt'] % 5 == 0:
            depth = params['market'].get_depth()
            ask_price = depth['asks'][0][0] if len(depth['asks']) > 0 else 1e9
            bid_price = depth['bids'][0][0] if len(depth['bids']) > 0 else 0
            organic = {'ask': [0 for i in range(30)], 'bid': [0 for i in range(30)]}
            user = {'ask': [0 for i in range(30)], 'bid': [0 for i in range(30)]}
            for ask in depth['asks']:
                percent = int(100 * (ask[0] / ask_price - 1))
                if percent >= 30:
                    break
                organic['ask'][percent] += ask[1] * ask[0]
            for bid in depth['bids']:
                percent = int(100 * (1 - bid[0] / bid_price))
                if percent >= 30:
                    continue
                organic['bid'][percent] += bid[1] * bid[0]
            if ask_price == 1e9 and len(orders['ask']) > 0:
                ask_price = min([order['price'] for order in orders['ask']])
            if bid_price == 0 and len(orders['bid']) > 0:
                bid_price = max([order['price'] for order in orders['bid']])
            for order in orders['ask']:
                qty = order['quantity']
                price = order['price']
                if price < ask_price:
                    continue
                percent = int(100 * (price / ask_price - 1))
                if percent >= 30:
                    continue
                organic['ask'][percent] -= qty * price
                user['ask'][percent] += qty * price
            for order in orders['bid']:
                qty = order['quantity']
                price = order['price']
                if price > bid_price:
                    continue
                percent = int(100 * (1 - price / bid_price))
                if percent >= 30:
                    continue
                organic['bid'][percent] -= qty * price
                user['bid'][percent] += qty * price
            organic['ask'] = list(accumulate(organic['ask']))
            organic['bid'] = list(accumulate(organic['bid']))
            user['ask'] = list(accumulate(user['ask']))
            user['bid'] = list(accumulate(user['bid']))
            self.log(params, 'organic_depth', organic)
            self.log(params, 'user_depth', user)
            step = 0.1 ** params['market'].symbol[3]
            if params['taker_buyback_price'] != None and params['taker_buyback_funds'] >= 5 and min(new_ask_grid.keys()) >= ask_price + step and ask_price < mid_price:
                delta = min(depth['asks'][0][1], params['taker_buyback_funds'] / ask_price)
                print(f'LOL {ask_price} {delta}')
                params['taker_buyback_funds'] -= delta * ask_price
                params['market'].new_limit(ask_price, delta, True)
        print(params['cnt'])
        print(f'{params['market'].market} asks: {orders['ask']}')
        print(f'{params['market'].market} bids: {orders['bid']}')
#        print(new_ask_prices)
#        print(new_bid_prices)
#        print(orders[0].keys())
        to_cancel = []
        to_create = [[], []]
        for order in orders['ask']:
            if order['price'] in new_ask_grid:
                new_ask_grid.pop(order['price'])
            else:
                to_cancel.append(order['id'])
        for order in orders['bid']:
            if order['price'] in new_bid_grid:
                new_bid_grid.pop(order['price'])
            else:
                to_cancel.append(order['id'])
        for price in new_ask_grid:
            ask = [price, new_ask_grid[price]]
            if not ask[0] in orders['ask']:
                to_create[0].append(ask)
        for price in new_bid_grid:
            bid = [price, new_bid_grid[price]]
            if not bid[0] in orders['bid']:
                to_create[1].append(bid)
        threads = []
        print(f'New len: {len(to_create[0])} + {len(to_create[1])}, cancel len: {len(to_cancel)}')
        print(to_create[0])
        for oid in to_cancel:
            # print(f'Start #{self.zi}: cancel {oid}')
            self.zi += 1
            threads.append(Thread(target=params['market'].cancel, args=(oid,)))
            threads[-1].start()
        for ask in to_create[0]:
            # print(f'Start #{self.zi}: create ask {ask}')
            self.zi += 1
            threads.append(Thread(target=params['market'].new_limit_maker, args=(ask[0], ask[1], False)))
            threads[-1].start()
        for bid in to_create[1]:
            # print(f'Start #{self.zi}: create bid {bid}')
            self.zi += 1
            threads.append(Thread(target=params['market'].new_limit_maker, args=(bid[0], bid[1], True)))
            threads[-1].start()
        return threads

    def run_event_loop(self, target=None):
        for i in range(len(self.params)):
            if self.params[i]['cancel_on_start']:
                self.params[i]['market'].cancel_open_orders()
#        for market in self.markets:
#            market.cancel_open_orders()

        for params in self.params:
            print(params['market'].get_info()['balance'])

        while True:
            try:
                info = self.params[0]['market'].get_info()
                if target == None:
                    print(info)
                    mid = (info['book']['ask_price'] + info['book']['bid_price']) / 2
                    if self.prev_mid > 0:
                        mid = self.prev_mid * self.ema_gamma + (1 - self.ema_gamma) * mid
                        mid = max(self.prev_mid * 0.9995, min(self.prev_mid * 1.0005, mid))
                    else:
                        self.pred_mid = mid
                    mid_2 = mid
                else:
                    mid = target()
                    mid_2 = (info['book']['ask_price'] + info['book']['bid_price']) / 2
                self.prev_mid = mid
                print(f'{int(time.time() * 1000)} - {mid}')
                self.zi = 0
                threads = []
                i = 0
                for params in self.params:
                    if not params['stopped']:
                        threads.extend(self.process_grid(params, mid if i == 0 else mid_2))
                    i += 1
                i = 0
                for t in threads:
                    t.join()
                    # print(f'Joined #{i}')
                    i += 1
            except Exception as e:
                print(f'exception: {e}')
            finally:
                time.sleep(self.cooldown)