import base
from callhandler import CallHandler
from browser import Browser
from PyQt6.QtCore import Qt
from PyQt6.QtWidgets import QMainWindow, QWidget, QVBoxLayout
from PyQt6.QtCore import QThread, QObject, pyqtSignal as Signal, pyqtSlot as Slot
import time

class Sight(QWidget):
    js_work_requested = Signal(str)

    def __init__(self, id, page):
        super().__init__()

        self.id = id
        self.page = page
        self.data = {} # private data(s) of the sight
        self.children = []
        self.parent = None
        self.js_worker = self.JsRunWorker()

        base.data["active_sight"] = self.id
        self.title = id

        if base.frameSupported():
            self.setWindowFlags(Qt.WindowType(0x00000800)) # remove the os windows frame (borders, close and other buttons
            self.setAttribute(Qt.WidgetAttribute(0x78)) # (int: 120)) # Make Transparent
            
        self.browser = Browser()
        self.browser.addObject('handler', CallHandler(self) )

        #self.browser.loadAdminContent(page)
        if "sight-admin" in id:
            self.browser.loadAdminContent(page)
        else:
            self.browser.loadContent(page)

        self.layout = QVBoxLayout()
        self.layout.addWidget(self.browser)
        self.layout.setSpacing(0);
        self.layout.setContentsMargins(1, 1, 1, 1); #Need 1,1,1,1 if it is 0,0,0,0 I got setgeometry warnings
        
        self.setLayout(self.layout)



    def runJs(self,request_js):
        self.browser.page().runJavaScript(request_js)


    def st(self):
        self.js_worker_thread = QThread()
        self.js_worker.js_run.connect(self.runJs)

        self.js_work_requested.connect(self.js_worker.do_work)
        # move worker to the worker thread
        self.js_worker.moveToThread(self.js_worker_thread)
        # start the thread
        self.js_worker_thread.start()
        self.js_work_requested.emit(self.page)

    # use when the frameSupported is False (for instance wayland)
    def closeEvent(self, event):
        self.js_worker.dont_work()
        self.js_worker_thread.quit()

        base.sights.close(self.id)

    def getParent(self):
        return self.parent

    def getPageId(self):
        return self.page

    def setParent(self, id):
        self.parent = id

    def addChild(self, id):
        self.children.insert(0, id)
        print(self.children)

    def getChildren(self):
        return self.children

    def removeChild(self, id):
        if id in self.children:
            self.children.remove(id)
            print(self.children)

    def setLayoutContentMargins(self,a,b,c,d):
        self.layout.setContentsMargins(a, b, c, d)
    
    def setTitle(self, title):
        self.title = title

    def getTitle(self):
        return self.title
    def getId(self):
        return self.id
    def addData(self, key, value):
        self.data[key] = value
    def getData(self, key):
        if key in self.data:
            return self.data[key]
        return None

    class JsRunWorker(QObject):
        __js_requests = []
        __infinitive = True
        js_run = Signal(str)

        def addRequest(self, js):
            self.__js_requests.append(js)
            #print("REQUESTS: ")
            #print(self.__js_requests)

        @Slot(str)
        def do_work(self, name):
            sec_sleep = 0.5
            while self.__infinitive:
                rs = self.__js_requests
                self.__js_requests.clear()

                time.sleep(sec_sleep)
                for request in rs:
                    time.sleep(sec_sleep)
                    print(name + " " +request)
                    try:
                        self.js_run.emit(request)
                    except Exception as error:
                        print("Error " + str(error))

                    #break
                    # self.__js_requests.remove(request)
                    # base.sights.get(page).browser.page().runJavaScript("receiveData('message', 'logs', {'event_code':'do_work', 'msg':'test', 'date':'ye'})", self.ready)

        def dont_work(self):
            self.__infinitive = False
        def ready(self, returnValue):
            if returnValue is not None:
                print(returnValue)