import unittest
from unittest.mock import patch

import warnings
from telegram.utils import request as tg_utils_request
from telegram.utils.request import Request
from telegram.utils.deprecate import TelegramDeprecationWarning
from telegram.ext import Updater
from telegram import User as tg_User
from telegram import Chat as tg_Chat
from ptbtest import ChatGenerator
from ptbtest import Mockbot
from ptbtest import UserGenerator
from ptbtest import CallbackQueryGenerator
from subprocess import run as subprocess_run

import config
import keyboards
from top_level_funcs import end_conversation
import conv_handlers


# # # file postconfig.py  # # #
from telegram import Bot
...
bot = Bot(token='some_token')
# # # end file postconfig.py  # # #


"""
This is an example to show how the ptbtest suite can be used.
https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/echobot2.py
"""

warnings.filterwarnings("ignore", category=TelegramDeprecationWarning)


# noinspection PyPep8Naming
class Mockbot(Mockbot):

    def __init__(self, request: Request = None, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.request = request or tg_utils_request.Request(connect_timeout=3, read_timeout=3, con_pool_size=16)
        self._current_keyboard = None
        self._current_markup = None
        self.end_conversation = end_conversation

    @Mockbot.message
    def CopyMessage(
            self,
            chat_id: int,
            from_chat_id: int,
            message_id: int,
            caption: str = None,
            parse_mode: str = None,
            caption_entities: list = None,
            disable_notification: bool = None,
            reply_to_message_id: int = None,
            allow_sending_without_reply: bool = None,
            reply_markup=None,
            timeout: float = None,
            api_kwargs: dict = None,
    ):
        data = {"chat_id": chat_id}
        if caption:
            # data['caption'] = caption
            data['text'] = caption
        if parse_mode:
            data["parse_mode"] = parse_mode
        if caption_entities:
            data["caption_entities"] = caption_entities

        return data

    @Mockbot.message
    def SendMediaGroup(
            self,
            chat_id,
            media,
            disable_notification=None,
            reply_to_message_id=None,
            timeout=20,
            api_kwargs=None,
            allow_sending_without_reply=None
    ):
        data = {"chat_id": chat_id, "media": media}

        return data

    @property
    def current_keyboard(self):
        return self.sent_messages[-1]['reply_markup']['keyboard']

    @property
    def current_markup(self):
        return self.sent_messages[-1]['reply_markup']

    def sent_answer(self, is_answer: str,
                    index: int = -1,
                    key: str = 'text',
                    _lower: bool = True,
                    _strip: bool = True,
                    _startswith: bool = True):
        bot_text = self.sent_messages[index][key]
        if key == 'text':
            if _lower:
                bot_text = bot_text.lower()
            if _strip:
                bot_text = bot_text.strip()
            if _startswith:
                return bot_text.startswith(is_answer)
        return bot_text

    send_media_group = SendMediaGroup
    copy_message = CopyMessage


class User:

    def __init__(self, user: tg_User, chat: tg_Chat, bot: Mockbot, user_data: dict, cqg: CallbackQueryGenerator):
        self.user = user
        self.chat = chat
        self.bot = bot
        self.user_data = user_data
        self.mg = self.bot.mg
        self.cqg = cqg

    def send_text(self, text: str, parse_mode: str = "HTML", message_id: int = None) -> None:
        update = self.mg.get_message(user=self.user, chat=self.chat, text=text, parse_mode=parse_mode, id=message_id)
        self.bot.insertUpdate(update=update)


bot = Mockbot()


@patch("postconfig.bot", bot)
class TestConversation(unittest.TestCase):  # IsolatedAsyncioTestCase - for async
    def setUp(self):  # name method should be exactly "setUp"
        # self.bot = Mockbot()
        self.bot = bot
        self.mg = self.bot.mg
        self.updater = Updater(bot=self.bot)
        self.dispatcher = self.updater.dispatcher
        self.dispatcher.add_handler(conv_handlers.registration)
        self.dispatcher.add_handler(conv_handlers.partner)
        self.dispatcher.add_handler(conv_handlers.create_post)
        self.chat_generator = ChatGenerator()
        self.user_generator = UserGenerator()
        self.cqg = CallbackQueryGenerator()
        self.botmock = patch("postconfig.bot", self.bot)
        self.botmock.return_value = self.bot
        self.addCleanup(self.updater.stop)

    @patch("postconfig.bot", bot)
    def test_reg_steps(self, user: User):
        self.botmock = patch("postconfig.bot", self.bot)
        self.botmock.return_value = self.bot
        user.send_text(text="/reg")
        self.assertTrue(self.bot.sent_answer(is_answer='отличное решение!'))
        user.send_text(text="Поехали")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 1 из 7'))
        user.send_text(text="David")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 2 из 7'))
        user.send_text(text="Общаться")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 3 из 7'))
        user.send_text(text="Я парень")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 4 из 7'))
        user.send_text(text="33")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 5 из 7'))
        user.send_text(text="Пропустить")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 6 из 7'))
        user.send_text(text="Готово")
        self.assertTrue(self.bot.sent_answer(is_answer='шаг 7 из 7'))
        user.send_text(text="Я бот из тестов")
        self.assertTrue(self.bot.sent_answer(is_answer='так будет', index=-2))  # -2 because sent 2 messages
        user.send_text(text="Готово")
        self.assertTrue(self.bot.sent_answer(is_answer='поздравляю'))

    @patch("postconfig.bot", bot)
    def test_reg_conv(self, user: User):
        # self.updater.start_polling()
        self.botmock = patch("postconfig.bot", self.bot)
        self.botmock.return_value = self.bot
        self.test_reg_steps(user=user)

    @patch("postconfig.bot", bot)
    def test_conversations(self):
        self.botmock = patch("postconfig.bot", self.bot)
        self.botmock.return_value = self.bot
        self.updater.start_polling()  # returns update_queue obj
        user = User(user := self.user_generator.get_user(id=177381168),
                    chat=self.chat_generator.get_chat(type="group"),
                    bot=self.bot,
                    user_data=self.dispatcher.user_data[user.id],
                    cqg=self.cqg)
        self.test_reg_conv(user=user)


if __name__ == '__main__':
    unittest.main()