from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from notifypy import Notify
import sys, keyring, threading, queue, asyncio, urllib, appdirs, os, time, pleroma, re, magic, monkeypatch, requests, misc, json, timeconvert, videowidget, audiowidget

CACHE = appdirs.AppDirs('plchat', 'plchat').user_cache_dir
APPDATA = appdirs.AppDirs('plchat', 'plchat').user_data_dir
THREADS = {}
STATIC_PREF = ''
ICON_PATH = 'fedi.svg'

class App(QMainWindow):
    settings = QSettings()
    _eventloop = asyncio.new_event_loop()
    accts = {}

    def __init__(self, processEvents):
        super().__init__()
        self.title = 'PlChat'
        self.processEvents = processEvents
        self.initUI()

    def initUI(self):
        self.setWindowTitle(self.title)
        self.setWindowIcon(QIcon(QPixmap(ICON_PATH)))
        self.setGeometry(self.settings.value('left', type=int) or 10, self.settings.value('top', type=int) or 10, self.settings.value('width', type=int) or 640, self.settings.value('height', type=int) or 480)

        self._exit = False
        self.Err = QErrorMessage()

        exitAction = QAction('&Exit', self)
        exitAction.setShortcut('Ctrl+Q')
        exitAction.setToolTip('Exit application')
        exitAction.triggered.connect(self.exitActionTrigger)

        newChatAction = QAction('New Chat', self, triggered=self.newChatDialog)
        newChatAction.setShortcut('Ctrl+N')
        newChatAction.setToolTip('Add a new chat')

        closeChatAction = QAction('Close Chat', self, triggered=self.closeTab)
        closeChatAction.setShortcut('Ctrl+W')
        closeChatAction.setToolTip('Close the current chat tab')

        newAcctAction = QAction('New Account', self, triggered=self.newAcctDialog)
        newAcctAction.setShortcut('Ctrl+Shift+N')
        newAcctAction.setToolTip('Add a new account')

        logoutAction = QAction('Logout', self, triggered=self.logout)
        logoutAction.setToolTip('Log out of the current account')

        reopenAction = QAction('Reopen All Chats', self, triggered=self.reopenAll)
        reopenAction.setToolTip('In case something breaks')

        contactAction = QAction('Contact', self, triggered=self.contactDialog)
        licenseAction = QAction('License', self, triggered=self.licenseDialog)

        self.closeToTrayAction = QAction('Close To System Tray', self, checkable=True)
        self.closeToTrayAction.setChecked(self.settings.value('closeToTray', type=bool))

        self.openInTrayAction = QAction('Open In System Tray', self, checkable=True)
        self.openInTrayAction.setChecked(self.settings.value('openInTray', type=bool))
        self.openInTrayAction.setToolTip('Does nothing if not also closing to tray.')

        self.animatePicturesAction = QAction('Display Animations', self, checkable=True)
        self.animatePicturesAction.setChecked(self.settings.value('animatePictures', type=bool))
        self.animatePicturesAction.changed.connect(updateAnimationPref)

        self.fetchBackgroundsAction = QAction("Fetch Backgrounds", self, checkable=True)
        self.fetchBackgroundsAction.setChecked(self.settings.value('fetchBackgrounds', type=bool))
        self.fetchBackgroundsAction.setToolTip("Most instances do not set this in a way that PlChat can check for. It will (probably) not work like you expect, but there is nothing I can do about it.")

        self.darkModeAction = QAction("Dark Mode", self, checkable=True)
        self.darkModeAction.setChecked(self.settings.value('darkMode', type=bool))
        self.darkModeAction.setToolTip("Only affects chat bubbles")

        self.sendNotificationsAction = QAction("Send Notifications", self, checkable=True)
        self.sendNotificationsAction.setChecked(self.settings.value('sendNotifications', type=bool))

        self.fetchHeadersAction = QAction("Fetch Headers", self, checkable=True)
        self.fetchHeadersAction.setChecked(self.settings.value('fetchHeaders', type=bool))

        self.twoFourTimeAction = QAction("Display 24-Hour Time", self, checkable=True)
        self.twoFourTimeAction.setChecked(self.settings.value('twoFourTime', type=bool))

        self.acctComboBox = QComboBox(self)
        self.acctComboBox.currentIndexChanged.connect(self.acctSwitch)
        acctComboBoxAction = QWidgetAction(self)
        acctComboBoxAction.setDefaultWidget(self.acctComboBox)
        self.acctComboBox.show()

        menubar = self.menuBar()

        if self.closeToTrayAction.isChecked():
            systraymenu = QMenu()
        
            hideAction = QAction("Hide", self, triggered=self.hide)
            showAction = QAction("Show", self, triggered=self.show)

            systraymenu.addAction(showAction)
            systraymenu.addAction(hideAction)
            systraymenu.addAction(exitAction)

            self.trayIcon = QSystemTrayIcon()
            self.trayIcon.setIcon(QIcon(ICON_PATH))
            self.trayIcon.setVisible(True)
            self.trayIcon.setToolTip("PlChat")
            self.trayIcon.setContextMenu(systraymenu)
            self.trayIcon.activated.connect(self.systrayClicked)
        else:
            self.trayIcon = None
        
        filemenu = menubar.addMenu("File")
        filemenu.addAction(newChatAction)
        filemenu.addAction(closeChatAction)
        filemenu.addAction(newAcctAction)
        filemenu.addAction(exitAction)

        editmenu = menubar.addMenu("Edit")
        editmenu.addAction(reopenAction)
        editmenu.setToolTipsVisible(True)

        prefsmenu = editmenu.addMenu("Preferences")
        prefsmenu.addAction(self.closeToTrayAction)
        prefsmenu.addAction(self.openInTrayAction)
        prefsmenu.addAction(self.animatePicturesAction)
        prefsmenu.addAction(self.darkModeAction)
        prefsmenu.addAction(self.sendNotificationsAction)
        prefsmenu.addAction(self.fetchBackgroundsAction)
        prefsmenu.addAction(self.fetchHeadersAction)
        prefsmenu.addAction(self.twoFourTimeAction)
        prefsmenu.setToolTipsVisible(True)

        accountmenu = menubar.addMenu('Accounts')
        accountmenu.addAction(acctComboBoxAction)
        accountmenu.addSeparator()
        accountmenu.addAction(logoutAction)

        aboutmenu = menubar.addMenu('About')
        aboutmenu.addAction(contactAction)
        aboutmenu.addAction(licenseAction)

        self.tabs = QTabWidget()
        self.tabs.setMovable(True)
        self.tabs.setTabsClosable(True)
        self.tabs.tabCloseRequested.connect(self.closeTab)
        self.tabs.currentChanged.connect(self.changeTab)
        self.setFocusProxy(self.tabs)

        self.setCentralWidget(self.tabs)

        if not self.openInTrayAction.isChecked() or not self.closeToTrayAction.isChecked():
            self.show()

        self.HeaderFont = QFont()
        self.HeaderFont.setPointSize(16)
        self.headerEmojiFontSize = QFontMetrics(self.HeaderFont).height()

        self.defaultFontMetrics = QFontMetrics(QFont())
        self.emojiFontSize = self.defaultFontMetrics.height()

        self.TimestampFont = QFont()
        self.TimestampFont.setPointSize(7)

        self.installEventFilter(self)

        asyncio.set_event_loop(self._eventloop)
        self._eventloop.call_soon(self.eventLoop)

        acctList = self.settings.value('acctList', type=list)
        if not acctList:
            self.newAcctDialog()
            return
        for acct in acctList:
            CallThread(getAvi, None, acct['instance'])
            self.initAcct(acct['instance'], acct['username'])

    def systrayClicked(self, reason):
        if reason == QSystemTrayIcon.Trigger:
            if self.isVisible():
                self.hide()
            else:
                self.show()

    def eventLoop(self):
        # Custom event loop to process queue events
        self.processEvents()
        self._eventloop.call_soon(self.eventLoop)
        monkeypatch.sleep(0.01)

    def exitActionTrigger(self):
        self._exit = True
        self.close()

    def closeEvent(self, event):
        if not self._exit and self.closeToTrayAction.isChecked():
            self.hide()
            return
        self.settings.setValue("left", self.x())
        self.settings.setValue("top", self.y())
        self.settings.setValue("width", self.width())
        self.settings.setValue("height", self.height())
        self.settings.setValue("closeToTray", self.closeToTrayAction.isChecked())
        self.settings.setValue("openInTray", self.openInTrayAction.isChecked())
        self.settings.setValue("animatePictures", self.animatePicturesAction.isChecked())
        self.settings.setValue("darkMode", self.darkModeAction.isChecked())
        self.settings.setValue("fetchBackgrounds", self.fetchBackgroundsAction.isChecked())
        self.settings.setValue("sendNotifications", self.sendNotificationsAction.isChecked())
        self.settings.setValue("fetchHeaders", self.fetchHeadersAction.isChecked())
        self.settings.setValue("twoFourTime", self.twoFourTimeAction.isChecked())
        event.accept()
        self._eventloop.stop()

    def getCurrentAcc(self):
        if self.acctComboBox.currentIndex() == -1 or not self.accts:
            return (False, False)
        # Returns username, instance
        return self.acctComboBox.currentText().split('@')[1], self.acctComboBox.currentText().split('@')[2]

    def newAcctDialog(self):
        dialog = LoginDialog(self)
        dialog.getInput(self.initAcct)

    def newChatDialog(self):
        u, i = self.getCurrentAcc()
        text, ok = QInputDialog.getText(self, 'Start A New Chat', "Username:", QLineEdit.Normal, "")
        if ok:
            if len(text) < 1:
                self.Err.showMessage("No text provided")
            else:
                if text[0] == '@':
                    text = text[1:]
                if text.find('@'+i) != -1:
                    text = text.replace('@'+i, '')
                CallThread(self.accts[u+i].getAcctInfo, self.newChatReady, text).start()
    
    def newChatReady(self, result):
        if result is None:
            self.Err.showMessage("I couldn't find that user!")
        elif not result['pleroma']['accepts_chat_messages']:
            self.Err.showMessage("This user is on instance that does not support pleroma chats.\nIt may be too old, or it may not be pleroma.")
        else:
            u, i = self.getCurrentAcc()
            closedList = self.settings.value('closed'+u+i, type=list) or []
            for ind in range(0,(len(closedList))):
                if closedList[ind] == result['acct']:
                    del closedList[ind]
                    break
            self.settings.setValue('closed'+u+i, closedList)
            CallThread(self.accts[u+i].addChat, self.populateChats, result['id']).start()

    def contactDialog(self):
        dialog = ContactCard(self)
        dialog.show()
    
    def licenseDialog(self):
        dialog = LicenseCard(self)
        dialog.show()

    def reopenAll(self):
        u, i = self.getCurrentAcc()
        if not u or not i:
            return
        self.settings.setValue('closed'+u+i, [])
        CallThread(self.accts[u+i].listChats, self.populateChats).start()

    def initAcct(self, instance, username, password=None):
        if password:
            acct = pleroma.Account(instance, username, password)
        else:
            token = keyring.get_password('plchat', instance+username+'access_token')
            refresh_token = keyring.get_password('plchat', instance+username+'refresh_token')
            clientID = keyring.get_password('plchat', instance+username+'clientID')
            clientSecret = keyring.get_password('plchat', instance+username+'clientSecret')
            acct = pleroma.Account(instance, username,
                token=token,
                refresh_token=refresh_token,
                clientID=clientID,
                clientSecret=clientSecret
            )
        RegisterThread(acct, self.doneRegister).start()

    def doneRegister(self, acct):
        self.accts[acct.username+acct.instance] = acct
        self.acctComboBox.addItem('@'+acct.username+'@'+acct.instance)
        acctList = self.settings.value('acctList', type=list) or []
        concat = True
        for acc in acctList:
            if acc['username'] == acct.username and acc['instance'] == acct.instance:
                concat = False
        if concat:
            acctList.append({"username": acct.username, "instance": acct.instance})
        self.settings.setValue('acctList', acctList)

        keyring.set_password('plchat', acct.instance+acct.username+'access_token', acct.token)
        keyring.set_password('plchat', acct.instance+acct.username+'refresh_token', acct.refresh_token)
        keyring.set_password('plchat', acct.instance+acct.username+'clientID', acct.clientID)
        keyring.set_password('plchat', acct.instance+acct.username+'clientSecret', acct.clientSecret)

        CallThread(getAvi, None, acct.instance).start()
        CallThread(acct.getInstanceInfo, None).start()

    def logout(self):
        u, i = self.getCurrentAcc()
        if not u or not i:
            print("Couldn't log out")
            return
        self.acctComboBox.removeItem(self.acctComboBox.currentIndex())
        del self.accts[u+i]
        acctList = self.settings.value('acctList', type=list)
        for j in range(len(acctList)):
            if acctList[j]['username'] == u and acctList[j]['instance'] == i:
                keyring.delete_password("plchat", i+u+'access_token')
                keyring.delete_password("plchat", i+u+'refresh_token')
                keyring.delete_password("plchat", i+u+'clientID')
                keyring.delete_password("plchat", i+u+'clientSecret')
                del acctList[j]
        self.settings.setValue('acctList', acctList)

    def acctSwitch(self):
        u, i = self.getCurrentAcc()
        if u+i in self.accts and 'title' in self.accts[u+i].getInstanceInfo():
            self.setWindowTitle(self.accts[u+i].getInstanceInfo()['title']+' Chat')
        else:
            self.setWindowTitle('PlChat')
        self.tabs.clear()
        CallThread(self.accts[u+i].listChats, self.populateChats).start()
        
    def populateChats(self, chatList):
        if type(chatList) == dict:
            chatList = [chatList]
        u, i = self.getCurrentAcc()
        if not u or not i:
            return
        closedList = self.settings.value('closed'+u+i, type=list) or []
        for chat in chatList:
            c = False
            for ind in range(0, self.tabs.count()):
                if self.tabs.widget(ind).acct == chat['account']['acct']:
                    c = True
            for entry in closedList:
                if chat['account']['acct'] == entry:
                    c = True
            if c:
                continue
            ctab = ChatArea(chat, self.tabs)
            self.tabs.addTab(ctab, chat['account']['display_name'])

    def closeTab(self, index=None):
        if not index:
            index = self.tabs.currentIndex()
        act = self.tabs.widget(index).acct
        u, i = self.getCurrentAcc()
        closedList = self.settings.value('closed'+u+i, type=list) or []
        f = True
        for entry in closedList:
            if entry == act:
                f = False
        if f:
            closedList.append(act)
        self.settings.setValue('closed'+u+i, closedList)
        self.tabs.removeTab(index)

    def handlePleromaEvent(self, acct, event):
        if event['event'] == 'pleroma:chat_update':
            payload = json.loads(event['payload'])
            tmp = 0
            for ind in range(0, self.tabs.count()):
                if self.tabs.widget(ind).acct == payload['account']['acct']:
                    self._eventloop.call_soon_threadsafe(self.tabs.widget(ind).addMessage, payload['last_message'])
                    tmp = ind
                    #self.tabs.widget(ind).addMessage(payload['last_message'])
            if payload['last_message']['account_id'] != acct.flakeid and (not self.hasFocus() or payload['account']['acct'] != self.tabs.widget(self.tabs.currentIndex()).acct):
                if self.sendNotificationsAction.isChecked():
                    CallThread(self.makeNotification, None, payload['last_message']['content'], payload['account']['acct'], payload['account']['avatar_static']).start()
                app.alert(self, 0)
                self._eventloop.call_soon_threadsafe(self.setUrgent, tmp)

    def makeNotification(self, content, user, url):
        path = getPic(url)
        sendNotification(content, title=user, icon=path)

    def setUrgent(self, ind):
        icon = QIcon()
        icon.addPixmap(QPixmap('unread.svg'))
        self.tabs.setTabIcon(ind, icon)
        self.tabs.widget(ind).unread = True
        if self.trayIcon:
            self.trayIcon.setIcon(icon)
        self.setWindowIcon(icon)

    def changeTab(self, ind):
        if not self.tabs.widget(ind):
            return
        if self.tabs.widget(ind).unread:
            CallThread(getPic, self.tabs.widget(ind).useAvi, self.tabs.widget(ind).avaURL).start()
            self.tabs.widget(ind).unread = False
        flip = True
        for A in range(0, self.tabs.count()):
            if self.tabs.widget(A).unread:
                flip = False
        if flip:
            if self.trayIcon:
                self.trayIcon.setIcon(QIcon(QPixmap(ICON_PATH)))
            self.setWindowIcon(QIcon(QPixmap(ICON_PATH)))
        self.tabs.widget(ind).markRead()
        self.tabs.widget(ind).setFocus(Qt.NoFocusReason)


    def eventFilter(self, object, event):
        if event.type() == QEvent.WindowActivate:
            self.windowActivate()
        return False

    def windowActivate(self):
        ind = self.tabs.currentIndex()
        if not self.tabs.widget(ind):
            return
        if self.tabs.widget(ind).unread:
            CallThread(getPic, self.tabs.widget(ind).useAvi, self.tabs.widget(ind).avaURL).start()
            self.tabs.widget(ind).unread = False
        flip = True
        for A in range(0, self.tabs.count()):
            if self.tabs.widget(A).unread:
                flip = False
        if flip:
            if self.trayIcon:
                self.trayIcon.setIcon(QIcon(QPixmap(ICON_PATH)))
            self.setWindowIcon(QIcon(QPixmap(ICON_PATH)))
        self.tabs.widget(ind).markRead()
        self.tabs.widget(ind).setFocus(Qt.NoFocusReason)

class BGWidget(QWidget):
    def __init__(self, path=None):
        super().__init__()
        self.path=path
        self.pixmap = QPixmap()
    
    def setPath(self, path):
        self.path = path

    def paintEvent(self, event):
        super().paintEvent(event)
        if self.pixmap.isNull() and self.path:
            self.pixmap = QPixmap(self.path)
        painter = QPainter(self)
        if not self.pixmap.isNull():
            self.pixmap = self.pixmap.scaled(self.width(), self.height(), Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation)
        painter.drawPixmap(0,0, self.pixmap)

class ChatArea(QWidget):
    def __init__(self, chat, parent=None):
        super().__init__(parent=parent)
        self.acct = chat['account']['acct']
        self.parent = parent
        self.chatID = chat['id']
        self.account = chat['account']
        self.unread = False
        if ex.animatePicturesAction.isChecked():
            avatar_prop = 'avatar'
            header_prop = 'header'
        else:
            avatar_prop = 'avatar_static'
            header_prop = 'header_static'
        self.avaURL = chat['account'][avatar_prop]
        CallThread(getPic, self.useAvi, self.avaURL).start()
        if ex.fetchHeadersAction.isChecked():
            CallThread(getPic, self.headerReady, chat['account'][header_prop]).start()

        self.wrapper = BGWidget()
        wrapperlayout = QHBoxLayout()
        wrapperlayout.setContentsMargins(0,0,0,0)
        wrapperlayout.setSpacing(0)
        self.wrapper.setLayout(wrapperlayout)

        self.header = QFrame()
        headerlayout = QHBoxLayout()
        headernest = QVBoxLayout()
        headernestwidget = QWidget()
        headernestwidget.setContentsMargins(0,0,0,0)
        self.header.setContentsMargins(0,0,0,0)

        wrapperlayout.addWidget(self.header)

        self.header.setLayout(headerlayout)
        headernestwidget.setLayout(headernest)

        uDN = EmojiText(chat['account']['display_name'], chat['account']['emojis'], header=True)
        if self.acct.find('@') == -1:
            uACT = LinkLabel(chat['account']['url'], '@'+self.acct+'@'+ex.getCurrentAcc()[1])
        else:
            uACT = LinkLabel(chat['account']['url'], '@'+self.acct)
        uACT.setMargin(0)
        #uACT.setStyleSheet("color: white;")
        headernest.addWidget(uDN)
        headernest.addWidget(uACT)

        self.avatar = QLabel()
        self.avatar.setMargin(0)
        self.avatar.setFixedHeight(round(QDesktopWidget().screenGeometry(-1).height() * 0.06))

        headerlayout.addWidget(self.avatar)
        headerlayout.addWidget(headernestwidget, 100)

        self.messageArea = MessageArea(self.chatID, self.account, self.callMe)
        self.msgs = MovingScroll(self.messageArea)

        if ex.fetchBackgroundsAction.isChecked():
            if self.acct.find('@') == -1:
                remoteURL = ex.getCurrentAcc()[1]
            else:
                remoteURL = self.acct.split('@')[1]
            self.msgs.remoteURL = remoteURL
            CallThread(requests.get, self.msgs.parseNodeInfo, 'https://'+remoteURL+'/api/v1/instance').start()
            del remoteURL

        self.msgs.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.msgs.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.msgs.setWidgetResizable(True)
        self.messageArea.setFixedWidth(self.msgs.getChildWidth())
        self.messageArea.update()

        send = SendArea(self.chatID)

        layout = QVBoxLayout()
        layout.addWidget(self.wrapper, 2)
        layout.addWidget(self.msgs, 35)
        layout.addWidget(send, 1)

        self.setFocusProxy(send.getTextbox())
        self.setLayout(layout)

    def callMe(self):
        self.msgs.setWidget(self.messageArea)

    def markRead(self):
        self.messageArea.markRead()

    def headerReady(self, path):
        self.wrapper.setPath(path)

    def addMessage(self, message):
        self.messageArea.messages.insert(0, message)
        self.messageArea._update(self.messageArea.messages)

    def useAvi(self, path):
        pic = QPixmap(path)
        ava = QPixmap(path)
        if pic.isNull():
            pic = QPixmap(APPDATA+'/'+ex.getCurrentAcc()[1]+'avi.png')
            ava = QPixmap(APPDATA+'/'+ex.getCurrentAcc()[1]+'avi.png')
        
        icon = QIcon()
        icon.addPixmap(pic)
        self.parent.setTabIcon(self.parent.indexOf(self), icon)
        
        ava = ava.scaledToHeight(round(QDesktopWidget().screenGeometry(-1).height() * 0.06), mode=Qt.SmoothTransformation)
        self.avatar.resize(ava.width(), ava.height())
        self.avatar.setPixmap(ava)
        self.avatar.setFixedWidth(self.avatar.width())

    def paintEvent(self, event):
        super().paintEvent(event)
        if not self.wrapper.pixmap.isNull():
            self.header.setStyleSheet(".QFrame{background-color: rgba(0, 0, 0, 0.3);} QFrame{color: white;}")
            self.paintEvent = super().paintEvent


class MovingScroll(QScrollArea):
    def __init__(self, child, path=None):
        super().__init__()
        self.child = child
        self.remoteURL = ''
        self.verticalScrollBar().rangeChanged.connect(self.scrollToBottom)
        self.verticalScrollBar().valueChanged.connect(self.handleValue)

    def resizeEvent(self, event):
        self.child.setFixedWidth(self.getChildWidth())

    def scrollToBottom(self):
        self.verticalScrollBar().triggerAction(QAbstractSlider.SliderToMaximum)

    def getChildWidth(self):
        return self.width()-self.verticalScrollBar().width()-5

    def handleValue(self, pos):
        if pos < (self.verticalScrollBar().maximum() / 10):
            self.child.addPage()

    def parseNodeInfo(self, response):
        try:
            CallThread(getPic, self.child.setPath, 'https://'+self.remoteURL+response.json()['background_image']).start()
        except:
            print("Couldn't download background image for: "+remoteURL)

class MessageArea(QWidget):
    def __init__(self, chatID, account, callback):
        super().__init__()
        self.chatID = chatID
        self.account = account
        self.callback = callback
        self.path = None
        self.pixmap = QPixmap()
        self.layout = QVBoxLayout()
        self.layout.setContentsMargins(10, 0,-5,0)
        self.last_read_id = None
        self.messages = []
        self.page = 0
        self.fetchingPage = False

    def update(self):
        u, i = ex.getCurrentAcc()
        CallThread(ex.accts[u+i].getMessages, self._update, self.chatID).start()

    def markRead(self):
        if not self.last_read_id:
            return
        u, i = ex.getCurrentAcc()
        acc = ex.accts[u+i]
        acc.markChatRead(self.chatID, self.last_read_id)

    def addPage(self):
        if self.fetchingPage:
            return
        self.fetchingPage = True
        u, i = ex.getCurrentAcc()
        self.page += 1
        CallThread(ex.accts[u+i].getMessages, self.pageReady, self.chatID, past=self.messages[len(self.messages)-1]['id']).start()

    def pageReady(self, messages):
        for message in messages:
            self.messages.append(message)
        self._update(self.messages)

    def _update(self, messages):
        self.messages = messages
        for message in messages:
            if message['account_id'] == self.account['id']:
                self.last_read_id = message['id']
        for i in reversed(range(self.layout.count())): 
            self.layout.itemAt(i).widget().setParent(None)
        for message in reversed(messages):
            #for line in re.split(newlineRegex, message['content']):
            #    if line.strip() == '':
            #        continue
            self.layout.addWidget(SingleMessage(message, self.account, self), 0, Qt.AlignBottom)
        self.setLayout(self.layout)
        self.callback()
        if self.fetchingPage:
            self.fetchingPage = False

    def getMessages(self):
        return self.messages or []
    
    def setPath(self, path):
        self.path = path

    def paintEvent(self, event):
        super().paintEvent(event)
        if self.pixmap.isNull() and self.path:
            self.pixmap = QPixmap(self.path)
        painter = QPainter(self)
        if not self.pixmap.isNull():
            self.pixmap = self.pixmap.scaled(self.width(), self.height(), Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation)
        painter.drawPixmap(0,0, self.pixmap)

newlineRegex = re.compile('<\/?br\/?>|\n')

class SingleMessage(QWidget):
    def __init__(self, message, account, parent):
        super().__init__(parent=parent)
        self.parent = parent
        self.message = message
        self.account = account
        self.layout = QHBoxLayout()
        self.layout.setContentsMargins(0,0,0,0)
        self.layout.setSpacing(0)
        self.setStyleSheet("MessageAvatar{margin: 0em 0.2em 0em 0.2em;border: 1px solid black;}")

        if ex.animatePicturesAction.isChecked():
            avatar_prop = 'avatar'
            header_prop = 'header'
        else:
            avatar_prop = 'avatar_static'
            header_prop = 'header_static'
        self.avaURL = self.account[avatar_prop]

        u,i = ex.getCurrentAcc()
        self.userPixmap = None
        self.convoPixmap = None
        CallThread(getPic, self.setUserPixmap, ex.accts[u+i].acct[avatar_prop]).start()
        CallThread(getPic, self.setConvoPixmap, self.avaURL).start()

        if self.message['account_id'] == self.account['id']:
            self.layout.addWidget(MessageAvatar('convo', self), 0, (Qt.AlignLeft | Qt.AlignTop))
            self.layout.addWidget(InternalMessage(self.message, self.account, self), 1, Qt.AlignLeft)
            #spacer = QWidget()
            #spacer.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
            #self.layout.addWidget(spacer, 9000)
        else:
            #spacer = QWidget()
            #spacer.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
            #self.layout.addWidget(spacer, 9000)
            self.layout.addWidget(InternalMessage(self.message, self.account, self), 1, Qt.AlignRight)
            self.layout.addWidget(MessageAvatar('user', self), 0, (Qt.AlignRight | Qt.AlignTop))

        self.setLayout(self.layout)

    def setUserPixmap(self, path):
        p = QPixmap(path)
        if p.isNull():
            p = QPixmap(APPDATA+'/'+ex.getCurrentAcc()[1]+'avi.png')
        p = p.scaledToHeight(50, mode=Qt.SmoothTransformation)
        self.userPixmap = p
    def setConvoPixmap(self, path):
        p = QPixmap(path)
        if p.isNull():
            p = QPixmap(APPDATA+'/'+ex.getCurrentAcc()[1]+'avi.png')
        p = p.scaledToHeight(50, mode=Qt.SmoothTransformation)
        self.convoPixmap = p

class MessageAvatar(QLabel):
    def __init__(self, futurepixmap, parent):
        super().__init__(parent=parent)
        self.parent = parent
        self.pixmap = QPixmap()
        self.setMargin(0)
        self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        CallThread(self.awaitPixmap, None, futurepixmap).start()
        #self.setPixmap(self.pixmap)

    def setPath(self, path):
        #if not self.pixmap.isNull():
        #    return
        #self.pixmap = QPixmap(path)
        #if self.pixmap.isNull():
        #    self.pixmap = QPixmap(APPDATA+'/'+ex.getCurrentAcc()[1]+'avi.png')
        #self.pixmap = self.pixmap.scaledToHeight(50, mode=Qt.SmoothTransformation)
        self.pixmap = path
        self.resize(self.pixmap.width(), self.pixmap.height())
        self.setPixmap(self.pixmap)
        self.setFixedWidth(self.pixmap.width())
    
    def awaitPixmap(self, p):
        if p == 'user':
            while not self.parent.userPixmap:
                monkeypatch.sleep(0.2)
            self.resize(self.parent.userPixmap.width(), self.parent.userPixmap.height())
            self.setPixmap(self.parent.userPixmap)
            self.setFixedWidth(self.parent.userPixmap.width())
        else:
            while not self.parent.convoPixmap:
                monkeypatch.sleep(0.2)
            self.resize(self.parent.convoPixmap.width(), self.parent.convoPixmap.height())
            self.setPixmap(self.parent.convoPixmap)
            self.setFixedWidth(self.parent.convoPixmap.width())

class InternalMessage(QFrame):
    def __init__(self, message, account, parent):
        super().__init__(parent=parent)
        self.parent = parent
        self.message = message
        self.account = account
        self.layout = QHBoxLayout()
        self.layout.setContentsMargins(0,0,0,0)
        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
        self.attachment = None
        if ex.darkModeAction.isChecked():
            color_text="#ffffff"
            color_bg = "#000000"
        else:
            color_text="#000000"
            color_bg = "#ffffff"

        self.setStyleSheet("InternalMessage{background-color: "+color_bg+";border-radius: 1em;padding: 0.5em;border: 1px solid "+color_text+";} QWidget{color:"+color_text+";}")

        if self.message['content']:
            self.label = EmojiText(self.message['content'], self.message['emojis'])
            self.label.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
        else:
            self.label = None

        self.timestamp = QLabel(timeconvert.utc_to_local(self.message['created_at'], ex.twoFourTimeAction.isChecked()))
        self.timestamp.setFont(ex.TimestampFont)
        self.timestamp.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        if self.label:
            self.layout.addWidget(self.label)
        if not self.message['attachment']:
            self.layout.addWidget(self.timestamp, 1, (Qt.AlignRight | Qt.AlignBottom))
        else:
            CallThread(self.getMime, self.addAttachment, self.message['attachment']['url']).start()

        #self.setMinimumSize(QSize(50, computedHeight))
        self.setLayout(self.layout)

    def getMime(self, url):
        with urllib.request.urlopen(url) as res:
            # pleroma sux balls at mime types
            mime = magic.from_buffer(res.read(2048), mime=True)
            return mime

    def addAttachment(self, mime):
        self.attachment = MediaAttachment(self.message['attachment'], mime)
        self.layout.addWidget(self.attachment)
        self.layout.addWidget(self.timestamp, 1, (Qt.AlignRight | Qt.AlignBottom))

    def sizeHint(self):
        multiplier = 2
        additive = 0
        if self.label:
            multiplier += self.label.layoutfinal.count()
        if self.attachment:
            additive += self.attachment.getMedia().height()
        computedHeight = (ex.defaultFontMetrics.height() * multiplier) + additive

        computedWidth = 50
        if self.attachment:
            if self.attachment.getMedia().width() > computedWidth:
                computedWidth = self.attachment.getMedia().width()
        return QSize(computedWidth, computedHeight)

def MediaAttachment(media, mime):
    if mime.find("image/") != -1:
        return ImageAttachment(media)
    elif mime.find("video/") != -1:
        return VideoAttachment(media)
    elif mime.find("audio/") != -1:
        return AudioAttachmentWrapper(media)
    else:
        return FileAttachment(media)

class FileAttachment(QPushButton):
    def __init__(self, media):
        super(FileAttachment, self).__init__()
        self.url = QUrl(media['url'])
        self.setCursor(Qt.PointingHandCursor)
        self.setIcon(self.style().standardIcon(QStyle.SP_FileLinkIcon))
        self.setFlat(True)

    def mouseReleaseEvent(self, event):
        if event.modifiers() == Qt.NoModifier and event.button() == Qt.LeftButton:
            QDesktopServices.openUrl(self.url)

    def getMedia(self):
        return self

class AudioAttachmentWrapper(QWidget):
    def __init__(self, media):
        super(AudioAttachmentWrapper, self).__init__()
        layout = QHBoxLayout()
        self.file = FileAttachment(media)
        self.audio = AudioAttachment(media)
        layout.addWidget(self.file)
        layout.addWidget(self.audio)
        self.setLayout(layout)
    
    def getMedia(self):
        return QSize(self.file.getMedia().width()+self.audio.getMedia().width(), self.file.getMedia().height()+self.audio.getMedia().height())

class AudioAttachment(audiowidget.AudioPlayer):
    def __init__(self, media):
        super(AudioAttachment, self).__init__()
        #CallThread(self.openFile, None, media['url']).start()
        self.openFile(media['url'])

    def getMedia(self):
        return super().sizeHint()

class LinkLabel(QLabel):
    def __init__(self, url, *args, **kwargs):
        super(LinkLabel, self).__init__(*args, **kwargs)
        self.url = QUrl(url)
        self.setCursor(Qt.PointingHandCursor)
    def mouseReleaseEvent(self, event):
        bttn = event.button()
        modif = event.modifiers()
        if modif == Qt.NoModifier and bttn == Qt.LeftButton:
            QDesktopServices.openUrl(self.url)

class VideoAttachment(videowidget.VideoPlayer):
    def __init__(self, media, *args, **kwargs):
        super().__init__(media['url'], *args, **kwargs)
        #CallThread(self.openFile, None, media['url']).start()
        self.openFile(media['url'])

    def getMedia(self):
        return QSize(self.width(), self.videoWidget.height()+50)

class ImageAttachment(LinkLabel):
    def __init__(self, media):
        super().__init__(media['remote_url'])
        self.pixmap = QPixmap()
        CallThread(getPic, self.setPath, media['url']).start()

    def setPath(self, path):
        self.pixmap = QPixmap(path)
        if round(ex.width() * 0.7) < self.pixmap.width():
            self.pixmap = self.pixmap.scaledToWidth(round(ex.width() * 0.7), mode=Qt.SmoothTransformation)
        self.resize(self.pixmap.width(), self.pixmap.height())
        self.setPixmap(self.pixmap)
        #self.setFixedHeight(self.height())
        self.url = QUrl(path)

    def getMedia(self):
        return self.pixmap

class SendArea(QWidget):
    def __init__(self, chatID):
        super().__init__()
        self.layout = QHBoxLayout()
        self.lastFile = None
        self.mediaPreview = None
        self.mediaID = None
        self.Err = QErrorMessage()
        self.chatID = chatID

        self.textbox = TextBox()

        self.mediaStack = QStackedWidget()

        self.attachButton = QPushButton(self.style().standardIcon(QStyle.SP_FileDialogStart), 'Attach File')
        self.attachButton.clicked.connect(self.newFileDialog)
        self.attachButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding)

        sendButton = QPushButton(QIcon(QPixmap('send.svg')), '')
        sendButton.clicked.connect(self.sendMessage)
        sendButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding)

        self.mediaStack.addWidget(self.attachButton)
        self.mediaStack.setCurrentWidget(self.attachButton)

        self.layout.addWidget(self.textbox, 8)
        self.layout.addWidget(self.mediaStack, 1)
        self.layout.addWidget(sendButton, 1)
        self.setFocusProxy(self.textbox)
        self.setLayout(self.layout)
        self.textbox.setSendFunction(self.sendMessage)

    def getTextbox(self):
        return self.textbox

    def newFileDialog(self):
        if self.mediaPreview == 'uploading':
            self.Err.showMessage("Already uploading a file!")
            return
        qfd = QFileDialog(self)
        qfd.setFileMode(QFileDialog.ExistingFile)
        qfd.setNameFilters(["All Files (*)"])
        qfd.filesSelected.connect(self.attachFile)
        qfd.show()

    def attachFile(self, paths):
        if paths[0] == self.lastFile:
            return
        elif self.mediaPreview:
            self.Err.showMessage("File already attached!")
            return
        u, i = ex.getCurrentAcc()
        CallThread(ex.accts[u+i].uploadMedia, self.doneAttachFile, paths[0]).start()
        self.mediaPreview = 'uploading'
        self.lastFile = paths[0]

    def doneAttachFile(self, media):
        if not 'id' in media:
            self.Err.showMessage('Error uploading file')
            self.detachFile()
            return
        self.mediaID =  media['id']
        self.mediaPreview = QPushButton(ex.style().standardIcon(QStyle.SP_FileIcon), '')
        self.mediaPreview.clicked.connect(self.detachDialog)
        self.mediaPreview.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding)
        self.mediaStack.addWidget(self.mediaPreview)
        self.mediaStack.setCurrentWidget(self.mediaPreview)

    def detachDialog(self):
        dialog = DetachDialog()
        dialog.accepted.connect(self.detachFile)
        dialog.getInput()

    def detachFile(self):
        if self.mediaPreview and type(self.mediaPreview) != str:
            self.mediaStack.removeWidget(self.mediaPreview)
        self.mediaStack.setCurrentWidget(self.attachButton)
        self.mediaPreview = None
        self.lastFile = None
        self.mediaID = None

    def sendMessage(self):
        u, i = ex.getCurrentAcc()
        acc = ex.accts[u+i]
        if self.textbox.toPlainText() == '':
            text = None
        else:
            text = self.textbox.toPlainText()
        CallThread(acc.sendMessage, None, self.chatID, content=text, media=self.mediaID).start()
        self.textbox.setText('')
        if self.mediaPreview:
            self.detachFile()
        self.textbox.setFocus(Qt.NoFocusReason)

class TextBox(QTextEdit):
    def __init__(self, sendFunction=None):
        super().__init__()
        self.sendFunction = sendFunction or self.noop

    def keyPressEvent(self, event):
        if not event.matches(QKeySequence.InsertParagraphSeparator):
            super().keyPressEvent(event)
        else:
            self.sendFunction()

    def setSendFunction(self, sendFunction):
        self.sendFunction = sendFunction
    
    def noop(self):
        return

class DetachDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent=parent)
        self.setWindowTitle("Detach Dialog")

        QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel

        self.buttonBox = QDialogButtonBox(QBtn)
        self.buttonBox.accepted.connect(self.accept)
        self.buttonBox.rejected.connect(self.reject)

        self.layout = QVBoxLayout()
        self.message = QLabel("Detach this file?")
        self.layout.addWidget(self.message)
        self.layout.addWidget(self.buttonBox)
        self.setLayout(self.layout)

    def getInput(self):
        self.exec_()
        self.show()
        self.raise_()
        self.activateWindow()

class LoginDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent=parent)
        self.setWindowTitle("Log In")

        QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel

        self.buttonBox = QDialogButtonBox(QBtn)
        self.buttonBox.accepted.connect(self.accept)
        self.buttonBox.rejected.connect(self.reject)

        self.layout = QVBoxLayout()
        self.message = QLabel("Log in to your fediverse account")
        self.username = QLineEdit()
        self.username.setPlaceholderText('Username (e.g. Moon)')
        self.instance = QLineEdit()
        self.instance.setPlaceholderText('Instance (e.g. shitposter.club)')
        self.password = QLineEdit()
        self.password.setPlaceholderText('Password')
        self.password.setEchoMode(QLineEdit.Password)
        self.layout.addWidget(self.message)
        self.layout.addWidget(self.username)
        self.layout.addWidget(self.instance)
        self.layout.addWidget(self.password)
        self.layout.addWidget(self.buttonBox)
        self.setLayout(self.layout)
        self.setFocusProxy(self.username)

    def getInput(self, func):
        self.show()
        self.raise_()
        self.activateWindow()
        self.accepted.connect(self._finished)
        self.finishedFunc = func
    
    def _finished(self):
        instance = self.instance.text()
        instance = instance.replace('http://', '')
        instance = instance.replace('https://', '')
        if instance[len(instance) - 1] == '/':
            instance = instance[0:(len(instance) - 2)]
        self.finishedFunc(self.instance.text(), self.username.text(), password=self.password.text())

class ContactCard(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent=parent)
        self.setWindowTitle("Contact Info")

        QBtn = QDialogButtonBox.Ok

        self.buttonBox = QDialogButtonBox(QBtn)
        self.buttonBox.accepted.connect(self.accept)

        self.layout = QVBoxLayout()
        self.message = QLabel("Written by knotteye\nContact me in the following places (in order of preference) with issues")
        self.fedi = QLabel("Fedi: <a href='https://waldn.net/users/knotteye'>@knotteye@waldn.net</a>")
        self.fedi.setOpenExternalLinks(True)
        self.xmpp = QLabel('XMPP: <a href="xmpp://knotteye@telekem.net?message">knotteye@telekem.net</a>')
        self.xmpp.setOpenExternalLinks(True)
        self.email = QLabel('Email: <a href="mailto:knotteye@airmail.cc">knotteye@airmail.cc</a>')
        self.email.setOpenExternalLinks(True)
        self.layout.addWidget(self.message)
        self.layout.addWidget(self.fedi)
        self.layout.addWidget(self.xmpp)
        self.layout.addWidget(self.email)
        self.layout.addWidget(self.buttonBox)
        self.setLayout(self.layout)

        self.show()
        self.raise_()
        self.activateWindow()

class LicenseCard(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent=parent)
        self.setWindowTitle("Required Licensing Information")
        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)

        QBtn = QDialogButtonBox.Ok

        self.buttonBox = QDialogButtonBox(QBtn)
        self.buttonBox.accepted.connect(self.accept)

        self.layout = QVBoxLayout()
        self.tabs =  QTabWidget()
        
        plchatlayout = QVBoxLayout()
        plchatW = QWidget()
        plchatW.setLayout(plchatlayout)
        plchatlabel = QLabel("<a href='https://example.org/'>Repository</a>")
        plchatlabel.setTextFormat(Qt.RichText)
        plchatlabel.setOpenExternalLinks(True)
        plchatLicense = QLabel('butts\nbutts\nbutts\nbutts\nbutts\nbutts\nbutts\nbutts\nbutts\nbutts\nbutts\nbutts\n')
        plchatscroll = QScrollArea()
        plchatscroll.setWidget(plchatLicense)
        plchatlayout.addWidget(plchatlabel)
        plchatlayout.addWidget(plchatscroll)

        pyqtlayout = QVBoxLayout()
        pyqtW = QWidget()
        pyqtW.setLayout(pyqtlayout)
        pyqtlabel = QLabel("<a href='https://www.riverbankcomputing.com/software/pyqt/'>More Information</a>")
        pyqtlabel.setTextFormat(Qt.RichText)
        pyqtlabel.setOpenExternalLinks(True)
        pyqtLicense = QLabel(misc.gpltext)
        pyqtscroll = QScrollArea()
        pyqtscroll.setWidget(pyqtLicense)
        pyqtlayout.addWidget(pyqtlabel)
        pyqtlayout.addWidget(pyqtscroll)

        videolayout = QVBoxLayout()
        videoW = QWidget()
        videoW.setLayout(videolayout)
        videolicense = QLabel(misc.videowidgetlicense)
        videoscroll = QScrollArea()
        videoscroll.setWidget(videolicense)
        videolayout.addWidget(videoscroll)

        self.tabs.addTab(plchatW, 'PlChat')
        self.tabs.addTab(pyqtW, 'PyQt5')
        self.tabs.addTab(videoW, "videowidget.py")

        self.layout.addWidget(self.tabs)
        self.layout.addWidget(self.buttonBox)
        self.setLayout(self.layout)

        self.show()
        self.raise_()
        self.activateWindow()

    def sizeHint(self):
        return QSize(500, 900)

class EmojiText(QWidget):
    ceRegex = re.compile('(:[^:]+:)')
    def __init__(self, text, emojiList, header=False):
        super().__init__()
        self.layoutfinal = QVBoxLayout()
        self.layoutfinal.setSpacing(0)
        self.layoutfinal.setContentsMargins(0,0,0,0)

        for line in re.split(newlineRegex, text):
           self.layoutfinal.addWidget(self.makeLine(line, emojiList, header))

        self.setLayout(self.layoutfinal)

    def makeLine(self, text, emojiList, header):
        widget = QWidget()
        layout = QWidget()
        layout = QHBoxLayout()
        layout.setSpacing(0)
        layout.setContentsMargins(0,0,0,0)
        widget.setContentsMargins(0,0,0,0)
        customEmojis = []
        if header:
            size = ex.headerEmojiFontSize
        else:
            size = ex.emojiFontSize

        for em in re.findall(self.ceRegex, text):
            for emoji in emojiList:
                if emoji['shortcode'] == em[1:len(em)-1]:
                    cemurl = emoji[STATIC_PREF+'url']
            customEmojis.append(CustomEmoji(em[1:len(em)-1], cemurl, size))

        i = 0

        for stringpart in re.split(self.ceRegex, text):
            if len(stringpart) > 2 and stringpart[0] == ':' and stringpart[len(stringpart)-1] == ':':
                layout.addWidget(customEmojis[i], 1)
                i += 1
            else:
                label = QLabel(stringpart)
                if header:
                    label.setFont(ex.HeaderFont)
                label.setTextFormat(Qt.RichText)
                label.setTextInteractionFlags((Qt.TextBrowserInteraction))
                label.setOpenExternalLinks(True)
                layout.addWidget(label)

        layout.addWidget(QWidget(), 9000)
        widget.setLayout(layout)
        return widget

class CustomEmoji(QLabel):
    def __init__(self, shortcode, url=None, height=12):
        super().__init__()
        self.setScaledContents=True
        if url:
            CallThread(getPic, self.loadPic, url).start()
            self.mheight = height
            self.pixmap = None
            self.setMargin(0)

    def loadPic(self, path):
        self.pixmap = QPixmap(path)
        self.setPixmap(self.pixmap.scaledToHeight(self.mheight, mode=Qt.SmoothTransformation))

class CallThread(threading.Thread):
    # Generic thread object that takes some function, a callback and a list of arguments
    # The entire purpose of this object is to be a wrapper around running functions in a new thread
    def __init__(self, function, callback, *args, **kwargs):
        super(CallThread, self).__init__()
        self.function = function
        self.args = args or ()
        self.kwargs = kwargs or {}
        self.callback = callback

    def run(self):
        result = self.function(*self.args, **self.kwargs)
        if not self.callback:
            return
        ex._eventloop.call_soon_threadsafe(self.callback, result)

class RegisterThread(threading.Thread):
    def __init__(self, acct, callback):
        super(RegisterThread, self).__init__()
        self.acct = acct
        self.callback = callback

    def run(self):
        self.acct.register()
        self.acct.login()
        NotifThread(self.acct).start()
        self.acct.setChatUpdate(ex.handlePleromaEvent)
        self.callback(self.acct)

class NotifThread(threading.Thread):
    def __init__(self, acct):
        super(NotifThread, self).__init__()
        self.acct = acct
        self.loop = asyncio.new_event_loop()
        self.daemon = True
        asyncio.set_event_loop(self.loop)
    
    def run(self):
        self.loop.run_until_complete(self.acct.startStreaming())

class HLine(QFrame):
    def __init__(self): 
        super(HLine, self).__init__() 
        self.setFrameShape(self.HLine|self.Sunken)

class VLine(QFrame):
    def __init__(self): 
        super(VLine, self).__init__() 
        self.setFrameShape(self.VLine|self.Sunken)

class IconLabel(QLabel):
    def __init__(self, icon, w=30, h=None):
        super(IconLabel, self).__init__()
        if not h:
            h = w
        #self.icon = self.style().standardIcon(icon)
        self.icon = icon
        self.setPixmap(self.icon.pixmap(QSize(w, h)))

Notification = Notify(
    default_notification_title="PlChat",
    default_notification_icon=ICON_PATH
    #default_notification_audio=NOTIF_SOUND
)

def sendNotification(message, title=None, icon=None):
    Notification.message = message
    if title:
        Notification.title = title
    if icon:
        Notification.icon = icon
    Notification.send(block=False)

def getPic(url):
    filename = urllib.parse.urlparse(url).netloc+os.path.basename(urllib.parse.urlparse(url).path)
    filepath = CACHE+'/img/'+filename
    try:
        f = open(filepath, mode='xb+')
        THREADS[filepath] = threading.current_thread()
    except FileExistsError:
        try:
            while THREADS[filepath].is_alive():
                monkeypatch.sleep(0.2)
            return filepath
        except KeyError:
            return filepath
    try:
        imgdata = urllib.request.urlopen(url).read()
    except Exception as E:
        print("Got "+str(E)+" while downloading file: "+url)
        return filepath
    f.write(imgdata)
    f.close()
    return filepath

def getVid(url):
    filename = urllib.parse.urlparse(url).netloc+os.path.basename(urllib.parse.urlparse(url).path)
    filepath = CACHE+'/vid/'+filename
    try:
        f = open(filepath, mode='xb+')
        THREADS[filepath] = threading.current_thread()
    except FileExistsError:
        try:
            while THREADS[filepath].is_alive():
                monkeypatch.sleep(0.2)
            return filepath
        except KeyError:
            return filepath
    try:
        viddata = urllib.request.urlopen(url).read()
    except Exception as E:
        print("Got "+str(E)+" while downloading file: "+url)
        return filepath
    f.write(viddata)
    f.close()
    return filepath

def getAudio(url):
    filename = urllib.parse.urlparse(url).netloc+os.path.basename(urllib.parse.urlparse(url).path)
    filepath = CACHE+'/audio/'+filename
    try:
        f = open(filepath, mode='xb+')
        THREADS[filepath] = threading.current_thread()
    except FileExistsError:
        try:
            while THREADS[filepath].is_alive():
                monkeypatch.sleep(0.2)
            return filepath
        except KeyError:
            return filepath
    try:
        viddata = urllib.request.urlopen(url).read()
    except Exception as E:
        print("Got "+str(E)+" while downloading file: "+url)
        return filepath
    f.write(viddata)
    f.close()
    return filepath

def _mkdir(_dir):
    if os.path.isdir(_dir): pass
    elif os.path.isfile(_dir):
        raise OSError("%s exists as a regular file." % _dir)
    else:
        parent, directory = os.path.split(_dir)
        if parent and not os.path.isdir(parent): _mkdir(parent)
        if directory: os.mkdir(_dir)

def getAvi(instance):
    filename = instance+'avi.png'
    filepath = APPDATA+'/'+filename
    try:
        f = open(filepath, mode='xb+')
    except FileExistsError:
        return
    try:
        imgdata = urllib.request.urlopen('https://'+instance+'/images/avi.png').read()
    except Exception as E:
        print("Couldn't get default avi for "+instance+", error: "+str(E))
        return
    f.write(imgdata)
    f.close()
    return filepath

def updateAnimationPref():
    if ex.animatePicturesAction.isChecked():
        STATIC_PREF = ''
    else:
        STATIC_PREF = 'static_'

if __name__ == '__main__':
    _mkdir(CACHE+'/img/')
    _mkdir(CACHE+'/vid/')
    _mkdir(CACHE+'/audio/')
    _mkdir(APPDATA)
    app = QApplication(sys.argv)
    app.setOrganizationName("plchat")
    app.setApplicationName("plchat")
    ex = App(app.processEvents)
    sys.exit(ex._eventloop.run_forever())