""" Connects discord with skype as a relay """

# Import Built-Ins
import asyncio
import logging
import sys
import threading
import time
from html import unescape

# Import Third-Party
import discord
from daemonize import Daemonize
from raven import Client
from raven.conf import setup_logging
from raven.handlers.logging import SentryHandler
from skpy import Skype, SkypeNewMessageEvent, SkypeEventLoop, SkypeMsg
from telegram.ext import Updater, MessageHandler, Filters

# Discord
admins = ["urbano#9519", "wojtekj#2564"]
discord_message_list = []
bots = ["Skype-bot#0724", "wojtekjBOT#2057", "RektBOT#1742", "DiscordBOT#3372"]
discord_write_channel = discord.Object(id='290573398961291264')  # Production
login_token = 'MzQ3MzYxNzU1NzUzODczNDA5.DHXR2g.N1-pjOsSWYUPL2OW9_xuMhdH9oU'  # Production


# Skype
skype_username = "discord-bot-123@protonmail.com"
skype_password = "CHOCHObtcMOON2.."
skype_group_url = "https://join.skype.com/nKBBN8kaFXb7"  # production
skype_group2_url = "https://join.skype.com/pbuuJZjtGHlV"  # production
skype_write_channel1 = "19:I2RraW5ndHVybmVyLyRtYXJ0aW4ubnlnYXJkMjthYjM1YjU5Yzk5MjI0Y2Q3@p2p.thread.skype"  # production
skype_write_channel2 = "19:bf64973ecb634ffdbc948132818a2c9e@thread.skype"  # production
skype_online = False
skype_message_list = []

# Telegram
TELEGRAM_TOKEN = '474466581:AAF2e6jva-D20JkB8YDdH3-JW7grz7VWbt8'
telegram_write_channel = ""

TelegramUpdater = Updater(token=TELEGRAM_TOKEN)


# Raven
client = Client("https://6276ca312fc74bb1a0258a6c70785ef5:0f221a6657e64923a63fdd3ad955cb2a@sentry.io/217820")
handler = SentryHandler(client)
handler.setLevel(logging.ERROR)
setup_logging(handler)
logger = logging.getLogger(__name__)


def is_gif(message):
    return bool([gif for gif in [".gif", "giphy.com"] if gif in message])


def format_tags(message):
    # 1 find number of tags
    tags_a = message.count('<')
    tags_b = message.count('>')

    n = min([tags_a, tags_b])

    if "<quote author=" in message:
        # Parsing skype quote
        message = message.replace('<<<', '')

        tabs = []
        for n in range(n):
            try:
                txt = message.split("<")[n].split(">")[0]
            except KeyError:
                logger.error("Error solving quotes", exc_info=True)
            else:
                tabs.append(txt)

        for tab in tabs:
            message = message.replace(tab, "")

        message = message.replace("<", "").replace(">", "").replace("quote", "").replace("//", "")

    message = message.replace("</b>", "*")

    return message


def push(platform, user, message, channel="both"):
    if platform == "skype" and skype_online:
        global discord_message_list
        message = message.replace("`", "")
        discord_message_list.append([user.split("#")[0], message, channel])
        x.write_message()

        return True

    elif platform == "discord":
        global skype_message_list
        message = unescape(message)
        message = format_tags(message)

        if not message.strip():
            logger.warning("No message after parsing")
            return True

        t = user + ": " + message
        text = "```LDIF\n" + t + "\n```"
        skype_message_list.append(text)

        return True

    elif platform == "telegram":
        TelegramUpdater.bot.send_message(chat_id=telegram_write_channel, text=user + ": " + message)


class DiscordBot(discord.Client):
    async def on_message(self, message):
        if not str(message.author) in bots:

            if message.content.startswith('!stick'):
                if str(message.author) in admins:
                    global discord_write_channel
                    discord_write_channel = message.channel

            else:
                if not message.content.startswith('!'):
                    if str(message.channel) == "general":
                        push("skype", str(message.author), str(message.clean_content))
                        push("telegram", str(message.author), str(message.clean_content))
                    else:
                        logger.error("Wrong channel!", extra={"stack": True})

    async def on_ready(self):
        logger.info("Discord ok")


async def new_mesage():
    await asyncio.sleep(5)
    while not discord_bot.is_closed:
        global skype_message_list
        if skype_message_list:
            message = skype_message_list.pop(0)
            if message:
                logger.info("Sending Discord: " + message)
                await discord_bot.send_message(discord_write_channel, message)

        await asyncio.sleep(0.15)


class SkypeBot(SkypeEventLoop):
    def __init__(self):
        super(SkypeBot, self).__init__(skype_username, skype_password)
        self.skype = Skype(skype_username, skype_password)

        global skype_write_channel1
        global skype_write_channel2

        skype_write_channel1 = self.chats.urlToIds(skype_group_url).get('id')
        skype_write_channel2 = self.chats.urlToIds(skype_group2_url).get('id')

        global skype_online
        skype_online = True

    def write_message(self):
        global discord_message_list
        message = discord_message_list.pop(0)
        channel = message[2]
        user_name = message[0]

        if not user_name:
            user_name = "Ghost"  # Hotfix

        message = SkypeMsg.bold(user_name) + ": " + message[1]

        if channel == "both":  # Sent from discord
            self.chat_group = self.chats.chat(skype_write_channel1)
            self.chat_group.sendMsg(message, rich=True)
            self.chat_group = self.chats.chat(skype_write_channel2)
            self.chat_group.sendMsg(message, rich=True)

        else:
            logger.warning("Wrong channel", extra={"stack": True})

    def onEvent(self, event):
        if not isinstance(event, SkypeNewMessageEvent):
            return None

        msg = {
            "skype_username": self.contacts[event.msg.userId].name,
            "message_string": event.msg.plain
        }

        if event.msg.userId != self.userId and event.msg.userId != "live:skype-bot-123" and not event.msg.content.startswith("!"):
            channel = str(event.msg.chatId)

            if channel == skype_write_channel1 or channel == skype_write_channel2:
                push("discord", str(msg["skype_username"]), str(msg["message_string"]), channel)
                push("telegram", str(msg["skype_username"]), str(msg["message_string"]), channel)

            else:
                logger.warning("I'm getting stalked", extra={'stack': True})


x = ""
skype_state = True


def start_skype():
    while skype_state:
        logger.info("Starting Thread")
        global x
        x = SkypeBot()  # Starts bot in skype
        t = threading.Thread(target=x.loop)  # Loop message
        t.start()

        while t.isAlive():
            time.sleep(1)

        logger.warning("Skype Dead from inside", exc_info=True)


discord_bot = DiscordBot()


def push_from_telegram(bot, update):
    """
    Listens telegram updates via dispatcher.add_handler
    All Telegram updates hits that function.
    """
    username = update.message.from_user.username
    message = update.message.text

    # To discord
    push("discord", username, message)

    # To skype
    push("skype", username, message)


def telegram_listener():
    """
    Starts Telegram bot, and it stays there.
    Better to use in a thread.
    """
    # Init
    dispatcher = TelegramUpdater.dispatcher

    # Setup listener
    echo_handler = MessageHandler(Filters.text | Filters.photo, push_from_telegram)
    dispatcher.add_handler(echo_handler)

    # Start listener
    TelegramUpdater.start_webhook(listen='127.0.0.1', port=5000, url_path=TELEGRAM_TOKEN)
    TelegramUpdater.bot.set_webhook(url='https://pyderman.com/' + TELEGRAM_TOKEN)
    TelegramUpdater.idle()


class RelayBot:
    def __init__(self):
        self.run()

    def run(self):
        skype_thread = threading.Thread(target=start_skype)
        skype_thread.start()

        telegram_thread = threading.Thread(target=telegram_listener)
        telegram_thread.start()

        try:
            discord_bot.loop.create_task(new_mesage())
            discord_bot.loop.run_until_complete(discord_bot.start(login_token))

        except Exception as e:
            logger.error(str(e), exc_info=True)
            discord_bot.loop.run_until_complete(discord_bot.logout())
            pending = asyncio.Task.all_tasks()
            gathered = asyncio.gather(*pending)

            gathered.cancel()
            discord_bot.loop.run_forever()
            gathered.exception()

        sys.exit(0)


worker = RelayBot()

pid = "/tmp/discord_relay.pid"
daemon = Daemonize(app="discord_relay", pid=pid, action=worker)
daemon.start()