from PyQt6.QtCore import QThread, pyqtSignal

from core.controllers.tickets.TicketSyncController import sync_ticket_prices
from core.controllers.tickets.TicketPayController import initiate_payment, check_if_paid
from core.controllers.tickets.TicketPrepController import prepare_tickets
from core.controllers.tickets.FailedVerificationController import (
    evaluate_if_its_the_key,
    prepare_tickets_with_saved_blind_sigs,
)
from core.controllers.tickets.UseTicketController import use_ticket

from gui.v2.infrastructure.setup_observers import (
    connection_observer,
    ticket_observer,
)


class TicketingWorkerThread(QThread):
    sync_done = pyqtSignal(object)
    invoice_ready = pyqtSignal(object)
    paid = pyqtSignal()
    not_paid = pyqtSignal()
    paid_check_failed = pyqtSignal(str)
    prep_done = pyqtSignal(object)
    use_done = pyqtSignal(object)
    failed_verification_evaluated = pyqtSignal(object)
    saved_blind_prep_done = pyqtSignal(object)
    error = pyqtSignal(str)

    def __init__(self, action, params=None):
        super().__init__()
        self.action = action
        self.params = params or {}

    def run(self):
        try:
            if self.action == 'SYNC_PRICES':
                result = sync_ticket_prices(ticket_observer, connection_observer)
                self.sync_done.emit(result)
            elif self.action == 'INITIATE_PAYMENT':
                result = initiate_payment(
                    self.params['how_many_profiles'],
                    self.params['which_key'],
                    self.params['which_cryptocurrency'],
                    ticket_observer,
                    connection_observer,
                    self.params.get('bypass_existing', False),
                )
                self.invoice_ready.emit(result)
            elif self.action == 'CHECK_PAID':
                result = check_if_paid(self.params['temp_billing_code'], ticket_observer, connection_observer)
                if isinstance(result, dict) and result.get('valid') and result.get('payment_status') == 'paid':
                    self.paid.emit()
                elif isinstance(result, dict) and result.get('valid'):
                    self.not_paid.emit()
                else:
                    err = 'unknown'
                    if isinstance(result, dict):
                        err = str(result.get('error_code') or result.get('message') or 'unknown')
                    self.paid_check_failed.emit(err)
            elif self.action == 'PREPARE_TICKETS':
                result = prepare_tickets(self.params['how_many_profiles'], ticket_observer, connection_observer)
                self.prep_done.emit(result)
            elif self.action == 'EVALUATE_FAILED_VERIFICATION':
                result = evaluate_if_its_the_key(
                    self.params['failed_validations'],
                    ticket_observer,
                    connection_observer,
                )
                self.failed_verification_evaluated.emit(result)
            elif self.action == 'PREPARE_SAVED_BLIND_SIGS':
                result = prepare_tickets_with_saved_blind_sigs(ticket_observer, connection_observer)
                self.saved_blind_prep_done.emit(result)
            elif self.action == 'USE_TICKET':
                result = use_ticket(
                    self.params['which_ticket'],
                    self.params['which_location'],
                    ticket_observer,
                    connection_observer,
                )
                self.use_done.emit(result)
        except Exception as e:
            self.error.emit(str(e))