import sys

import loguru
from PySide6.QtCore import QThread, Signal

from src import LOG_DIR
from src.backend import Database
from src.logic.webrequest import BibTextTransformer, WebRequest

log = loguru.logger
log.remove()
log.add(sys.stdout, level="INFO")
log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")


# logger.add(sys.stderr, format="{time} {level} {message}", level="INFO")
log.add(sys.stdout, level="INFO")


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

    def __init__(self):
        super(BookGrabber, self).__init__(parent=None)
        self.is_Running = True
        log.info("Starting worker thread")
        self.data = []
        self.app_id = None
        self.prof_id = None
        self.mode = None
        self.book_id = None
        self.use_any = False
        self.use_exact = False
        self.app_nr = None
        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
        self.request = WebRequest()
        self.db = Database()


    def add_values(
        self, app_id: int, prof_id: int, mode: str, data, any_book=False, exact=False
    ):
        self.app_id = app_id
        self.prof_id = prof_id
        self.mode = mode
        self.data: list[str] = data
        self.use_any = any_book
        self.use_exact = exact
        log.info(f"Working on {len(self.data)} entries")
        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
        log.debug("State: " + str(self.tstate))
        app_nr = self.db.query_db("SELECT appnr FROM semesterapparat WHERE id = ?", (self.app_id,))[0][0]
        self.request.set_apparat(app_nr)
        # log.debug(self.tstate)

    def run(self):
        item = 0
        iterdata = self.data
        # log.debug(iterdata)

        for entry in iterdata:
            # log.debug(entry)
            log.info("Processing entry: {}", entry)

            webdata = self.request.get_ppn(entry)
            if self.use_any:
                webdata = webdata.use_any_book
            webdata = webdata.get_data()

            if webdata == "error":
                continue

            bd = BibTextTransformer(self.mode)
            log.debug(webdata)
            if self.mode == "ARRAY":
                if self.use_exact:
                    bd = bd.use_signature(entry)
            bd = bd.get_data(webdata).return_data()
            log.debug(bd)
            if bd is None:
                # bd = BookData
                continue
            bd.signature = entry
            transformer = (
                BibTextTransformer("RDS").get_data(webdata).return_data("rds_data")
            )

            # confirm lock is acquired
            self.db.addBookToDatabase(bd, self.app_id, self.prof_id)
            # get latest book id
            self.book_id = self.db.getLastBookId()
            log.info("Added book to database")
            state = 0
            for result in transformer.RDS_DATA:
                # log.debug(result.RDS_LOCATION)
                if str(self.app_nr) in result.RDS_LOCATION:
                    state = 1
                    break

            log.info(f"State of {entry}: {state}")
            log.debug(
                "updating availability of " + str(self.book_id) + " to " + str(state)
            )
            try:
                self.db.setAvailability(self.book_id, state)
                log.debug("Added book to database")
            except Exception as e:
                log.error(f"Failed to update availability: {e}")
                log.debug("Failed to update availability: " + str(e))

            # time.sleep(5)
            item += 1
            self.updateSignal.emit(item, len(self.data))
        log.info("Worker thread finished")
        # self.done.emit()
        self.quit()

    def stop(self):
        self.is_Running = False


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

    def __init__(self, appnr: int):
        super(BookGrabberTest, self).__init__(parent=None)
        self.is_Running = True
        log.info("Starting worker thread")
        self.data = None
        self.app_nr = None
        self.prof_id = None
        self.mode = None
        self.book_id = None
        self.use_any = False
        self.use_exact = False
        self.app_nr = appnr
        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
        self.results = []

    def add_values(
        self, app_nr: int, prof_id: int, mode: str, data, any_book=False, exact=False
    ):
        self.app_nr = app_nr
        self.prof_id = prof_id
        self.mode = mode
        self.data = data
        self.use_any = any_book
        self.use_exact = exact
        log.info(f"Working on {len(self.data)} entries")
        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
        log.debug("State: " + str(self.tstate))
        # log.debug(self.tstate)

    def run(self):
        item = 0
        iterdata = self.data
        # log.debug(iterdata)
        for entry in iterdata:
            # log.debug(entry)
            signature = str(entry)
            log.info("Processing entry: " + signature)

            webdata = WebRequest().set_apparat(self.app_nr).get_ppn(entry)
            if self.use_any:
                webdata = webdata.use_any_book
            webdata = webdata.get_data()

            if webdata == "error":
                continue

            bd = BibTextTransformer(self.mode)
            if self.mode == "ARRAY":
                if self.use_exact:
                    bd = bd.use_signature(entry)
            bd = bd.get_data(webdata).return_data()
            if bd is None:
                # bd = BookData
                continue
            bd.signature = entry
            transformer = (
                BibTextTransformer("RDS").get_data(webdata).return_data("rds_data")
            )

            # confirm lock is acquired
            # get latest book id
            log.info("Added book to database")
            state = 0
            for result in transformer.RDS_DATA:
                # log.debug(result.RDS_LOCATION)
                if str(self.app_nr) in result.RDS_LOCATION:
                    state = 1
                    break

            log.info(f"State of {signature}: {state}")
            # log.debug("updating availability of " + str(self.book_id) + " to " + str(state))
            self.results.append(bd)

            # time.sleep(5)
            item += 1
            self.updateSignal.emit(item, len(self.data))
        log.info("Worker thread finished")
        # self.done.emit()
        self.quit()

    def stop(self):
        self.is_Running = False