# from icecream import ic
from PySide6.QtCore import QThread
from PySide6.QtCore import Signal as Signal

from src.backend.database import Database
from src.backend.webadis import get_book_medianr
from src.logic.webrequest import BibTextTransformer, TransformerType, WebRequest
from src.shared.logging import log


class AvailChecker(QThread):
    updateSignal = Signal(str, int)
    updateProgress = Signal(int, int)

    def __init__(
        self,
        links: list[str] | None = None,
        appnumber: int | None = None,
        parent=None,
        books: list[dict] | None = None,
    ):
        if links is None:
            links = []
        super().__init__(parent)
        log.info("Starting worker thread")
        log.info(
            "Checking availability for "
            + str(links)
            + " with appnumber "
            + str(appnumber)
            + "..."
        )
        self.links = links
        self.appnumber = appnumber
        self.books = books or []
        log.info(
            f"Started worker with appnumber: {self.appnumber} and links: {self.links} and {len(self.books)} books..."
        )
        # Pre-create reusable request and transformer to avoid per-item overhead
        self._request = WebRequest().set_apparat(self.appnumber)
        self._rds_transformer = BibTextTransformer(TransformerType.RDS)

    def run(self):
        self.db = Database()
        state = 0
        count = 0
        for link in self.links:
            log.info("Processing entry: " + str(link))
            data = self._request.get_ppn(link).get_data()
            rds = self._rds_transformer.get_data(data).return_data("rds_availability")

            book_id = None
            if not rds or not rds.items:
                log.warning(f"No RDS data found for link {link}")
                continue
            for item in rds.items:
                sign = item.superlocation
                loc = item.location
                # # #print(item.location)
                if str(self.appnumber) in sign or str(self.appnumber) in loc:
                    state = 1
                    break
            for book in self.books:
                if book["bookdata"].signature == link:
                    book_id = book["id"]
                    break
            log.info(f"State of {link}: " + str(state))
            # #print("Updating availability of " + str(book_id) + " to " + str(state))
            # use get_book_medianr to update the medianr of the book in the database
            auth = self.db.getWebADISAuth
            medianr = get_book_medianr(rds.items[0].callnumber, self.appnumber, auth)
            book_data = book["bookdata"]
            book_data.medianr = medianr
            self.db.updateBookdata(book["id"], book_data)
            self.db.setAvailability(book_id, state)
            count += 1
            self.updateProgress.emit(count, len(self.links))
            self.updateSignal.emit(item.callnumber, state)

        log.info("Worker thread finished")
        # teminate thread

        self.quit()