#!/usr/bin/env python

import sys, traceback

from PyQt6.QtCore import pyqtSignal, pyqtSlot, QRunnable, QObject

class WorkerSignals(QObject):
    """
    Defines the signals avail from a running worker thread.

    Supported signals are:

    finished
        No Data

    error
        tuple (exctype, value, traceback.format_exc() )

    result
        object data returned from processing, anything

    progress
        int indicating % progress
    """
    started = pyqtSignal()
    finished = pyqtSignal()
    error = pyqtSignal(tuple)
    result = pyqtSignal(object)
    progress = pyqtSignal(int)
    import_progress = pyqtSignal(int)
    current_file_progress = pyqtSignal(float)
    # current_import_file = pyqtSignal()

class Worker(QRunnable):
    """
    Worker Thread

    Inherits from QRunnable to handler worker thread setup, signals and wrap-up.

    :param callback: The function callback to run on this worker thread. Supplied args and
                     kwargs will be passed through to the runner.
    :type callback: function
    :param args: Arguments to pass to the callback function
    :param kwargs: Keywords to pass to the callback function
    """

    def __init__(self,fn,*args,**kwargs):
        super(Worker,self).__init__()

        # Store constructor args (re-used for processing)
        self.fn = fn
        self.args = args
        self.kwargs = kwargs
        self.signals = WorkerSignals()

        # Add the callback to our kwargs
        self.kwargs['progress_callback'] = self.signals.progress
        self.kwargs['import_progress_callback'] = self.signals.import_progress
        self.kwargs['current_file_progress_callback'] = self.signals.current_file_progress
        # self.kwargs['current_import_file'] = self.signals.current_import_file

    @pyqtSlot()
    def run(self):
        """
        Initialise the runner function with passed args, kwargs.
        """
        # Retrieve args/kwargs here; and fire processing using them
        try:
            self.signals.started.emit()
            result = self.fn(*self.args, **self.kwargs)
        except:
            traceback.print_exc()
            exctype, value = sys.exc_info()[:2]
            self.signals.error.emit((exctype,value,traceback.format_exc()))
        else:
            self.signals.result.emit(result)
        finally:
            self.signals.finished.emit()