import asyncio

from PySide6.QtCore import Qt, Signal, QPoint
from PySide6.QtWidgets import QWidget, QVBoxLayout, QSplashScreen
from qframelesswindow import FramelessWindow

from Kikka.KikkaConst import *
from Kikka.Utils.Singleton import singleton

@singleton
class KikkaShell():
    
    def __init__(self):
        self.init()
        self.shellWindow = None
    
    def init(self):
        pass
    
    def loadShell(self, data):
        
        async def _async_load_start(data):
            future = asyncio.ensure_future(async_load(data))
            future.add_done_callback(_loaded)
            await asyncio.gather(future)
        
        async def async_load(data):
            await asyncio.sleep(1)
            shell_type = data.get("shell_type")
            if shell_type is None:
                return None
            elif shell_type == "Image":
                from .ImageShellWindow import ImageShellWindow
                shellWindow = ImageShellWindow()
                shellWindow.loadData(data)
                return shellWindow
            return None
            
        def _loaded(future):
            shellWindow = future.result()
            self.shellWindow = shellWindow
            self.show()

        asyncio.run(_async_load_start(data))
    
    def onKikkaOperation(self, operation, param):
        pass
    
    def switchShell(self, new_shell):
        if self.shellWindow is not None:
            self.shellWindow.deleteLater()
        self.shellWindow = new_shell

    def show(self):
        self.shellWindow.show()


class ShellBase(QSplashScreen):
    SIGNAL_SHELL_OPERATION = Signal(EShellOperation, dict)
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self._isMoving = False
        self.init()
    
    def init(self):
        self.setWindowFlags(self.windowFlags() | Qt.WindowType.WindowStaysOnTopHint)
        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
        self.setMouseTracking(True)
        self.setAcceptDrops(True)
    
    def loadData(self, data):
        raise NotImplemented

    def onKikkaOperation(self, operation, param):
        raise NotImplemented

    def mousePressEvent(self, event):
        self._movepos = event.globalPos() - self.pos()
        if event.buttons() == Qt.MouseButton.LeftButton:
            self._isMoving = True
            event.accept()
    
    def mouseMoveEvent(self, event):
        # self._mouseLogging("mouseMoveEvent", event.buttons(), event.globalPos().x(), event.globalPos().y())
        self._mousepos = event.pos()
        if self._isMoving and event.buttons() == Qt.MouseButton.LeftButton:
            self.move(event.globalPos() - self._movepos)
            event.accept()
        else:
            self._isMoving = False

    def mouseReleaseEvent(self, event):
        self._isMoving = False
    
    def mouseDoubleClickEvent(self, event):
        if event.buttons() == Qt.MouseButton.LeftButton:
            self._isMoving = False
    
    def wheelEvent(self, event):
        pass

    def dragEnterEvent(self, event):
        event.accept()
    
    def dropEvent(self, event):
        urls = event.mimeData().urls()
    
    def move(self, *__args):
        if len(__args) == 1 and isinstance(__args[0], QPoint):
            x = __args[0].x()
            y = __args[0].y()
        elif len(__args) == 2 and isinstance(__args[0], int) and isinstance(__args[1], int):
            x = __args[0]
            y = __args[1]
        else:
            super().move(*__args)
            return

        super().move(x, y)