import threading
import time

from PyQt6.QtCore import QThread, pyqtSignal

from src.backend.database import Database
from src.logic.log import MyLogger
from src.transformers import RDS_AVAIL_DATA
from src.logic.webrequest import BibTextTransformer, WebRequest
import sqlite3
from icecream import ic

class BookGrabber(QThread):
    updateSignal = pyqtSignal(int, int)

    def __init__(
        self,
        mode: str = None,
        data: list = None,
        app_id: int = None,
        prof_id: int = None,
        parent=None,
    ):
        super().__init__(parent)
        self.logger = MyLogger("Worker")
        self.logger.log_info("Starting worker thread")
        self.app_id = app_id
        self.prof_id = prof_id
        self.mode = mode
        self.data = data
        self.book_id = None
        self.logger.log_info(f"Worker thread started, using mode:{self.mode} and app_id:{self.app_id} and prof_id:{self.prof_id}")
        ic(self.app_id)
        time.sleep(2)
    def run(self):
        self.db = Database()
        item = 0
        for entry in self.data:
            signature = str(entry)
            self.logger.log_info("Processing entry: " + signature)

            webdata = WebRequest().get_ppn(entry).get_data()
            if webdata == "error":
                continue
            bd = BibTextTransformer(self.mode).get_data(webdata).return_data()
            transformer = BibTextTransformer("RDS")
            rds = transformer.get_data(webdata).return_data("rds_availability")
            bd.signature = entry
            # confirm lock is acquired
            print("lock acquired, adding book to database")
            self.db.addBookToDatabase(bd, self.app_id, self.prof_id)
            # get latest book id
            self.book_id = self.db.getLastBookId()
            self.logger.log_info("Added book to database")
            state = 0
            print(len(rds.items))
            for rds_item in rds.items:
                ic(rds_item)
                sign = rds_item.superlocation
                loc = rds_item.location
                # print(item.location)
                if self.app_id in sign or self.app_id in loc:
                    state = 1
                    break

                # for book in self.books:
                #     if book["bookdata"].signature == entry:
                #         book_id = book["id"]
                #         break
            self.logger.log_info(f"State of {signature}: {state}")
            print(
                "lock acquired, updating availability of "
                + str(self.book_id)
                + " to "
                + str(state)
            )
            try:
                self.db.setAvailability(self.book_id, state)
            except sqlite3.OperationalError as e:
                self.logger.log_error(f"Failed to update availability: {e}")

            # time.sleep(5)
            item += 1
            self.updateSignal.emit(item, len(self.data))
        self.logger.log_info("Worker thread finished")
        # teminate thread
        self.app_id = None
        self.prof_id = None
        self.mode = None
        self.data = None

        self.quit()


class AvailChecker(QThread):
    updateSignal = pyqtSignal(str, int)
    updateProgress = pyqtSignal(int,int)
    def __init__(
        self, links: list = [], appnumber: int = None, parent=None, books=list[dict]
    ):
        if links is None:
            links = []
        super().__init__(parent)
        self.logger = MyLogger("AvailChecker")
        self.logger.log_info("Starting worker thread")
        self.logger.log_info(
            "Checking availability for "
            + str(links)
            + " with appnumber "
            + str(appnumber)
            + "..."
        )
        self.links = links
        self.appnumber = appnumber
        self.books = books
        self.logger.log_info(f"Started worker with appnumber: {self.appnumber} and links: {self.links} and {len(self.books)} books...")
        ic(self.appnumber)
        time.sleep(2)
    def run(self):
        self.db = Database()
        state = 0
        count = 0
        for link in self.links:
            self.logger.log_info("Processing entry: " + str(link))
            data = WebRequest().get_ppn(link).get_data()
            transformer = BibTextTransformer("RDS")
            rds = transformer.get_data(data).return_data("rds_availability")

            book_id = None
            for item in rds.items:
                sign = item.superlocation
                loc = item.location
                # print(item.location)
                if self.appnumber in sign or self.appnumber in loc:
                    state = 1
                    break
            for book in self.books:
                if book["bookdata"].signature == link:
                    book_id = book["id"]
                    break
            self.logger.log_info(f"State of {link}: " + str(state))
            print(
                "Updating availability of "
                + str(book_id)
                + " to "
                + str(state)
            )
            self.db.setAvailability(book_id, state)
            count += 1
            self.updateProgress.emit(count, len(self.links))
            self.updateSignal.emit(item.callnumber, state)

        self.logger.log_info("Worker thread finished")
        # teminate thread

        self.quit()


class AutoAdder(QThread):
    updateSignal = pyqtSignal(int)

    setTextSignal = pyqtSignal(int)
    progress = pyqtSignal(int)

    def __init__(self, data=None, app_id=None, prof_id=None, parent=None):
        super().__init__(parent)
        self.logger = MyLogger("AutoAdder")
        self.data = data
        self.app_id = app_id
        self.prof_id = prof_id

        print("Launched AutoAdder")
        print(self.data, self.app_id, self.prof_id)

    def run(self):
        self.db = Database()
        # show the dialog, start the thread to gather data and dynamically update progressbar and listwidget
        self.logger.log_info("Starting worker thread")
        item = 0
        for entry in self.data:
            try:
                # webdata = WebRequest().get_ppn(entry).get_data()
                # bd = BibTextTransformer("ARRAY").get_data(webdata).return_data()
                # bd.signature = entry
                self.updateSignal.emit(item)
                self.setTextSignal.emit(entry)
                # qsleep
                item += 1
                self.progress.emit(item)
                print(item, len(self.data))
                time.sleep(1)

            except Exception as e:
                print(e)
                self.logger.log_exception(
                    f"The query failed with message {e} for signature {entry}"
                )
                continue
        if item == len(self.data):
            self.logger.log_info("Worker thread finished")
            # teminate thread
            self.finished.emit()


class MockAvailCheck:

    def __init__(
        self, links: list = [], appnumber: int = None, parent=None, books=list[dict]
    ):
        if links is None:
            links = []
        super().__init__(parent)
        self.logger = MyLogger("MockAvailChecker")
        self.logger.log_info("Starting worker thread")
        self.logger.log_info(
            "Checking availability for "
            + str(links)
            + " with appnumber "
            + str(appnumber)
            + "..."
        )
        self.links = links
        self.appnumber = appnumber
        self.books = books

    def run(self):
        self.db = Database()
        state = 0
        count = 0
        result = []
        for link in self.links:
            self.logger.log_info("Processing entry: " + str(link))
            data = WebRequest().get_ppn(link).get_data()
            transformer = BibTextTransformer("RDS")
            rds = transformer.get_data(data).return_data("rds_availability")

            for item in rds.items:
                sign = item.superlocation
                loc = item.location
                ic(item.location, item.superlocation)
                if self.appnumber in sign or self.appnumber in loc:
                    state = 1
                book_id = None
                for book in self.books:
                    if book["bookdata"].signature == link:
                        book_id = book["id"]
                        break
                self.logger.log_info(f"State of {link}: " + str(state))
                print(
                    "lock acquired, updating availability of "
                    + str(book_id)
                    + " to "
                    + str(state)
                )
                result.append((item.callnumber, state))
            count += 1
        return result
            

        self.logger.log_info("Worker thread finished")
        # teminate thread