import asyncio
import logging
import os
import time
import json
import subprocess
import sys
import psutil
from datetime import datetime
from pathlib import Path
from aiogram.types import Message
from aiogram.enums import ParseMode
from aiogram import Bot, Dispatcher, types
from aiogram.filters.command import Command
from aiogram import F
from pathlib import Path
from aiogram.exceptions import TelegramBadRequest
from apscheduler.schedulers.asyncio import AsyncIOScheduler
import signal

logging.basicConfig(level=logging.INFO)

scheduler = AsyncIOScheduler()
bot = Bot(token="7848354217:AAFqy-o0vsCFVUwvOZCFeEwN4BQEGcAvfME")
# bot = Bot(token="8075248495:AAF5sWpFJYOPmaN__vutIaZ-73J44FVti-g")

dp = Dispatcher()

def parse_admins_json():
    with open('admins.json', 'r') as admins_f:
        uids = json.loads(''.join(admins_f.readlines()).replace(' ', '').replace('\n', ''))

    with open('/home/ubuntu/tgbot/alerts.json', 'r') as alert_f:
        uids_blocked_alarams = json.loads(''.join(alert_f.readlines()).replace(' ', '').replace('\n', ''))

        for uid in uids:
            if uid not in uids_blocked_alarams:
                uids_blocked_alarams[uid] = {}

    return (uids, uids_blocked_alarams)


available_uids, uids_blocked_alarams = parse_admins_json()

super_admins = {
    "6351928464": "Mansur",
    "6049031402":"Murat",
    "377206035":"Denis",
    "5885283978":"Ibragim",
}

alarm_types = {
    'wide-spread': 'mm_wide_spread',
    'buy-occupancy': 'mm_buy_occupancy_rate',
    'sell-occupancy': 'mm_sell_occupancy_rate',
    'narrow-spread': 'mm_narrow_spread',
    'zero-balance': 'mm_zero_balance',
    'base-low-balance': 'mm_base_low_balance',
    'quote-low-balance': 'mm_quote_low_balance',
    'no-trades': 'vol_no_trades'
}

alarm_type_to_answer = {
    'mm_wide_spread': 'Wide spread > 2%',
    'mm_buy_occupancy_rate': 'Buy side occupancy rate',
    'mm_sell_occupancy_rate': 'Sell side occupancy rate',
    'mm_narrow_spread': 'Narrow spread < 0.02%',
    'mm_zero_balance': 'Zero balance',
    'mm_base_low_balance': 'Base balance < 10% of Zero base',
    'mm_quote_low_balance': 'Quote balance < 10% of Zero quote',
    'vol_no_trades': 'No trades within last 15 minutes',
}

price_checker_upd_p = {}

path_to_mm_balances_dir = '/mnt/mm_telemetry'
path_to_vol_balances_dir = '/mnt/volume_telemetry'
balance_state = {}
prev_wide_spread = {}
stopped = [[], []]

alarm_last_time = {}

async def verification(uid):
    if f"{uid}" in available_uids:
        return True
    else:
        return False


@dp.message(Command("start"))
async def start(message: types.Message):
    is_verified = await verification(message.from_user.id)
    if not is_verified:
        await message.answer("You are not verified so i don't know who are you\nPlease contact @saushkin_den if you think this is a mistake")
        return

    await message.answer(f"Welcome to EchoBot controller, {available_uids[str(message.from_user.id)]}!\n") # Call \"/help\" too see the available commands")


@dp.message(Command("ping"))
async def ping(message: types.Message):
    is_verified = await verification(message.from_user.id)
    if not is_verified:
        await message.answer("You are not in whitelist")
        return

    if str(message.from_user.id) in super_admins:
        await message.answer("You have super-admin rights")
    else:
        await message.answer("You have user rights")


@dp.message(Command("check_user_alarms"))
async def check_user_alarms(message: types.Message):
    result = ''
    if str(message.from_user.id) in super_admins:
        for user in uids_blocked_alarams:

            result += f'\n~~~ {available_uids[user]} ({user}) disabled alarms list ~~~'
            init_result = result

            if len(uids_blocked_alarams[user]) == 0:
                result += '\n- No disabled\n'
                continue

            for pair in uids_blocked_alarams[user]:

                if len(uids_blocked_alarams[user][pair]) == 0:
                    continue

                result += ('\n' + pair + ':')

                for alarm in uids_blocked_alarams[user][pair]:
                    result += '\n- ' + alarm_type_to_answer[alarm]

            if result == init_result: # то есть нет ни одного аларма
                result += '\n- No disabled\n'

            result += '\n'

        await message.reply(result)

    else:
        await message.reply("You haven't super admin rights to do it")


@dp.message(Command("get_disabled_alarms"))
async def get_disabled_alarms(message: types.Message):
    is_verified = await verification(message.from_user.id)
    if not is_verified:
        await message.answer("You are not in whitelist")
        return

    if len(uids_blocked_alarams[str(message.from_user.id)]) == 0:
        await message.reply('No disabled alarms')
        return

    answer = init_answer = 'List of disabled alarms\n------------'

    for pair in uids_blocked_alarams[str(message.from_user.id)]:

        if len(uids_blocked_alarams[str(message.from_user.id)][pair]) == 0:
            continue

        answer += ('\n' + pair + ':')
        for alarm in uids_blocked_alarams[str(message.from_user.id)][pair]:
            answer += ('\n- ' + alarm_type_to_answer[alarm])

        answer += '\n'

    if answer == init_answer:
        await message.reply('No disabled alarms')
    else:
        await message.reply(answer)


@dp.message(F.text.lower().contains('/add_admin_'))
async def add_admin(message: Message):
    add_id = message.text.split('_')[2].upper()
    name = message.text.split('_')[3].upper()
    if str(message.from_user.id) in super_admins:
        if str(message.from_user.id) not in available_uids:
            available_uids[str(message.from_user.id)] = super_admins[str(message.from_user.id)]
            uids_blocked_alarams[str(message.from_user.id)] = {}

        available_uids[add_id] = name[0].upper() + name[1:].lower()
        uids_blocked_alarams[add_id] = {}

        with open('/home/ubuntu/tgbot/admins.json', 'w') as admins_f:
            admins_f.write(json.dumps(available_uids))

        with open('/home/ubuntu/tgbot/alerts.json', 'w') as alerts_f:
            alerts_f.write(json.dumps(uids_blocked_alarams))

        await message.reply(f"{available_uids[add_id]} with {add_id} uid was added as admin")

    else:
        await message.reply("You haven't super admin rights to do it")


@dp.message(F.text.lower().contains('/alarm_'))
async def add_filter(message: Message):
    is_verified = await verification(message.from_user.id)
    if not is_verified:
        await message.answer("You are not verified so i don't know who are you")
        return

    if message.text.split('_')[1].lower() == 'reset':
        if len(message.text.split('_')) < 4:
            await message.answer("Wrong number of arguments!\nExample: /alarm_reset_DAG_MEXC")
            return

        coin = message.text.split('_')[2]
        exchange = '_'.join(message.text.split('_')[3:])

        name = (coin + "_USDT_" + exchange).upper()
        uids_blocked_alarams[str(message.from_user.id)][name] = []

        await message.answer("Reset completed")

    elif message.text.split('_')[1].lower() == 'disable':
        if len(message.text.split('_')) < 5:
            await message.answer("Wrong number of arguments!\nExample: /alarm_disable_wide-spread_DAG_MEXC")
            return

        alarm_type = message.text.split('_')[2].lower()
        coin = message.text.split('_')[3]
        exchange = '_'.join(message.text.split('_')[4:])

        name = (coin + "_USDT_" + exchange).upper()

        if name in uids_blocked_alarams[str(message.from_user.id)]:
            if alarm_type in uids_blocked_alarams[str(message.from_user.id)][name]:
                await message.answer('Already have this type')
                return
            elif alarm_type == 'all' and len(uids_blocked_alarams[str(message.from_user.id)][name]) == len(alarm_types):
                await message.answer('Already have this type')
                return

        if alarm_type == 'all':

            if name not in uids_blocked_alarams[str(message.from_user.id)]:
                uids_blocked_alarams[str(message.from_user.id)][name] = []

            for alarm_t in alarm_types:
                uids_blocked_alarams[str(message.from_user.id)][name].append(alarm_types[alarm_t])
        else:
            if alarm_type not in alarm_types:
                all_types = '\n- '.join(alarm_types.keys())
                await message.answer(f'Unknown alarm type: {alarm_type}\nAllowed types:\n- {all_types}')
                return

            if name not in uids_blocked_alarams[str(message.from_user.id)]:
                uids_blocked_alarams[str(message.from_user.id)][name] = []

            uids_blocked_alarams[str(message.from_user.id)][name].append(alarm_types[alarm_type])

        await message.answer("Add filter completed")

    else:
        await message.answer('Unknown type, allowed only: \"reset\" and \"disable\"')

    with open('/home/ubuntu/tgbot/alerts.json', 'w') as alert_f:
        alert_f.write(json.dumps(uids_blocked_alarams))


@dp.message(F.text) # КОСТЫЛЬ!! нужны фильтры, сейчас НЕЛЬЗЯ эту функцию поднимать выше
async def bad_message(message: Message):
    is_verified = await verification(message.from_user.id)
    if not is_verified:
        await message.answer("You are not verified so i don't know who are you\nplease contact @saushkin_den if you think this is a mistake")
        return

    await message.answer("I don't understand you")


async def send_message_to_users(msg):
    for user_id in available_uids:
        try:
            await bot.send_message(text=msg, chat_id=user_id)
        except:
            continue


async def broadcast_alarm_message_to_users(msg, pair, alarm_type):
    pair = pair.upper()

    if pair not in alarm_last_time:
        alarm_last_time[pair] = {}

    if alarm_type in alarm_last_time[pair]:
        if int(time.time()) - alarm_last_time[pair][alarm_type] >= 600:
            for user_id in available_uids:
                try:
                    if pair in uids_blocked_alarams[user_id] and alarm_type in uids_blocked_alarams[user_id][pair]:
                        continue
                    else:
                        await bot.send_message(text=msg, chat_id=user_id)

                except Exception as e:
                    print(f'Exception broadcast_alarm_message_to_users: {e}')

                    continue

            alarm_last_time[pair][alarm_type] = int(time.time())
    else:
        for user_id in available_uids:
            try:
                if pair in uids_blocked_alarams[user_id] and alarm_type in uids_blocked_alarams[user_id][pair]:
                    continue
                else:
                    await bot.send_message(text=msg, chat_id=user_id)
            except:
                continue

        alarm_last_time[pair][alarm_type] = int(time.time())



async def mm_calculate_lob_occupancy_rate(name, orders_log, decoded):
    orders = json.loads(''.join(orders_log.split(' ')[2:]).replace("'", '"'))
    asks_sum = sum([float(order['quantity']) for order in orders['ask']])
    bids_sum = sum([float(order['quantity']) * float(order['price']) for order in orders['bid']])

    print('asks_sum', asks_sum, 'bids_sum', bids_sum)

    for line in decoded:
        if 'position' in line:
            position = json.loads(''.join(line.split(' ')[2:]).replace("'", '"'))

            if 'total_buy_quote' not in position or 'total_sell_base' not in position: # пока нет этого поля, чтобы исключения не летели постоянно
                print("'total_buy_quote' not in position")
                break

            if 0.1 * float(position['total_buy_quote']) > bids_sum:
                await broadcast_alarm_message_to_users(
                    f"MARKET MAKING ALARM: {name} buy order book occupancy rate < 10%\nCurrent bids amount: {bids_sum}\nTotal buy quote parameter: {float(position['total_buy_quote'])}",
                    name, 'mm_buy_occupancy_rate'
                )

            if 0.1 * float(position['total_sell_base']) > asks_sum:
                await broadcast_alarm_message_to_users(
                    f"MARKET MAKING ALARM: {name} sell order book occupancy rate < 10%\nCurrent asks quantity: {asks_sum}\nTotal sell base parameter: {float(position['total_sell_base'])}",
                    name, 'mm_sell_occupancy_rate'
                )

            break


async def balance_checker(bot: Bot):
    mm_files_path = [path_to_mm_balances_dir + '/' + file.name for file in Path(path_to_mm_balances_dir).iterdir() if file.is_file()]
    volume_files_path = [path_to_vol_balances_dir + '/' + file.name for file in Path(path_to_vol_balances_dir).iterdir() if file.is_file()]

    for balance_file in mm_files_path:
        p = subprocess.Popen(['tail', '-30', balance_file],shell=False, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
        res, err = p.communicate()
        if not err:
            name = balance_file.split('/')[-1]
            decoded = res.decode().split('\n')
            used = set()
            for line in decoded[::-1]:
                try:
                    time = str(datetime.fromtimestamp(int(int(line.split(' ')[0]) / 1000)))
                except Exception as e:
                    if line != '':
                        print(e)
                        print(f'error parse {name}')
                    continue

                splitted = line.split(' ')

                if len(splitted) < 3:
                    continue

                if 'stop' in line:
                    if name in stopped[0]:
                        break
                    stopped[0].append(name)
                    await send_message_to_users(f'MARKET MAKING ALARM: {name} bot was stopped at {time}')
                    break

                if name in stopped[0]:
                    stopped[0].remove(name)
                    await send_message_to_users(f'MARKET MAKING ALARM: {name} bot was restarted')

                if 'cashout' in line or 'buyback' in line:
                    continue

                msg_type = splitted[1]
                if msg_type in used:
                    continue
                used.add(msg_type)

                try:
                    info_dict = eval(''.join(splitted[2:]).replace("'", '"'))
                except Exception as e:
                    print(name, f'{e}')
                    continue

                if msg_type == 'book':
                    if float(info_dict['ask_price']) == 0:
                        pass
                        # await send_message_to_users(f'ALARM: {name} bid price = 0')
                    else:
                        spread_size = (float(info_dict['ask_price']) - float(info_dict['bid_price'])) / float(info_dict['ask_price'])
                        ask = float(info_dict['ask_price'])
                        bid = float(info_dict['bid_price'])
                        if spread_size > 0.02:
                            await broadcast_alarm_message_to_users(
                                f'MARKET MAKING ALARM: {name} spread > 2%\nspread: {round(spread_size * 100, 2)}%\nask: {ask}\nbid: {bid}',
                                name, 'mm_wide_spread'
                            )
                        elif spread_size < 0.0002:
                            await broadcast_alarm_message_to_users(
                                f'MARKET MAKING ALARM: {name} spread < 0.02%\nspread: {round(spread_size * 100, 2)}%\nask: {ask}\nbid: {bid}',
                                name, 'mm_narrow_spread'
                            )

                elif msg_type == 'balance':
                    base, quote = float(info_dict['base']), float(info_dict['quote'])
                    new_balances = {"time": time, "base": base, 'quote': quote}

                    zero_base, zero_quote = await extract_zero_position(decoded[::-1]) # TODO: обработать только что созданные файлы

                    if zero_base == 0 and zero_quote == 0:
                        await broadcast_alarm_message_to_users(
                            f'MARKET MAKING ALARM: {name} zero base or quote balance',
                            name, 'mm_zero_balance'
                        )
                        continue

                    if base < 0.1 * zero_base:
                        await broadcast_alarm_message_to_users(
                            f'MARKET MAKING ALARM: {name} base balance lower than critical (<10%)\nbase: {base} ~~~ zero base: {zero_base}',
                            name, 'mm_base_low_balance'
                        )

                    if quote < 0.1 * zero_quote:
                        await broadcast_alarm_message_to_users(
                            f'MARKET MAKING ALARM: {name} balance lower than critical (<10%)\nquote: {quote} ~~~ zero quote: {zero_quote}',
                            name, 'mm_quote_low_balance'
                        )

                    if name not in balance_state:
                        balance_state[name] = new_balances
                        continue

                    free_delta = abs(new_balances['base'] - balance_state[name]['base']) / balance_state[name]['base']
                    locked_delta = abs(new_balances['quote'] - balance_state[name]['quote']) / balance_state[name]['quote']

                    if free_delta > 0.1 or locked_delta > 0.1:
                        prev_bal = json.dumps(balance_state[name])
                        new_bal = json.dumps(new_balances)
                        balance_state[name] = new_balances # update
                        # await send_message_to_users(f'ALARM: {name} balance > 10% change:\n  new: {new_bal}\n  previous: {prev_bal}')

                elif msg_type == 'orders':
                    await mm_calculate_lob_occupancy_rate(name, line, decoded[::-1])
        else:
            print(err.decode())

    # for balance_file in volume_files_path:
    #     p = subprocess.Popen(['tail', '-1', balance_file],shell=False, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
    #     res, err = p.communicate()
    #     if not err:
    #         name = balance_file.split('/')[-1]
    #         try:
    #             time = str(datetime.fromtimestamp(int(int(res.decode().split(' ')[0]) / 1000)))
    #         except:
    #             print(f'error parse {name} ')
    #             continue

    #         if 'stop' in res.decode():
    #             if name in stopped[1]:
    #                 continue
    #             stopped[1].append(name)
    #             await send_message_to_users(f'VOLUME ALARM: {name} bot was stopped at {time}')
    #             continue

    #         if name in stopped[1]:
    #             stopped[1].remove(name)
    #             await send_message_to_users(f'VOLUME ALARM: {name} bot was restarted')

    #         msg_type = res.decode().split(' ')[1]
    #         info_dict = eval(''.join(res.decode().split(' ')[2:]).replace("'", '"'))

    #         if msg_type == 'balance':
    #             base, quote = float(info_dict['base']), float(info_dict['quote'])
    #             new_balances = {"time": time, "base": base, 'quote': quote}

    #             if base < 10 and quote < 10: # в теории норм обработать надо
    #                 await send_message_to_users(f'VOLUME ALARM: {name} quote or base balance = 0')
    #                 continue

    #             if name not in balance_state:
    #                 balance_state[name] = new_balances
    #                 continue

    #             free_delta = abs(new_balances['base'] - balance_state[name]['base']) / max(30, balance_state[name]['base'])
    #             locked_delta = abs(new_balances['quote'] - balance_state[name]['quote']) / max(30, balance_state[name]['quote'])

    #             if free_delta > 0.1 or locked_delta > 0.1:
    #                 prev_bal = json.dumps(balance_state[name])
    #                 new_bal = json.dumps(new_balances)
    #                 balance_state[name] = new_balances # update
    #                 # await send_message_to_users(f'VOLUME ALARM: {name} balance > 10% change:\n  previous: {prev_bal}\n  new: {new_bal}')
    #     else:
    #         print(err.decode())

    print(balance_state)


async def volume_health_trades_checker(bot: Bot):
    volume_files_path = [path_to_vol_balances_dir + '/' + file.name for file in Path(path_to_vol_balances_dir).iterdir() if file.is_file()]

    bound_time = (int(time.time()) - 900)*1000 # -15 minutes

    for balance_file in volume_files_path:
        p = subprocess.Popen(['tail', '-5000', balance_file],shell=False, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
        res, err = p.communicate()
        if not err:
            name = balance_file.split('/')[-1]
            decoded = res.decode().split('\n')

            if len(decoded) <= 2:
                continue

            line = ''
            if 'stop' in decoded[-1]:
                line = decoded[-1]
            elif 'stop' in decoded[-2]:
                line = decoded[-2]

            if line != '':
                try:
                    t = str(datetime.fromtimestamp(int(int(line.split(' ')[0]) / 1000)))
                except Exception as e:
                    if line != '':
                        print(e)
                        print(f'error parse {name}')
                    continue

                if name not in stopped[1]:
                    stopped[1].append(name)
                    stop_type = 'Spread > 10% or Price change > 8%'
                    msg=' '
                    if 'fees' in line:
                        stop_type = 'Fees increased'
                        try:
                            d = json.loads(''.join(line.split(' ')[2:]).replace("'", '"'))
                            if 'msg' in d:
                                msg = '\n' + str(d['msg'])
                        except:
                            pass

                    await send_message_to_users(f'VOLUME ALARM: {name} bot was stopped at {t} due to {stop_type}{msg}')
                continue

            for line in decoded[::-1]:

                if name in stopped[1]:
                    stopped[1].remove(name)
                    await send_message_to_users(f'VOLUME ALARM: {name} bot was restarted')
                    continue

                try:
                    if int(line.split(' ')[0]) < bound_time:
                        await broadcast_alarm_message_to_users(f'VOLUME ALARM: {name} no private trades within 15 minutes', name, 'vol_no_trades')
                        break

                    if 'private_trades' in line:
                        if ''.join(line.split(' ')[2:]) != '[]':
                            break

                except Exception as e:
                    if line != '':
                        print(f'volume_health_trades_checker exception: {e}')
                        print('volume_health_trades_checker exeception:', name, line)
                    continue


async def extract_zero_position(decoded):
    for line in decoded:
        if 'position' in line:
            position = json.loads(''.join(line.split(' ')[2:]).replace("'", '"'))
            return (float(position['zero_base']), float(position['zero_quote']))

    return (0, 0)


async def price_checker(bot: Bot):
    mm_files_path = [path_to_mm_balances_dir + '/' + file.name for file in Path(path_to_mm_balances_dir).iterdir() if file.is_file()]

    for balance_file in mm_files_path:
        p = subprocess.Popen(['tail', '-100', balance_file],shell=False, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
        res, err = p.communicate()

        if not err:
            name = balance_file.split('/')[-1]
            decoded = res.decode().split('\n')
            for line in decoded[::-1]:
                if 'stop' in line:
                    break
                if 'book' in line:
                    book = json.loads(''.join(line.split(' ')[2:]).replace("'", '"'))
                    mid_price = (float(book['ask_price']) + float(book['bid_price'])) / 2

                    # print('Price checker', name, price_checker_upd_p)
                    # print('book', name, book)

                    if float(book['ask_price']) == 0 and float(book['bid_price']) == 0:
                        continue

                    if name not in price_checker_upd_p:
                        price_checker_upd_p[name] = [0, 0]

                    if price_checker_upd_p[name][1] != 0:
                        if mid_price > 1.05 * price_checker_upd_p[name][1] or mid_price < 0.95 * price_checker_upd_p[name][1]:
                            prev_time = str(datetime.fromtimestamp(price_checker_upd_p[name][0]))
                            cur_time = str(datetime.fromtimestamp(int(time.time())))
                            await send_message_to_users(
                                f'MARKET MAKING ALARM: {name} 15 minutes mid price delta > 5%\n{prev_time}\nprevious mid price: {price_checker_upd_p[name][1]}\n{cur_time}\ncurrent mid price: {mid_price} && ask: {book["ask_price"]} && bid: {book["bid_price"]}'
                            )
                            price_checker_upd_p[name][0] = int(time.time())
                            price_checker_upd_p[name][1] = mid_price

                    if price_checker_upd_p[name][0] == 0 or int(time.time()) - price_checker_upd_p[name][0] >= 900: # 15 min
                        price_checker_upd_p[name][0] = int(time.time())
                        price_checker_upd_p[name][1] = mid_price

                    break


# def signal_handler(sig, frame):

#     async def asyncfunc():
#         await send_message_to_users('Bot was stopped by developer')

#     asyncio.run(asyncfunc())
#     time.sleep(10)
#     sys.exit(0)

async def main():
    scheduler = AsyncIOScheduler()
    scheduler.add_job(balance_checker, "interval", seconds=25, args=[bot])
    scheduler.add_job(price_checker, "interval", seconds=15, args=[bot])
    scheduler.add_job(volume_health_trades_checker, "interval", seconds=40, args=[bot])
    scheduler.start()

    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())