123

import asyncio
import datetime
from datetime import datetime
from datetime import timedelta

import pytz
from aiogram import types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import StatesGroup, State
from aiogram.utils.exceptions import MessageCantBeEdited

import db
from csv_writer import delete_csv_file, create_csv_file, CSV_PATH
from . import texts
from .db import DB
from ..keyboards import admin_panel as keyboards
from ..loader import dp, bot, ADMINS
from ..states import Menu, AdminMessage

now_day = datetime.now().day

db_ = DB('mongodb://localhost:27017/', 'AD')
loop = asyncio.get_event_loop()
tasks = []


def gethour():
    return datetime.now().hour + 4


def getmin():
    return datetime.now().minute


def getday():
    return datetime.now().day


async def my_sleep_func():
    await asyncio.sleep(50)


async def Check():
    global now_day
    while True:
        if now_day != getday():
            db_.decriment()
            now_day = getday()
        list_adv = db_.get_all_adv()
        for x in list_adv:
            for t in x['Time']:
                print(str(gethour()) + ':' + str(getmin()))
                print('' + t)
                t = t.replace(':', ' ').split()
                if gethour() == int(t[0]) or (gethour()) == 25 and int(t[0]) == 1 or (gethour()) == 26 and int(
                        t[0]) == 2 or (gethour()) == 27 and int(t[0]) == 3 or (gethour()) == 28 and int(t[0]) == 4:
                    print('+')
                    if getmin() == int(t[-1]):
                        print('+++')
                        try:
                            for chat in db_.get_all_chat():
                                print('+')
                                await bot.send_photo(int(chat['chat_id']), open(x['msg_img'], 'rb'), caption=f"""
💰 <b>На правах рекламы </b> \n \n{x['msg_text']}\n
💰 <b>На правах рекламы \n</b>
""")
                        except Exception as e:
                            print(e)
                            for chat in db_.get_all_chat():
                                await bot.send_message(int(chat['chat_id']), x['msg_text'])
        await my_sleep_func()


class Post:
    msg_id = None
    days = None
    time = None


post = Post()


@dp.message_handler(user_id=ADMINS, commands='check')
async def show_admin_panel(message: types.message, state: FSMContext):
    loop = asyncio.get_event_loop()
    asyncio.ensure_future(Check())
    loop.run_forever()


@dp.message_handler(user_id=ADMINS, commands='admin')
async def show_admin_panel(message: types.message, state: FSMContext):
    await state.finish()
    kwargs = {
        'text': "Нажмите на интересующий вас пункт:",
        'reply_markup': keyboards.main
    }
    try:
        await message.edit_text(**kwargs)
    except MessageCantBeEdited:
        await message.answer(**kwargs)


@dp.callback_query_handler(user_id=ADMINS, text_contains='words:')
async def words_management(callback: types.callback_query):
    words = db.get_words()
    if callback.data.endswith("add"):
        await AdminMessage.add_word.set()
        text = f"Напишите слово для добавления"
    elif callback.data.endswith("del"):
        await AdminMessage.del_word.set()
        text = f"Напишите слово для удаления\nСписок слов:\n" + "\n".join(list(map(str, words)))
    else:
        text = "Список слов:\n" + "\n".join(list(map(str, words)))

    await callback.message.edit_text(text, reply_markup=keyboards.back)
    await callback.answer()


@dp.callback_query_handler(user_id=ADMINS, text_contains='stop:')
async def stop_management(callback: types.callback_query):
    if callback.data == 'stop:':
        await callback.message.edit_text('Стоп-слова', reply_markup=keyboards.stop)
        return await callback.answer()
    stop = db.get_stop()
    if callback.data.endswith("add"):
        await AdminMessage.add_stop.set()
        text = f"Напишите слово для добавления"
    elif callback.data.endswith("del"):
        await AdminMessage.del_stop.set()
        text = f"Напишите слово для удаления\nСписок слов:\n" + "\n".join(list(map(str, stop)))
    else:
        text = "Список слов:\n" + "\n".join(list(map(str, stop)))

    await callback.message.edit_text(text, reply_markup=keyboards.back)
    await callback.answer()


@dp.callback_query_handler(user_id=ADMINS, text='logs')
async def logs_management(callback: types.CallbackQuery):
    csv_file = open(CSV_PATH, 'rb')
    await callback.message.answer_document(csv_file)
    delete_csv_file()
    create_csv_file()


@dp.message_handler(user_id=ADMINS, state=AdminMessage.add_word)
async def add_word(message: types.Message, state: FSMContext):
    # await state.finish()
    db.add_word(message.text)
    await message.answer('Готово', reply_markup=keyboards.back)


@dp.message_handler(user_id=ADMINS, state=AdminMessage.del_word)
async def del_word(message: types.Message, state: FSMContext):
    # await state.finish()
    db.del_word(message.text)
    await message.answer('Готово', reply_markup=keyboards.back)


@dp.message_handler(user_id=ADMINS, state=AdminMessage.add_stop)
async def add_stop(message: types.Message, state: FSMContext):
    # await state.finish()
    db.add_stop(message.text)
    await message.answer('Готово', reply_markup=keyboards.back)


@dp.message_handler(user_id=ADMINS, state=AdminMessage.del_stop)
async def del_stop(message: types.Message, state: FSMContext):
    # await state.finish()
    db.del_stop(message.text)
    await message.answer('Готово', reply_markup=keyboards.back)


@dp.callback_query_handler(user_id=ADMINS, text_contains='chats:')
async def chat_management(callback: types.callback_query):
    chat_id = callback.message.chat.id

    if callback.data.endswith("add"):
        db.add_chat(chat_id)
        text = f"Добавлен чат: <code>{chat_id}</code>"
    elif callback.data.endswith("del"):
        db.del_chat(chat_id)
        print('ok2')
        text = f"Удалён чат: <code>{chat_id}</code>"
    elif callback.data.endswith("show"):
        chats = db.get_chats()
        text = "Список чатов:\n" + "\n".join(list(map(str, chats)))

    await callback.message.edit_text(text)
    await callback.answer()


@dp.callback_query_handler(user_id=ADMINS, text='show_settings')
async def show_current_settings(callback: types.callback_query):
    try:
        settings = db.get_chat(callback.message.chat.id)
        if settings:
            text = (
                "Настройки для чата <code>%s</code>\n\n"
                "Кулдаун (в часах): <b>%s</b>\n"
                "Количество анализируемых сообщений <b>%s</b>\n"
                "Задержка удаления уведомления: <b>%s мин</b>\n"
                "Минимальная длинна анализируемого сообщения: <b>%s</b>"
            )
        else:
            text = "Сначала добавьте чат!"
        await callback.message.edit_text(
            text % settings,
            reply_markup=keyboards.back
        )
        await callback.answer()
    except:
        await callback.answer('Данного чата нет в базе данных! С начала добавьте его', show_alert=True)


@dp.callback_query_handler(user_id=ADMINS, text_contains='set:')
async def settings_management(callback: types.callback_query):
    setting = callback.data.split(':')[1]
    await eval(f"Menu.set.{setting}.set()")
    await callback.message.edit_text(
        texts.settings_hintings[setting],
        reply_markup=keyboards.back
    )
    await callback.answer()


@dp.callback_query_handler(user_id=ADMINS, text=['cancel', 'back'], state='*')
async def back_to_admin_panel(callback: types.callback_query, state: FSMContext):
    await state.finish()
    await show_admin_panel(callback.message, state)
    await callback.answer()


@dp.message_handler(state=Menu.set)
async def set_setting(message: types.message, state: FSMContext, raw_state: str):
    setting, value = raw_state.split(':')[1], message.text

    async def wrong_value():
        await message.answer(
            "Неверное значение!\nПопробуйте ещё "
            "раз, или нажмите \"Отмена\"",
            reply_markup=keyboards.cancel
        )

    try:
        value = int(value)
    except ValueError:
        await wrong_value()
        return

    ranges = {
        'cooldown': range(1, 73),
        'limit_messages': range(1, 151),
        'delay_delete_notification': range(1, 11),
        'minimum_len_message': range(10, 11)
    }
    if value not in ranges[setting]:
        await wrong_value()
        return

    db.update_setting(
        message.chat.id,
        column_name=setting,
        value=value
    )
    await message.answer("Новое значение установлено!")
    await state.finish()


msg_cancel = types.InlineKeyboardMarkup(row_width=1)
msg_cancel_btn = types.InlineKeyboardButton(text='Отмена', callback_data='send_message_cancel')
msg_send_btn = types.InlineKeyboardButton(text='Отправить', callback_data='send_msg')
msg_cancel.add(msg_cancel_btn)


@dp.message_handler(user_id=ADMINS, commands='panic')
async def panic_cmd(message: types.message, state: FSMContext):
    global tasks
    for task in tasks:
        tasks[tasks.index(task)].cancel()
        tasks.pop(tasks.index(task))
    await bot.send_message(message.from_user.id, 'Все отложенные сообщения удалены!')


@dp.callback_query_handler(user_id=ADMINS, text='send_message')
async def choose_type_msg(c: types.CallbackQuery):
    msg_type = types.InlineKeyboardMarkup(row_width=2)
    msg_type_instaln = types.InlineKeyboardButton(text='Моментально', callback_data='instant_msg')
    msg_type_delay = types.InlineKeyboardButton(text='Отложить', callback_data='delay_msg')
    msg_type.add(msg_type_instaln, msg_type_delay)
    await AdminMessage.msg_type.set()
    try:
        await bot.edit_message_text('Выберите, тип отправки сообщения: ', c.from_user.id, c.message.message_id,
                                    reply_markup=msg_type.add(msg_cancel_btn))
    except:
        await c.answer('Используйте отправку сообщений только в лс бота!', show_alert=True)


@dp.callback_query_handler(state='*', text='send_message_cancel')
async def cancel_handler(c: types.CallbackQuery, state: FSMContext):
    current_state = await state.get_state()
    if current_state is None:
        await bot.send_message(c.from_user.id, 'Отменено', reply_markup=types.ReplyKeyboardRemove())
    elif current_state.split(':')[0] == 'AdminMessage':
        await state.finish()
        await bot.delete_message(c.from_user.id, c.message.message_id)
        await bot.send_message(c.from_user.id, 'Отменено', reply_markup=types.ReplyKeyboardRemove())


@dp.callback_query_handler(text='instant_msg', state=AdminMessage.msg_type)
@dp.callback_query_handler(text='delay_msg', state=AdminMessage.msg_type)
async def insert_msg(c: types.CallbackQuery, state: FSMContext):
    async with state.proxy() as data:
        data['msg_type'] = c.data
    await bot.delete_message(c.from_user.id, c.message.message_id)
    await bot.send_message(c.from_user.id, 'Введите сообщение, которое нужно отправить', reply_markup=msg_cancel)
    await AdminMessage.next()


class OutputFormSetDay(StatesGroup):
    Output = State()


@dp.message_handler(content_types=['any'], state=AdminMessage.msg)
async def select_chats(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['msg'] = message
        data['content_type'] = message.content_type
        data['chats'] = []
    chats_id = db.get_chats()
    chats_mkp = types.InlineKeyboardMarkup(row_width=1)
    chats_mkp_ = types.InlineKeyboardMarkup(row_width=1)
    for chat in chats_id:
        try:
            chat_info = await bot.get_chat(chat)
            chats_mkp.add(types.InlineKeyboardButton(text='[-] ' + chat_info.title, callback_data='chat_' + str(chat)))
        except:
            db.del_chat(int(chat))
            await bot.send_message(message.from_user.id, 'Чат - ' + str(
                chat) + ' есть в базе данных, но в нем нету бота. \nДля избежания ошибки, чат был удален с базы данных!')
    chats_mkp.add(types.InlineKeyboardButton(text='Ввести информацию', callback_data='description'))
    if data['msg_type'] == 'delay_msg':
        await bot.send_message(message.from_user.id, 'Введите количество дней отправки сообщений (Например : 1)\n',
                               reply_markup=chats_mkp_.add(msg_cancel_btn))
        post.msg_id = message
        await OutputFormSetDay.Output.set()
        return None
    await data['msg'].send_copy(message.from_user.id)
    await bot.send_message(message.from_user.id, 'Выберите чаты, куда отправить данное сообщение',
                           reply_markup=chats_mkp.add(msg_cancel_btn))
    await AdminMessage.next()


@dp.message_handler(state='*', commands='cancel')
@dp.message_handler(state=OutputFormSetDay.Output)
async def process_name(message: types.Message, state: FSMContext):
    Output = message.text
    post.days = Output
    chats_mkp = types.InlineKeyboardMarkup(row_width=1)
    await bot.send_message(message.from_user.id,
                           "Введите время отправки сообщения через '/'\n Например(14:45/13:35/18:50)",
                           reply_markup=chats_mkp.add(msg_cancel_btn))
    await OutputFormSetTime.Output.set()


class OutputFormSetImg(StatesGroup):
    Output = State()


class OutputFormSetTime(StatesGroup):
    Output = State()


filepath = 'C:/Users/nikit/PycharmProjectsCumShot/photos/'


@dp.message_handler(state='*', commands='cancel')
@dp.message_handler(state=OutputFormSetTime.Output)
async def process_time(message: types.Message, state: FSMContext):
    Output = message.text
    post.time = Output.replace('/', ' ').split()
    chats_mkp = types.InlineKeyboardMarkup(row_width=1)
    await bot.send_message(message.from_user.id,
                           "Отправьте медиа документ к сообщению \n Или 'Нет'",
                           reply_markup=chats_mkp.add(msg_cancel_btn))
    await OutputFormSetImg.Output.set()


@dp.message_handler(state='*', commands='cancel')
@dp.message_handler(state=OutputFormSetImg.Output, content_types=['any'])
async def proctyess_img(message: types.Message, state: FSMContext):
    Output = message.text
    if Output == 'Нет':
        db_.create_ADV(post.msg_id.text, post.days, post.time)
        await bot.send_message(message.from_user.id, "Баннер успешно создан!")
    else:
        file_info = await bot.get_file(message.photo[len(message.photo) - 1].file_id)
        downloaded_file = await bot.download_file(file_info.file_path)
        src = filepath + f'{post.msg_id.message_id}.png'
        with open(src, 'wb') as new_file:
            new_file.write(downloaded_file.getvalue())
        db_.create_ADV(post.msg_id.text, post.days, post.time, src)
        await bot.send_message(message.from_user.id, "Баннер успешно создан!")
    await state.finish()


@dp.callback_query_handler(text_contains='chat_', state=AdminMessage.chats)
async def choose_chat(c: types.CallbackQuery, state: FSMContext):
    async with state.proxy() as data:
        data['chats'].append(c.data.split('_')[1])
    chats_id = db.get_chats()
    chats = ''
    for chat in data['chats']:
        chat_info = await bot.get_chat(chat)
        chats = chats + chat_info.title + '\n'
    chats_mkp = types.InlineKeyboardMarkup(row_width=2)
    for chat in chats_id:
        try:
            chat_info = await bot.get_chat(chat)
            if str(chat) in data['chats']:
                chats_mkp.add(
                    types.InlineKeyboardButton(text='[✅] ' + chat_info.title, callback_data='selectChat_' + str(chat)))
            else:
                chats_mkp.add(
                    types.InlineKeyboardButton(text='[-] ' + chat_info.title, callback_data='chat_' + str(chat)))
        except:
            db.del_chat(int(chat))
            await bot.send_message(c.from_user.id, 'Чат - ' + str(
                chat) + ' есть в базе данных, но в нем нету бота. \nДля избежания ошибки, чат был удален с базы данных!')
    chats_mkp.add(types.InlineKeyboardButton(text='Ввести информацию', callback_data='description'))
    if chats == '':
        await bot.edit_message_text('Сообщение будет отправлено в данные чаты: \n \n' + chats, c.from_user.id,
                                    c.message.message_id, reply_markup=chats_mkp.add(msg_cancel_btn))
    else:
        await bot.edit_message_text('Сообщение будет отправлено в данные чаты: \n \n' + chats, c.from_user.id,
                                    c.message.message_id, reply_markup=chats_mkp.add(msg_send_btn, msg_cancel_btn))


@dp.callback_query_handler(text_contains='selectChat_', state=AdminMessage.chats)
async def choose_chat(c: types.CallbackQuery, state: FSMContext):
    async with state.proxy() as data:
        for i in range(5):
            try:
                data['chats'].remove(c.data.split('_')[1])
            except:
                pass
    chats_id = db.get_chats()
    chats = ''
    for chat in data['chats']:
        chat_info = await bot.get_chat(chat)
        chats = chats + chat_info.title + '\n'
    chats_mkp = types.InlineKeyboardMarkup(row_width=2)
    for chat in chats_id:
        try:
            chat_info = await bot.get_chat(chat)
            if str(chat) in data['chats']:
                chats_mkp.add(
                    types.InlineKeyboardButton(text='[✅] ' + chat_info.title, callback_data='selectchat_' + str(chat)))
            else:
                chats_mkp.add(
                    types.InlineKeyboardButton(text='[-] ' + chat_info.title, callback_data='chat_' + str(chat)))
        except:
            db.del_chat(int(chat))
            await bot.send_message(c.from_user.id, 'Чат - ' + str(
                chat) + ' есть в базе данных, но в нем нету бота. \nДля избежания ошибки, чат был удален с базы данных!')
    chats_mkp.add(types.InlineKeyboardButton(text='Ввести информацию', callback_data='description'))
    if chats == '':
        await bot.edit_message_text('Сообщение будет отправлено в данные чаты: \n \n' + chats, c.from_user.id,
                                    c.message.message_id, reply_markup=chats_mkp.add(msg_cancel_btn))
    else:
        await bot.edit_message_text('Сообщение будет отправлено в данные чаты: \n \n' + chats, c.from_user.id,
                                    c.message.message_id, reply_markup=chats_mkp.add(msg_send_btn, msg_cancel_btn))


@dp.callback_query_handler(text='description', state=AdminMessage.chats)
async def insert_descriprion(c: types.CallbackQuery, state: FSMContext):
    back_to_chats = types.InlineKeyboardMarkup(row_width=1)
    await bot.edit_message_text('Введите информацию:', c.from_user.id, c.message.message_id,
                                reply_markup=back_to_chats.add(
                                    types.InlineKeyboardButton('Назад', callback_data='back_to_chats')))
    await AdminMessage.next()


@dp.message_handler(state=AdminMessage.description)
async def descriptions(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        if data['content_type'] == 'text':
            data['msg'].text = '💰 <b>' + 'На правах рекламы' + '</b> \n \n' + data[
                'msg'].text + '\n \n 💰 <b>' + 'На правах рекламы' + '</b> \n \n'
            await bot.send_message(message.from_user.id, data['msg'].text)
        elif data['content_type'] == 'photo':
            if data['msg'].caption:
                data['msg'].caption = '💰 <b>' + 'На правах рекламы' + '</b> \n \n' + data[
                    'msg'].caption + '💰 <b>' + 'На правах рекламы' + '</b> \n \n'
            else:
                data[
                    'msg'].caption = '💰 <b>' + 'На правах рекламы' + '</b> \n \n' + '💰 <b>' + 'На правах рекламы' + '</b> \n \n'
        elif data['content_type'] == 'video':
            if data['msg'].caption:
                data['msg'].caption = '💰 <b>' + 'На правах рекламы' + '</b> \n \n' + data[
                    'msg'].caption + '💰 <b>' + 'Нна правах рекламы' + '</b> \n \n'
            else:
                data[
                    'msg'].caption = '💰 <b>' + 'Текст на правах рекламы' + '</b> \n \n' + '💰 <b>' + 'Текст на правах рекламы' + '</b> \n \n'
            await bot.send_video(message.from_user.id, data['msg'].video.file_id, caption=data['msg'].caption)
        else:
            state.finish()
            await bot.send_message(message.from_user.id, 'Принимаем только текст, фото и видео!')
    chats_id = db.get_chats()
    chats = ''
    for chat in data['chats']:
        chat_info = await bot.get_chat(chat)
        chats = chats + chat_info.title + '\n'
    chats_mkp = types.InlineKeyboardMarkup(row_width=2)
    for chat in chats_id:
        chat_info = await bot.get_chat(chat)
        if str(chat) in data['chats']:
            chats_mkp.add(
                types.InlineKeyboardButton(text='[✅] ' + chat_info.title, callback_data='selectchat_' + str(chat)))
        else:
            chats_mkp.add(types.InlineKeyboardButton(text='[-] ' + chat_info.title, callback_data='chat_' + str(chat)))
    if chats == '':
        await bot.send_message(message.from_user.id, 'Сообщение будет отправлено в данные чаты: \n \n' + chats,
                               reply_markup=chats_mkp.add(msg_cancel_btn))
    else:
        await bot.send_message(message.from_user.id, 'Сообщение будет отправлено в данные чаты: \n \n' + chats,
                               reply_markup=chats_mkp.add(msg_send_btn, msg_cancel_btn))
    await AdminMessage.previous()


@dp.callback_query_handler(text='back_to_chats', state=AdminMessage.description)
async def insert_descriprion(c: types.CallbackQuery, state: FSMContext):
    async with state.proxy() as data:
        pass
    chats_id = db.get_chats()
    chats = ''
    for chat in data['chats']:
        chat_info = await bot.get_chat(chat)
        chats = chats + chat_info.title + '\n'
    chats_mkp = types.InlineKeyboardMarkup(row_width=2)
    for chat in chats_id:
        chat_info = await bot.get_chat(chat)
        if str(chat) in data['chats']:
            chats_mkp.add(
                types.InlineKeyboardButton(text='[✅] ' + chat_info.title, callback_data='selectchat_' + str(chat)))
        else:
            chats_mkp.add(types.InlineKeyboardButton(text='[-] ' + chat_info.title, callback_data='chat_' + str(chat)))
    chats_mkp.add(types.InlineKeyboardButton(text='Ввести информацию', callback_data='description'))
    if chats == '':
        await bot.edit_message_text('Сообщение будет отправлено в данные чаты: \n \n' + chats, c.from_user.id,
                                    c.message.message_id, reply_markup=chats_mkp.add(msg_cancel_btn))
    else:
        await bot.edit_message_text('Сообщение будет отправлено в данные чаты: \n \n' + chats, c.from_user.id,
                                    c.message.message_id, reply_markup=chats_mkp.add(msg_send_btn, msg_cancel_btn))
    await AdminMessage.previous()


@dp.callback_query_handler(text='send_msg', state=AdminMessage.chats)
async def send_msg_chats(c: types.CallbackQuery, state: FSMContext):
    async with state.proxy() as data:
        pass
    if data['msg_type'] == 'instant_msg':
        await bot.delete_message(c.from_user.id, c.message.message_id)
        await bot.send_message(c.from_user.id, 'Рассылка началась!')
        if data['content_type'] == 'text':
            for chat in data['chats']:
                await bot.send_message(int(chat), data['msg'].text)
        elif data['content_type'] == 'photo':
            for chat in data['chats']:
                await bot.send_photo(int(chat), data['msg'].photo[0].file_id, data['msg'].caption)
        elif data['content_type'] == 'video':
            for chat in data['chats']:
                await bot.send_video(int(chat), data['msg'].video.file_id, caption=data['msg'].caption)
        await bot.send_message(c.from_user.id, 'Рассылка окончена!')
        await state.finish()

    elif data['msg_type'] == 'delay_msg':
        await bot.delete_message(c.from_user.id, c.message.message_id)
        await bot.send_message(c.from_user.id, 'Введите время отправки сообщения в формате чч:мм',
                               reply_markup=msg_cancel)
        await AdminMessage.set_time.set()


@dp.message_handler(state=AdminMessage.set_time)
async def set_time(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['set_time'] = message.text
    datas = [data['msg'], data['content_type'], data['chats'], data['set_time'], message.from_user.id]
    await bot.send_message(message.from_user.id, 'Рассылка начата!')
    global tasks
    task = asyncio.ensure_future(scheduled_sender(datas))
    tasks.append(task)
    await state.finish()


async def scheduled_sender(data):
    task = ''
    message = data[0]
    content_type = data[1]
    chates = data[2]
    interval = data[3]
    admin_id = data[4]
    do_it = 0
    while True:
        if do_it == 1:
            for chat in chates:
                try:
                    if content_type == 'text':
                        await bot.send_message(int(chat), message.text)
                    elif content_type == 'photo':
                        await bot.send_photo(int(chat), message.photo[0].file_id, message.caption)
                    elif content_type == 'video':
                        await bot.send_video(int(chat), message.video.file_id, caption=message.caption)
                except Exception as ex:
                    print(ex)
            await bot.send_message(admin_id, 'Рассылка окончена!')
            return await del_task(task)
        else:
            task = (tasks[-1])
            do_it = do_it + 1
            a = timedelta(hours=int(interval.split(':')[0]), minutes=int(interval.split(':')[1]))
            b = timedelta(hours=datetime.now(pytz.timezone('Europe/Moscow')).time().hour,
                          minutes=datetime.now(pytz.timezone('Europe/Moscow')).time().minute,
                          seconds=datetime.now(pytz.timezone('Europe/Moscow')).time().second)
            c = a - b
            try:
                d = str(c).split(', ')[1].split(':')
            except:
                d = str(c).split(':')
            seconds = (int(d[0]) * 60 + int(d[1])) * 60 + int(d[2])
            await asyncio.sleep(seconds)


async def del_task(task):
    global tasks
    tasks[tasks.index(task)].cancel()
    tasks.remove(task)