#!/usr/bin/python3
import sys, os, subprocess
from pathlib import Path
from PySide6 import QtCore, QtGui, QtWidgets
from pynput import keyboard

from core.file_search import find
from core.web_search import MullvadLetaWrapper
from core.discord_presence import presence
from core.app_launcher import list_apps, launch
from core.updater import update_repository, is_update_available
from core.dukto import DuktoProtocol, Peer

ASSET = Path(__file__).parent / "assets" / "2ktan.png"

class AppLauncherDialog(QtWidgets.QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("App Launcher")
        self.setMinimumSize(600, 400)
        
        # Main layout
        layout = QtWidgets.QVBoxLayout()
        
        # Search box
        self.search_box = QtWidgets.QLineEdit()
        self.search_box.setPlaceholderText("Search applications...")
        self.search_box.textChanged.connect(self.filter_apps)
        layout.addWidget(self.search_box)
        
        # Apps list widget
        self.list_widget = QtWidgets.QListWidget()
        self.list_widget.itemClicked.connect(self.launch_app)
        layout.addWidget(self.list_widget)
        
        # Buttons
        button_layout = QtWidgets.QHBoxLayout()
        close_button = QtWidgets.QPushButton("Close")
        close_button.clicked.connect(self.close)
        
        button_layout.addStretch()
        button_layout.addWidget(close_button)
        layout.addLayout(button_layout)
        
        self.setLayout(layout)
        
        # Load apps
        self.load_apps()
        
        # Focus search box
        self.search_box.setFocus()
    
    def load_apps(self):
        try:
            QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) #type: ignore
            self.apps = list_apps()
            self.apps.sort(key=lambda x: x.name.lower())
            self.populate_list(self.apps)
        except Exception as e:
            QtWidgets.QMessageBox.critical(self, "Error", f"Failed to load applications: {e}")
        finally:
            QtWidgets.QApplication.restoreOverrideCursor()
    
    def populate_list(self, apps):
        self.list_widget.clear()
        for app in apps:
            item = QtWidgets.QListWidgetItem(app.name)
            item.setData(QtCore.Qt.UserRole, app) #type: ignore
            
            # Try to load the icon
            if app.icon:
                icon = QtGui.QIcon.fromTheme(app.icon)
                if not icon.isNull():
                    item.setIcon(icon)
            
            self.list_widget.addItem(item)
    
    def filter_apps(self, text):
        if not text:
            self.populate_list(self.apps)
            return
        
        text_lower = text.lower()
        filtered_apps = [app for app in self.apps if text_lower in app.name.lower()]
        self.populate_list(filtered_apps)
    
    def launch_app(self, item: QtWidgets.QListWidgetItem):
        if not item:
            return
        
        app = item.data(QtCore.Qt.UserRole) #type: ignore
        if app:
            try:
                launch(app)
                self.close()
            except Exception as e:
                QtWidgets.QMessageBox.critical(self, "Launch Error", 
                                              f"Failed to launch {app.name}: {e}")


class FileSearchResults(QtWidgets.QDialog):
    def __init__(self, results, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Search Results")
        self.setMinimumSize(600, 400)

        # results list widget
        self.list_widget = QtWidgets.QListWidget()
        self.list_widget.addItems(results)
        self.list_widget.itemDoubleClicked.connect(self.open_file_location)

        # layout
        layout = QtWidgets.QVBoxLayout()
        layout.addWidget(self.list_widget)
        self.setLayout(layout)

    def open_file_location(self, item: QtWidgets.QListWidgetItem):
        file_path = item.text()
        if os.path.exists(file_path):
            directory = os.path.dirname(file_path)
            url = QtCore.QUrl.fromLocalFile(directory)
            QtGui.QDesktopServices.openUrl(url)


class WebSearchResults(QtWidgets.QDialog):
    def __init__(self, results, parent=None):
        super().__init__(parent)
        self.setWindowTitle(f"Web Search Results - {results['query']}")
        self.setMinimumSize(800, 600)
        
        self.results = results
        
        # Main layout
        layout = QtWidgets.QVBoxLayout()
        
        # Info label
        info_text = f"Engine: {results['engine']} | Page: {results['page']}"
        if results.get('cached'):
            info_text += " | (Cached results)"
        info_label = QtWidgets.QLabel(info_text)
        info_label.setStyleSheet("color: gray; font-size: 10px; padding: 5px;")
        layout.addWidget(info_label)
        
        # Scroll area
        scroll = QtWidgets.QScrollArea()
        scroll.setWidgetResizable(True)
        scroll.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)  # type: ignore
        
        # Container
        container = QtWidgets.QWidget()
        container_layout = QtWidgets.QVBoxLayout(container)
        container_layout.setSpacing(15)
        
        # Add infobox
        if results.get('infobox'):
            infobox_widget = self._create_infobox_widget(results['infobox'])
            container_layout.addWidget(infobox_widget)
            
            # Separator
            line = QtWidgets.QFrame()
            line.setFrameShape(QtWidgets.QFrame.HLine)   #type: ignore
            line.setFrameShadow(QtWidgets.QFrame.Sunken) #type: ignore
            container_layout.addWidget(line)
        
        # Add news
        if results.get('news'):
            news_label = QtWidgets.QLabel("News")
            news_label.setStyleSheet("border: 1px solid #e0e0e0; border-radius: 3px; padding: 8px;")
            container_layout.addWidget(news_label)
            
            for news_item in results['news'][:5]:  # Show first 5 news items
                news_widget = self._create_news_widget(news_item)
                container_layout.addWidget(news_widget)
            
            # Separator
            line = QtWidgets.QFrame()
            line.setFrameShape(QtWidgets.QFrame.HLine)   #type: ignore
            line.setFrameShadow(QtWidgets.QFrame.Sunken) #type: ignore
            container_layout.addWidget(line)
        
        # Add results
        for result in results.get('results', []):
            result_widget = self._create_result_widget(result)
            container_layout.addWidget(result_widget)
        
        container_layout.addStretch()
        scroll.setWidget(container)
        layout.addWidget(scroll)
        
        # Navigation buttons
        nav_layout = QtWidgets.QHBoxLayout()
        
        if results['page'] > 1:
            prev_button = QtWidgets.QPushButton("← Previous Page")
            prev_button.clicked.connect(lambda: self.load_page(results['page'] - 1))
            nav_layout.addWidget(prev_button)
        
        nav_layout.addStretch()
        
        if results.get('has_next_page'):
            next_button = QtWidgets.QPushButton("Next Page →")
            next_button.clicked.connect(lambda: self.load_page(results['page'] + 1))
            nav_layout.addWidget(next_button)
        
        layout.addLayout(nav_layout)
        
        self.setLayout(layout)
    
    def _create_infobox_widget(self, infobox):
        widget = QtWidgets.QFrame()
        widget.setFrameShape(QtWidgets.QFrame.StyledPanel) #type: ignore
        widget.setStyleSheet("border: 1px solid #e0e0e0; border-radius: 3px; padding: 8px;")
        
        layout = QtWidgets.QVBoxLayout(widget)
        
        # Title
        title = QtWidgets.QLabel(infobox.get('title', ''))
        title.setStyleSheet("font-weight: bold; font-size: 16px;")
        title.setWordWrap(True)
        layout.addWidget(title)
        
        # Subtitle
        if infobox.get('subtitle'):
            subtitle = QtWidgets.QLabel(infobox['subtitle'])
            subtitle.setStyleSheet("color: gray; font-size: 12px;")
            subtitle.setWordWrap(True)
            layout.addWidget(subtitle)
        
        # URL
        if infobox.get('url'):
            url_label = QtWidgets.QLabel(f'<a href="{infobox["url"]}">{infobox["url"]}</a>')
            url_label.setOpenExternalLinks(True)
            url_label.setStyleSheet("color: blue; font-size: 11px;")
            layout.addWidget(url_label)
        
        # Description
        if infobox.get('description'):
            desc = QtWidgets.QLabel(infobox['description'])
            desc.setWordWrap(True)
            desc.setStyleSheet("margin-top: 5px;")
            layout.addWidget(desc)
        
        return widget
    
    def _create_news_widget(self, news_item):
        widget = QtWidgets.QFrame()
        widget.setFrameShape(QtWidgets.QFrame.Box) #type: ignore
        widget.setStyleSheet("border: 1px solid #e0e0e0; border-radius: 3px; padding: 8px;")
        
        layout = QtWidgets.QVBoxLayout(widget)
        layout.setSpacing(3)
        
        # Source
        source_label = QtWidgets.QLabel(news_item.get('source', ''))
        source_label.setStyleSheet("color: green; font-size: 10px;")
        layout.addWidget(source_label)
        
        # Title (clickable)
        title = QtWidgets.QLabel(f'<a href="{news_item["url"]}">{news_item.get("title", "")}</a>')
        title.setOpenExternalLinks(True)
        title.setWordWrap(True)
        title.setStyleSheet("font-size: 12px;")
        layout.addWidget(title)
        
        # Timestamp
        if news_item.get('timestamp'):
            time_label = QtWidgets.QLabel(news_item['timestamp'])
            time_label.setStyleSheet("color: gray; font-size: 9px;")
            layout.addWidget(time_label)
        
        return widget
    
    def _create_result_widget(self, result):
        widget = QtWidgets.QFrame()
        widget.setFrameShape(QtWidgets.QFrame.NoFrame) #type: ignore
        widget.setStyleSheet("padding: 5px;")
        
        layout = QtWidgets.QVBoxLayout(widget)
        layout.setSpacing(5)
        
        # Display URL
        if result.get('display_url'):
            url_label = QtWidgets.QLabel(result['display_url'])
            url_label.setStyleSheet("color: green; font-size: 11px;")
            layout.addWidget(url_label)
        
        # Title
        title = QtWidgets.QLabel(f'<a href="{result["url"]}">{result.get("title", "")}</a>')
        title.setOpenExternalLinks(True)
        title.setWordWrap(True)
        title.setStyleSheet("font-size: 14px; color: #1a0dab;")
        layout.addWidget(title)
        
        # Snippet
        if result.get('snippet'):
            snippet = QtWidgets.QLabel(result['snippet'])
            snippet.setWordWrap(True)
            snippet.setStyleSheet("color: #545454; font-size: 12px;")
            layout.addWidget(snippet)
        
        return widget
    
    def load_page(self, page_num):
        try:
            QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)  # type: ignore
            leta = MullvadLetaWrapper(engine=self.results['engine'])
            new_results = leta.search(self.results['query'], page=page_num)
            
            # Close current dialog and open new one
            new_dialog = WebSearchResults(new_results, self.parent())
            new_dialog.show()
            self.close()
            
        except Exception as e:
            QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
        finally:
            QtWidgets.QApplication.restoreOverrideCursor()


class TextViewerDialog(QtWidgets.QDialog):
    def __init__(self, text, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Text Received")
        self.setMinimumSize(400, 300)

        self.text_to_copy = text
        layout = QtWidgets.QVBoxLayout(self)

        self.text_edit = QtWidgets.QTextEdit()
        self.text_edit.setPlainText(text)
        self.text_edit.setReadOnly(True)
        layout.addWidget(self.text_edit)

        button_layout = QtWidgets.QHBoxLayout()
        button_layout.addStretch()

        copy_button = QtWidgets.QPushButton("Copy to Clipboard")
        copy_button.clicked.connect(self.copy_text)
        button_layout.addWidget(copy_button)

        close_button = QtWidgets.QPushButton("Close")
        close_button.clicked.connect(self.accept)
        button_layout.addWidget(close_button)

        layout.addLayout(button_layout)

    def copy_text(self):
        clipboard = QtWidgets.QApplication.clipboard()
        clipboard.setText(self.text_to_copy)


class MainWindow(QtWidgets.QMainWindow):
    show_menu_signal = QtCore.Signal()
    
    # Dukto signals
    peer_added_signal = QtCore.Signal(Peer)
    peer_removed_signal = QtCore.Signal(Peer)
    receive_request_signal = QtCore.Signal(str)
    progress_update_signal = QtCore.Signal(int, int)
    receive_start_signal = QtCore.Signal(str)
    receive_complete_signal = QtCore.Signal(list, int)
    receive_text_signal = QtCore.Signal(str, int)
    send_start_signal = QtCore.Signal(str)
    send_complete_signal = QtCore.Signal(list)
    dukto_error_signal = QtCore.Signal(str)


    def __init__(self, dukto_handler, restart=False, no_quit=False, super_menu=True):
        super().__init__()

        flags = (
            QtCore.Qt.FramelessWindowHint                              #type: ignore
            | QtCore.Qt.WindowStaysOnTopHint                           #type: ignore
            | QtCore.Qt.Tool                                           #type: ignore
            | QtCore.Qt.WindowDoesNotAcceptFocus                       #type: ignore
        )

        self.setWindowFlags(flags)         
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)          #type: ignore
        pix = QtGui.QPixmap(str(ASSET))

        self.label = QtWidgets.QLabel(self)
        self.label.setPixmap(pix)
        self.label.resize(pix.size())
        self.resize(pix.size())

        img = pix.toImage()
        mask_img = img.createAlphaMask()
        mask = QtGui.QBitmap.fromImage(mask_img)
        self.setMask(mask)

        self.super_menu = super_menu
        self.dukto_handler = dukto_handler
        self.progress_dialog = None

        # Connect Dukto callbacks to emit signals
        self.dukto_handler.on_peer_added = lambda peer: self.peer_added_signal.emit(peer)
        self.dukto_handler.on_peer_removed = lambda peer: self.peer_removed_signal.emit(peer)
        self.dukto_handler.on_receive_request = lambda ip: self.receive_request_signal.emit(ip)
        self.dukto_handler.on_transfer_progress = lambda total, rec: self.progress_update_signal.emit(total, rec)
        self.dukto_handler.on_receive_start = lambda ip: self.receive_start_signal.emit(ip)
        self.dukto_handler.on_receive_complete = lambda files, size: self.receive_complete_signal.emit(files, size)
        self.dukto_handler.on_receive_text = lambda text, size: self.receive_text_signal.emit(text, size)
        self.dukto_handler.on_send_start = lambda ip: self.send_start_signal.emit(ip)
        self.dukto_handler.on_send_complete = lambda files: self.send_complete_signal.emit(files)
        self.dukto_handler.on_error = lambda msg: self.dukto_error_signal.emit(msg)
        
        # Connect signals to GUI slots
        self.peer_added_signal.connect(self.handle_peer_added)
        self.peer_removed_signal.connect(self.handle_peer_removed)
        self.receive_request_signal.connect(self.show_receive_confirmation)
        self.progress_update_signal.connect(self.update_progress_dialog)
        self.receive_start_signal.connect(self.handle_receive_start)
        self.receive_complete_signal.connect(self.handle_receive_complete)
        self.receive_text_signal.connect(self.handle_receive_text)
        self.send_start_signal.connect(self.handle_send_start)
        self.send_complete_signal.connect(self.handle_send_complete)
        self.dukto_error_signal.connect(self.handle_dukto_error)

        self.tray = QtWidgets.QSystemTrayIcon(self)
        self.tray.setIcon(QtGui.QIcon(str(ASSET)))

        # RIGHT MENU
        right_menu = QtWidgets.QMenu()
        right_menu.addAction("Launch App", self.start_app_launcher)
        right_menu.addAction("Search Files", self.start_file_search)
        right_menu.addAction("Search Web", self.start_web_search)
        right_menu.addSeparator()
        self.send_menu_right = right_menu.addMenu("Send to")
        right_menu.addSeparator()
        right_menu.addAction("Check for updates", self.update_git)
        if restart:
            right_menu.addAction("Restart", self.restart_application)
        right_menu.addAction("Hide/Show", self.toggle_visible)
        right_menu.addSeparator()
        if not no_quit:
            right_menu.addAction("Quit", QtWidgets.QApplication.quit)
        self.tray.setContextMenu(right_menu)
        self.tray.activated.connect(self.handle_tray_activated)
        self.tray.show()

        # LEFT MENU
        self.left_menu = QtWidgets.QMenu()
        self.left_menu.addAction("Launch App", self.start_app_launcher)
        self.left_menu.addAction("Search Files", self.start_file_search)
        self.left_menu.addAction("Search Web", self.start_web_search)
        self.left_menu.addSeparator()
        self.send_menu_left = self.left_menu.addMenu("Send to")
        
        self.update_peer_menus()

        # always on top timer
        self.stay_on_top_timer = QtCore.QTimer(self)
        self.stay_on_top_timer.timeout.connect(self.ensure_on_top)
        self.stay_on_top_timer.start(1000)

        # Super key
        self.show_menu_signal.connect(self.show_menu)
        self.start_hotkey_listener()

    def show_menu(self):
        self.left_menu.popup(QtGui.QCursor.pos())

    def on_press(self, key):
        if self.super_menu:
            if key == keyboard.Key.cmd:
                self.show_menu_signal.emit()

    def start_hotkey_listener(self):
        self.listener = keyboard.Listener(on_press=self.on_press)
        self.listener.start()

    def closeEvent(self, event):
        self.listener.stop()
        super().closeEvent(event)

    def ensure_on_top(self):
        if self.isVisible():
            self.raise_()

    def showEvent(self, event):
        super().showEvent(event)
        self.raise_()

    def mousePressEvent(self, event: QtGui.QMouseEvent):
        if event.button() == QtCore.Qt.LeftButton:                      #type: ignore
            self.left_menu.popup(event.globalPosition().toPoint())

        elif event.button() == QtCore.Qt.RightButton:                   #type: ignore
            self.tray.contextMenu().popup(event.globalPosition().toPoint())

    def handle_tray_activated(self, reason):
        if reason == QtWidgets.QSystemTrayIcon.ActivationReason.Trigger:
            self.left_menu.popup(QtGui.QCursor.pos())

    def toggle_visible(self):
        self.setVisible(not self.isVisible())

    @QtCore.Slot(Peer)
    def handle_peer_added(self, peer: Peer):
        self.update_peer_menus()

    @QtCore.Slot(Peer)
    def handle_peer_removed(self, peer: Peer):
        self.update_peer_menus()

    def update_peer_menus(self):
        self.send_menu_left.clear()
        self.send_menu_right.clear()
        
        peers = list(self.dukto_handler.peers.values())
        
        if not peers:
            self.send_menu_left.addAction("No peers found").setEnabled(False)
            self.send_menu_right.addAction("No peers found").setEnabled(False)
            return

        for peer in sorted(peers, key=lambda p: p.signature):
            peer_submenu_left = self.send_menu_left.addMenu(peer.signature)
            peer_submenu_right = self.send_menu_right.addMenu(peer.signature)

            send_files_action_left = peer_submenu_left.addAction("Send File(s)")
            send_text_action_left = peer_submenu_left.addAction("Send Text")
            
            send_files_action_right = peer_submenu_right.addAction("Send File(s)")
            send_text_action_right = peer_submenu_right.addAction("Send Text")

            # Use a lambda with a default argument to capture the correct peer object
            send_files_action_left.triggered.connect(lambda checked=False, p=peer: self.start_file_send(p))
            send_text_action_left.triggered.connect(lambda checked=False, p=peer: self.start_text_send(p))
            
            send_files_action_right.triggered.connect(lambda checked=False, p=peer: self.start_file_send(p))
            send_text_action_right.triggered.connect(lambda checked=False, p=peer: self.start_text_send(p))

    def start_file_send(self, peer: Peer):
        file_paths, _ = QtWidgets.QFileDialog.getOpenFileNames(
            self,
            f"Select files to send to {peer.signature}",
            str(Path.home()),
        )
        if file_paths:
            self.dukto_handler.send_file(peer.address, file_paths, peer.port)

    def start_text_send(self, peer: Peer):
        text, ok = QtWidgets.QInputDialog.getMultiLineText(
            self,
            f"Send Text to {peer.signature}",
            "Enter text to send:"
        )
        if ok and text:
            self.dukto_handler.send_text(peer.address, text, peer.port)

    def show_receive_confirmation(self, sender_ip: str):
        reply = QtWidgets.QMessageBox.question(
            self,
            "Incoming Transfer",
            f"You have an incoming transfer from {sender_ip}.\nDo you want to accept it?",
            QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
            QtWidgets.QMessageBox.StandardButton.No
        )
        if reply == QtWidgets.QMessageBox.StandardButton.Yes:
            self.dukto_handler.approve_transfer()
        else:
            self.dukto_handler.reject_transfer()

    @QtCore.Slot(str)
    def handle_receive_start(self, sender_ip: str):
        self.progress_dialog = QtWidgets.QProgressDialog("Receiving data...", "Cancel", 0, 100, self)
        self.progress_dialog.setWindowTitle(f"Receiving from {sender_ip}")
        self.progress_dialog.setWindowModality(QtCore.Qt.WindowModal) # type: ignore
        self.progress_dialog.show()
    
    @QtCore.Slot(str)
    def handle_send_start(self, dest_ip: str):
        self.progress_dialog = QtWidgets.QProgressDialog("Sending data...", "Cancel", 0, 100, self)
        self.progress_dialog.setWindowTitle(f"Sending to {dest_ip}")
        self.progress_dialog.setWindowModality(QtCore.Qt.WindowModal) # type: ignore
        self.progress_dialog.show()

    @QtCore.Slot(int, int)
    def update_progress_dialog(self, total_size: int, received: int):
        if self.progress_dialog:
            self.progress_dialog.setMaximum(total_size)
            self.progress_dialog.setValue(received)

    @QtCore.Slot(list, int)
    def handle_receive_complete(self, received_files: list, total_size: int):
        if self.progress_dialog:
            self.progress_dialog.setValue(total_size)
            self.progress_dialog.close()
            self.progress_dialog = None
        
        QtWidgets.QMessageBox.information(self, "Transfer Complete", f"Successfully received {len(received_files)} items to ~/Received.")
        
        reply = QtWidgets.QMessageBox.question(
            self,
            "Open Directory",
            "Do you want to open the folder now?",
            QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
            QtWidgets.QMessageBox.StandardButton.Yes
        )

        if reply == QtWidgets.QMessageBox.StandardButton.Yes:
            receive_dir = str(Path.home() / "Received")
            url = QtCore.QUrl.fromLocalFile(receive_dir)
            QtGui.QDesktopServices.openUrl(url)
    
    @QtCore.Slot(list)
    def handle_send_complete(self, sent_files: list):
        if self.progress_dialog:
            if self.progress_dialog.maximum() > 0:
                self.progress_dialog.setValue(self.progress_dialog.maximum())
            self.progress_dialog.close()
            self.progress_dialog = None
        
        if sent_files and sent_files[0] == "___DUKTO___TEXT___":
            QtWidgets.QMessageBox.information(self, "Transfer Complete", "Text sent successfully.")
        else:
            QtWidgets.QMessageBox.information(self, "Transfer Complete", f"Successfully sent {len(sent_files)} items.")

    @QtCore.Slot(str, int)
    def handle_receive_text(self, text: str, total_size: int):
        if self.progress_dialog:
            self.progress_dialog.close()
            self.progress_dialog = None
        
        dialog = TextViewerDialog(text, self)
        dialog.exec()

    @QtCore.Slot(str)
    def handle_dukto_error(self, error_msg: str):
        if self.progress_dialog:
            self.progress_dialog.close()
            self.progress_dialog = None
        QtWidgets.QMessageBox.critical(self, "Transfer Error", error_msg)

    def start_app_launcher(self):
        self.app_launcher_dialog = AppLauncherDialog(self)
        self.app_launcher_dialog.move(QtGui.QCursor.pos())
        self.app_launcher_dialog.show()

    def start_file_search(self):
        dialog = QtWidgets.QInputDialog(self)
        dialog.setWindowTitle("File Search")
        dialog.setLabelText("Enter search pattern:")
        dialog.move(QtGui.QCursor.pos())
        
        ok = dialog.exec()
        pattern = dialog.textValue()
        
        if ok and pattern:
            try:
                QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) #type: ignore
                results = find(pattern, root='~')
            except RuntimeError as e:
                QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
                return
            finally:
                QtWidgets.QApplication.restoreOverrideCursor()

            if results:
                self.results_dialog = FileSearchResults(results, self)
                self.results_dialog.show()
            else:
                reply = QtWidgets.QMessageBox.question(self, "No Results", "Sorry, I couldn't find anything in your home folder. Would you like me to search the root folder?",
                                                       QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No, QtWidgets.QMessageBox.StandardButton.No)
                if reply == QtWidgets.QMessageBox.StandardButton.Yes:
                    try:
                        QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)  # type: ignore
                        results = find(pattern, root='/')
                    except RuntimeError as e:
                        QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
                        return
                    finally:
                        QtWidgets.QApplication.restoreOverrideCursor()

                    if results:
                        self.results_dialog = FileSearchResults(results, self)
                        self.results_dialog.show()
                    else:
                        QtWidgets.QMessageBox.information(self, "No Results", "Sorry, I couldn't find anything in the root folder either.")

    def start_web_search(self):
        dialog = QtWidgets.QInputDialog(self)
        dialog.setWindowTitle("Web Search")
        dialog.setLabelText("Enter search query:")
        dialog.move(QtGui.QCursor.pos())

        ok = dialog.exec()
        query = dialog.textValue()
        
        if ok and query:
            try:
                QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) #type: ignore
                leta = MullvadLetaWrapper(engine="brave")
                results = leta.search(query)
                
                if results and results.get('results'):
                    self.web_results_dialog = WebSearchResults(results, self)
                    self.web_results_dialog.show()
                else:
                    QtWidgets.QMessageBox.information(self, "No Results", "No web search results found.")
                    
            except Exception as e:
                QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
            finally:
                QtWidgets.QApplication.restoreOverrideCursor()

    def update_git(self):
        update_available = is_update_available()

        if not update_available:
            QtWidgets.QMessageBox.information(self, "No Updates", "You are already on the latest version.")
            return
        else:
            reply = QtWidgets.QMessageBox.question(self, "Update Available",
                                                   "An update is available. Would you like to download and install it now?",
                                                   QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
                                                   QtWidgets.QMessageBox.StandardButton.Yes)
            if reply == QtWidgets.QMessageBox.StandardButton.No:
                return

        status, message = update_repository()
        
        if status == "UPDATED":
            reply = QtWidgets.QMessageBox.question(self, "Update Successful",
                                                   f"{message}\n\nWould you like to restart now to apply the changes?",
                                                   QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
                                                   QtWidgets.QMessageBox.StandardButton.Yes)
            if reply == QtWidgets.QMessageBox.StandardButton.Yes:
                self.restart_application()
            
        elif status == "FAILED":
            QtWidgets.QMessageBox.critical(self, "Update Failed", message)

    def restart_application(self):
        presence.end()
        self.dukto_handler.shutdown()
        
        args = [sys.executable] + sys.argv

        subprocess.Popen(args)
        
        QtWidgets.QApplication.quit()


def main():
    app = QtWidgets.QApplication(sys.argv)
    app.setApplicationName("CLARA")

    restart = "--restart" in sys.argv
    no_quit = "--no-quit" in sys.argv
    super_menu = not "--no-super" in sys.argv
    
    dukto_handler = DuktoProtocol()
    
    pet = MainWindow(dukto_handler=dukto_handler, restart=restart, no_quit=no_quit, super_menu=super_menu)
    
    presence.start()
    
    dukto_handler.initialize()
    dukto_handler.say_hello()
    
    # bottom right corner
    screen_geometry = app.primaryScreen().availableGeometry()
    pet_geometry = pet.frameGeometry()
    x = screen_geometry.width() - pet_geometry.width()
    y = screen_geometry.height() - pet_geometry.height()
    pet.move(x, y)

    pet.show()

    app.aboutToQuit.connect(presence.end)
    app.aboutToQuit.connect(dukto_handler.shutdown)
    sys.exit(app.exec())


if __name__ == "__main__":
    main()