import sqlite3
import time

from PyQt6.QtCore import QThread
from PyQt6.QtCore import pyqtSignal as Signal

from src.backend.database import Database
from src.logic.log import MyLogger
from src.logic.webrequest import BibTextTransformer, WebRequest

# from src.transformers import RDS_AVAIL_DATA


class BookGrabber(QThread):
    updateSignal = Signal(int, int)
    done = Signal()

    def __init__(self, app_id, prof_id, mode, data, parent=None):
        super(BookGrabber, self).__init__(parent=None)
        self.is_Running = True
        self.logger = MyLogger("Worker")
        self.logger.log_info("Starting worker thread")
        self.data = data
        self.app_id = app_id
        self.prof_id = prof_id
        self.mode = mode
        self.book_id = None
        self.state = (self.app_id, self.prof_id, self.mode, self.data)
        time.sleep(2)

    # def resetValues(self):
    #     self.app_id = None
    #     self.prof_id = None
    #     self.mode = None
    #     self.data = None
    #     self.book_id = None

    def run(self):
        while self.is_Running:
            self.db = Database()
            item = 0
            iterdata = self.data
            print(iterdata)
            for entry in iterdata:
                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:
                    sign = rds_item.superlocation
                    loc = rds_item.location
                    # ic(sign, loc)
                    # ic(rds_item)
                    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(
                    "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")
            # self.done.emit()
            self.stop()
            if not self.is_Running:
                break

    def stop(self):
        self.is_Running = False