from threading import Thread
import numpy as np
import time
from copy import copy
from binance.spot import Spot
from utility import make_client
import fcntl

class Volume:
    def reopen(self):
        try:
            self.target_f.close()
        except Exception as e:
            print(e)
        try:
            self.target_f = open(f"/mnt/pt_telemetry/{self.group}", "r")
        except Exception as e:
            print(e)

    def __init__(self, group):
        self.threads = []
        self.binance = Spot('', '')
        self.pwr = 0
        self.volumes = []
        self.bgt = int(time.time())
        self.group = group
        self.reopen()
        self.price = 0
        self.last_len = 0
        self.last_mm_info_t = 0

    def get_mm_lvls(self):
        lines = self.mm_bests_f.readlines()
        print('get_mm_lvls len:', len(lines))
        if len(lines) < 1:
            return
        if lines[-1] != '':
            bests_info_dict = eval(lines[-1].rstrip())
        else:
            if len(lines) < 2:
                return
            bests_info_dict = eval(lines[-2].rstrip())
        try:
            t = int(bests_info_dict['ts'])
            self.last_mm_info_t = t
            print('get_mm_lvls:', bests_info_dict)
            print('delta', int(time.time()*1000) - t)
            if int(time.time()*1000) - t > 1000: # считаем, что 1000ms достаточно, чтобы выставление мм-ордера догло до биржи
                return
            print('delta t < 1000')
        except:
            print('Exception get_mm_lvls():', line[-2:])
            return
        return (float(bests_info_dict['ask_price']), float(bests_info_dict['bid_price']))

    def target(self):
        try:
            fcntl.flock(self.target_f, fcntl.LOCK_EX)
            lines = self.target_f.readlines()
            clen = len(lines)
            if self.last_len == 0 and clen == 0:
                self.reopen()
            self.last_len = len(lines)
            fcntl.flock(self.target_f, fcntl.LOCK_UN)
            for line in lines:
                if 'price' in line:
                    self.price = float(eval(line.split(' price ')[1])['price'])
        except Exception as e:
            print(e)
            self.target_f = open(f"/mnt/pt_telemetry/{self.group}", "r")
        return self.price

    def _process(self,
                market, daily_volume, left_bound,
                right_bound, history_mode, threshold,
                tight_spread, smart, smart_spread, close_candles,
                tight_min_base,
                tight_min_quote,
                buy_ratio
                ):
        self.mm_bests_f = open(f"/mnt/mm_bid_ask/{market.symbol[1].upper()}_{market.symbol[2].upper()}_{market.market}", "r") # если есть файл

        book = market.get_info()['book']
        self.price = (book['ask_price'] + book['bid_price']) / 2
        bal_f = open(f"/mnt/volume_telemetry/{market.symbol[1].upper()}_{market.symbol[2].upper()}_{market.market}", "a")

        flush = lambda _: bal_f.flush()
        log = lambda name, obj: flush(bal_f.write(f'{int(time.time() * 1000)} {name} {obj}\n'))

        log("alert", {'op': 'start'})
        price = (book['ask_price'] + book['bid_price']) / 2
        counter = 0
        self.step = 0.1 ** market.symbol[3]
        market_old = market
        if smart:
            bal_f2 = open(f"/mnt/wolume_telemetry/{market.symbol[1].upper()}_{market.symbol[2].upper()}_{market.market}", "a")
            market2 = make_client(market.market, market.symbol[1] + '_' + market.symbol[2], market.symbol[3:], 'W', {})
            market_new = market2
        else:
            bal_f2 = bal_f
            market2 = market

        flush2 = lambda _: bal_f2.flush()
        log2 = lambda name, obj: flush2(bal_f2.write(f'{int(time.time() * 1000)} {name} {obj}\n'))

        last_price = None
        last_day = 0
        last_5m = None
        iter_len = [0]
        while True:
            market, market2 = market2, market
            bg = time.time()
            print(bg, flush=True)
            coef = 1
            cd = 10
            try:
                ##########
                info = market_old.get_info()
                log('book', info['book'])
                log('balance', info['balance'])
                public_trades = market_old.get_new_public_trades()
                private_trades = market_old.get_new_private_trades()
                log('public_trades', public_trades)
                log('private_trades', private_trades)

                if smart:
                    print('bebra', flush=True)
                    info = market_new.get_info()
                    log2('book', info['book'])
                    print(info, flush=True)
                    log2('balance', info['balance'])
                    public_trades = market_new.get_new_public_trades()
                    private_trades = market_new.get_new_private_trades()
                    log2('public_trades', public_trades)
                    log2('private_trades', private_trades)

                print('started', flush=True)
                try:
                    fees_res = market.get_fees()
                    if type(fees_res) == tuple:
                        taker_fees, maker_fees = fees_res[0], fees_res[1]
                        log('fees', {'taker': taker_fees, 'maker': maker_fees})
                    else:
                        print('not tuple fees result', fees_res)

                except Exception as e:
                    print(f'exception: {e} ({market.market})', flush=True)
                    log('alert', {'op': 'stop', 'type':'fees', 'msg':f'{e}'})
                    return

                if history_mode:
                    cur_day = int(time.time()) // 86400
                    cur_5m = (int(time.time()) % 86400) // 288
                    if cur_day > last_day:
                        kline_history = self.binance.klines(symbol='BTCUSDT', interval='5m', limit=289, endTime = cur_day * 86400000)[:-1]
                        volume_1d = np.sum(float(kline[7]) for kline in kline_history)
                        last_day = cur_day
                    kline_5m = kline_history[:cur_5m + 1]
                else:
                    volume_1d = float(self.binance.ticker_24hr(symbol='BTCUSDT')['quoteVolume'])
                    kline_5m = self.binance.klines(symbol='BTCUSDT', interval='5m', limit=60)
                print(f'len: {len(kline_5m)}')
                pmn = np.min([float(z[4]) for z in kline_5m])
                pmx = np.max([float(z[4]) for z in kline_5m])

                V = daily_volume / float(volume_1d) * float(kline_5m[-2][7])
                if V >= 100:
                    mean_cd = 5
                elif V >= 50:
                    mean_cd = 10
                elif V >= 25:
                    mean_cd = 60
                elif V >= 10:
                    mean_cd = 120
                else:
                    mean_cd = 180
                mean_vol = V * ((mean_cd + np.mean(iter_len)) / 300)
                print(np.mean(iter_len))
                cd = min(120, max(1, np.random.uniform(mean_cd / 10, mean_cd * 1.9)))
                norm_price = (float(kline_5m[-1][4]) - pmn) / (pmx - pmn) * (right_bound - left_bound) + left_bound
                step_size = 0.1 ** market.symbol[3]

                book_time_before = time.time()*1000 # debug
                print('book time before:', book_time_before) # debug
                info = market.get_info()
                book_time_after = time.time()*1000 # debug
                print('book time after:', book_time_after) # debug
                print('book latency:', book_time_after - book_time_before) # debug
                book = info['book']
                print(book)
                if book['bid_price'] == 0:
                    print('bid_price == 0')
                    time.sleep(10)
                    continue

                bal = info['balance']
                spread = book['ask_price'] / book['bid_price'] - 1
                if spread >= 0.1:
                    print('spread > 10%')
                    counter += 1
                    if counter >= 10:
                        log('alert', {'op': 'stop', 'type':'spread'})
                        return
                    time.sleep(10)
                    continue
                else:
                    counter = 0
                print(f'balances: {bal['base']} {bal['quote']}')
                print(f'spread: {spread} {market.market}')

                mm_lvls = self.get_mm_lvls()
                print('info book:', book)
                print('mm_info_t - book_t:', int((book_time_before + book_time_after) / 2) - self.last_mm_info_t) # debug
                print('delta now - mm_info_t:', int(time.time()*1000) -  self.last_mm_info_t) # debug
                if mm_lvls != None:
                    book['ask_price'] = min(book['ask_price'], mm_lvls[0])
                    book['bid_price'] = max(book['bid_price'], mm_lvls[1])
                    if mm_lvls[0] < book['ask_price'] or mm_lvls[1] > book['bid_price']:
                        print(int(time.time()*1000), 'MM update detected', book, mm_lvls)

                cur_price = (book['bid_price'] + step_size) + (book['ask_price'] - book['bid_price'] - 2 * step_size) * norm_price
                target_price = self.target()
                try:
                    print(target_price)
                    print(f'target: {target_price} (clip inside ({target_price * (1 - threshold / 100)}; {target_price * (1 + threshold / 100)}))')
                    cur_price = np.clip(cur_price, target_price * (1 - threshold / 100), target_price * (1 + threshold / 100))
                except Exception as e:
                    print(e)
                print(mean_vol)
                qty = min((bal['base'] * cur_price + bal['quote']) / 3, 3.5 + max(1.6, np.random.normal(mean_vol, mean_vol / 3))) / cur_price
                cur_price = float(f'%.{market.symbol[3]}f' % cur_price)
                print(f"iteration: {qty}, {cur_price}, {norm_price}")
                if last_price != None:
                    if abs(cur_price / last_price - 1) >= 0.08:
                        log('alert', {'op': 'stop'})
                        break

                    if close_candles:
                        cur_5m = (int(time.time()) % 86400) // 300
                        if last_5m == None or cur_5m > last_5m and last_price != None:
                            cur_price = last_price
                        last_5m = cur_5m

                # book = market.get_info()['book']
                print(f'{cur_price} {book['bid_price'] + step_size} {book['ask_price'] - step_size}')
                print(f'{market.market} {book}')
                if bal['base'] < qty:
                    print("bal[base] < qty")
                    print(last_price)
                    if last_price != None and abs(book['ask_price'] / last_price - 1) <= 0.01:
                        market.new_limit(book['ask_price'], qty, True)
                elif bal['quote'] < qty * cur_price:
                    print("bal[quote] < qty * cur_price")
                    if last_price != None and abs(book['bid_price'] / last_price - 1) <= 0.01:
                        market.new_limit(book['bid_price'], qty, False)
                else:
                    if cur_price <= book['ask_price'] - step_size / 2 and cur_price >= book['bid_price'] + step_size / 2:
                        print(f"proceeding {type(market)}")
                        threads = []
                        if np.random.randint(0, 2):
                            threads.append(Thread(target=market.new_limit, args=(cur_price, qty, False)))
                            threads[-1].start()
                            threads.append(Thread(target=market2.new_limit, args=(cur_price, qty, True)))
                            threads[-1].start()
                        else:
                            threads.append(Thread(target=market.new_limit, args=(cur_price, qty, True)))
                            threads[-1].start()
                            threads.append(Thread(target=market2.new_limit, args=(cur_price, qty, False)))
                            threads[-1].start()
                        for t in threads:
                            t.join()
                    elif tight_spread:
                        print(f"tight {type(market)}")
                        print('ask', book['ask_price'])
                        print('bid', book['bid_price'])

                        threads = []
                        is_buy = (self.target() >= book['ask_price'])
                        if is_buy:
                            print('buying in tight')
                            qty = max(qty, 6 / book['ask_price'])
                            print('qty', qty)
                            if bal['quote'] - qty * book['ask_price'] >= tight_min_quote:
                                print('valid balance for buyback')
                                threads.append(Thread(target=market.new_limit, args=(book['ask_price'], qty, True)))
                                threads[-1].start()
                                cur_price = book['ask_price']
                            else:
                                print('invalid balance for buyback')
                                print(bal['quote'], qty, tight_min_quote)
                        else:
                            print('selling in tight')
                            qty = max(qty, 6 / book['bid_price'])
                            print('qty', qty)
                            if bal['base'] - qty >= tight_min_base:
                                print('valid balance for buyback')
                                threads.append(Thread(target=market.new_limit, args=(book['bid_price'], qty, False)))
                                threads[-1].start()
                                cur_price = book['bid_price']
                            else:
                                print('invalid balance for buyback')
                                print(bal['base'], qty, tight_min_base)
                        for t in threads:
                            t.join()

                    last_price = cur_price

            except Exception as e:
                print(f'exception: {e} ({market.market})')
            try:
                market.cancel_open_orders()
            except Exception as e:
                print(f'exception cancel: {e} ({market.market})')
            finally:
                if len(iter_len) == 100:
                    iter_len = iter_len[1:]
                iter_len.append(time.time() - bg)
                time.sleep(cd)

    def add_market(self, market, daily_volume, left_bound=1/4, right_bound=3/4, history_mode=False, threshold=1.5, tight_spread=False, smart_daily_volume=0, smart_spread_size=2, close_candles=False, tight_min_base=0, tight_min_quote=0, buy_ratio=0.5):
        daily_volume = float(daily_volume)
        left_bound = float(left_bound)
        right_bound = float(right_bound)
        threshold = float(threshold)
        if threshold < 0:
            threshold = None
        if smart_daily_volume:
            self.threads.append(Thread(target=self._process, args=(market, smart_daily_volume / 2, left_bound, right_bound, history_mode, threshold, tight_spread, True, smart_spread_size, close_candles, tight_min_base, tight_min_quote, buy_ratio)))
        if daily_volume:
            self.threads.append(Thread(target=self._process, args=(market, daily_volume, left_bound, right_bound, history_mode, threshold, tight_spread, False, 0, close_candles, tight_min_base, tight_min_quote, buy_ratio)))

    def run_event_loop(self):
        for thread in self.threads:
            thread.start()
        for thread in self.threads:
            thread.join()