main.py

import sys
import os
import google.generativeai as genai
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QHBoxLayout, QVBoxLayout,
    QTextEdit, QLineEdit, QLabel, QSplitter, QMessageBox, QPushButton,
    QFileDialog, QSizePolicy, QListWidget, QListWidgetItem,
    QSystemTrayIcon, QMenu, QStyle, QFrame # Added QFrame
)
from PySide6.QtCore import Qt, Slot, Signal, QObject, QBuffer, QIODevice, QRunnable, QThreadPool, QTimer, QRect
from PySide6.QtGui import QPixmap, QImage, QIcon, QTextCursor, QAction, QPainter, QColor, QFont
import threading
from io import BytesIO
import functools
import re
import mss
import tempfile
from PIL import Image
import pytesseract
import datetime
import json
import webbrowser
import urllib.parse

from quick_ask_overlay import InsightOverlay
from plugin_manager import PluginManager
from api_key_dialog import ApiKeyDialog
from region_selector_widget import RegionSelectorWidget
from chat_session_manager import ChatSession, ChatMessage, db_manager
from typing import Optional, List, Dict
from google.generativeai import types as genai_types
from google.ai.generativelanguage_v1beta.types import GroundingMetadata

# Attempt to import autorun, will be handled in auto-start methods if missing
try:
    import autorun
except ImportError:
    autorun = None

# --- Styling Constants ---
STYLE_CONSTANTS = {
    "MAIN_BG_COLOR": "rgba(20, 22, 30, 0.95)",
    "PANEL_BG_COLOR": "rgba(40, 42, 54, 0.85)",
    "MIDDLE_PANEL_BG_COLOR": "rgba(30, 32, 40, 0.9)",
    "ACCENT_VIOLET": "rgba(180, 100, 220, 0.75)",
    "ACCENT_BLUE": "rgba(80, 150, 230, 0.75)",
    "ACCENT_GREY": "rgba(70, 73, 90, 0.75)",
    "BORDER_COLOR": "rgba(220, 220, 255, 0.15)",
    "TEXT_COLOR_LIGHT": "rgb(240, 240, 240)",
    "TEXT_COLOR_MEDIUM": "rgb(180, 180, 200)",
    "TEXT_COLOR_DARK": "rgb(40, 42, 54)",
    "INPUT_FIELD_BG": "rgba(20, 22, 30, 0.7)",
    "BUTTON_BG_COLOR": "rgba(80, 85, 110, 0.8)",
    "BUTTON_HOVER_BG_COLOR": "rgba(100, 105, 130, 0.85)",
    "BUTTON_PRESSED_BG_COLOR": "rgba(70, 75, 100, 0.9)",
    "SCROLL_BAR_BG": "rgba(20, 22, 30, 0.8)",
    "SCROLL_BAR_HANDLE": "rgba(70, 73, 90, 0.9)",
    "SCROLL_BAR_HANDLE_HOVER": "rgba(90, 93, 120, 0.95)",
    "FONT_FAMILY": "Inter, Roboto, Lato, Sans-Serif",
    "FONT_SIZE_NORMAL": "10pt",
    "FONT_SIZE_SMALL": "9pt",
    "FONT_SIZE_LARGE": "12pt",
    "BORDER_RADIUS": "12px",
    "BORDER_RADIUS_SM": "8px",
}

def get_base_stylesheet():
    return f"""
        QWidget {{
            font-family: {STYLE_CONSTANTS['FONT_FAMILY']};
            font-size: {STYLE_CONSTANTS['FONT_SIZE_NORMAL']};
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
        }}
        QMainWindow {{
            background-color: {STYLE_CONSTANTS['MAIN_BG_COLOR']};
        }}
        QWidget#LeftColumnWidget, QWidget#RightColumnWidget {{
            background-color: {STYLE_CONSTANTS['PANEL_BG_COLOR']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS']};
        }}
        QWidget#MiddleColumnWidget {{
            background-color: {STYLE_CONSTANTS['MIDDLE_PANEL_BG_COLOR']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS']};
        }}
        QLabel {{
            background-color: transparent;
            color: {STYLE_CONSTANTS['TEXT_COLOR_MEDIUM']};
        }}
        QLabel#TitleLabel {{
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
            font-size: {STYLE_CONSTANTS['FONT_SIZE_LARGE']};
            font-weight: bold;
            padding: 5px 0px;
        }}
        QLineEdit {{
            background-color: {STYLE_CONSTANTS['INPUT_FIELD_BG']};
            border: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']};
            padding: 6px 10px;
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
        }}
        QLineEdit:focus {{
            border: 1px solid {STYLE_CONSTANTS['ACCENT_VIOLET']};
        }}
        QTextEdit {{
            background-color: {STYLE_CONSTANTS['INPUT_FIELD_BG']};
            border: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']};
            padding: 6px;
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
        }}
        QTextEdit#ChatArea {{
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS']};
            background-color: rgba(0,0,0,0.1); /* Slightly darker than middle panel for depth */
        }}
        QPushButton {{
            background-color: {STYLE_CONSTANTS['BUTTON_BG_COLOR']};
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
            border: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']};
            padding: 6px 12px;
            min-height: 20px;
        }}
        QPushButton:hover {{
            background-color: {STYLE_CONSTANTS['BUTTON_HOVER_BG_COLOR']};
            border: 1px solid {STYLE_CONSTANTS['ACCENT_BLUE']};
        }}
        QPushButton:pressed {{
            background-color: {STYLE_CONSTANTS['BUTTON_PRESSED_BG_COLOR']};
        }}
        QPushButton:disabled {{
            background-color: rgba(50,50,50,0.7);
            color: rgba(150,150,150,0.7);
        }}
        QListWidget {{
            background-color: rgba(0,0,0,0.1);
            border: none; /* Remove default border, panel provides container */
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']};
            padding: 4px;
        }}
        QListWidget::item {{
            background-color: rgba(255, 255, 255, 0.03);
            color: {STYLE_CONSTANTS['TEXT_COLOR_MEDIUM']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']};
            padding: 8px 6px; margin-bottom: 4px;
            border: 1px solid transparent; /* For hover/selection border */
        }}
        QListWidget::item:hover {{
            background-color: {STYLE_CONSTANTS['ACCENT_GREY']};
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
            border: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']};
        }}
        QListWidget::item:selected {{
            background-color: {STYLE_CONSTANTS['ACCENT_VIOLET']};
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
            border: 1px solid {STYLE_CONSTANTS['ACCENT_BLUE']};
        }}
        QScrollBar:vertical {{
            background: {STYLE_CONSTANTS['SCROLL_BAR_BG']}; width: 10px; margin: 0px; border-radius: 5px;
        }}
        QScrollBar::handle:vertical {{
            background: {STYLE_CONSTANTS['SCROLL_BAR_HANDLE']}; min-height: 20px; border-radius: 5px;
        }}
        QScrollBar::handle:vertical:hover {{ background: {STYLE_CONSTANTS['SCROLL_BAR_HANDLE_HOVER']}; }}
        QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{ height: 0px; background: none; }}
        QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical {{ background: none; }}
        QScrollBar:horizontal {{
            background: {STYLE_CONSTANTS['SCROLL_BAR_BG']}; height: 10px; margin: 0px; border-radius: 5px;
        }}
        QScrollBar::handle:horizontal {{
            background: {STYLE_CONSTANTS['SCROLL_BAR_HANDLE']}; min-width: 20px; border-radius: 5px;
        }}
        QScrollBar::handle:horizontal:hover {{ background: {STYLE_CONSTANTS['SCROLL_BAR_HANDLE_HOVER']}; }}
        QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{ width: 0px; background: none; }}
        QScrollBar::add-page:horizontal, QScrollBar::sub-page:horizontal {{ background: none; }}
        QSplitter::handle {{ background-color: {STYLE_CONSTANTS['BORDER_COLOR']}; }}
        QSplitter::handle:horizontal {{ width: 1px; }}
        QSplitter::handle:vertical {{ height: 1px; }}
        QSplitter::handle:pressed {{ background-color: {STYLE_CONSTANTS['ACCENT_BLUE']}; }}
        QMenu {{
            background-color: {STYLE_CONSTANTS['PANEL_BG_COLOR']};
            border: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']};
            border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']}; padding: 5px;
        }}
        QMenu::item {{ padding: 5px 20px; color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']}; }}
        QMenu::item:selected {{ background-color: {STYLE_CONSTANTS['ACCENT_VIOLET']}; }}
        QMenu::separator {{ height: 1px; background: {STYLE_CONSTANTS['BORDER_COLOR']}; margin: 4px 0px; }}
        QToolTip {{
            background-color: {STYLE_CONSTANTS['PANEL_BG_COLOR']};
            color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};
            border: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']};
            padding: 4px; border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']};
        }}
    """

# ... (WorkerSignals, GeminiRunnable, HotkeySignal classes remain the same) ...
class WorkerSignals(QObject):
    finished = Signal(object, str, list, str, int, str, str)
    error = Signal(str, list, str, int, str)

class GeminiRunnable(QRunnable):
    def __init__(self, model_to_use, query_content_parts, source, iteration_count,
                 generation_config: Optional[genai_types.GenerationConfig] = None,
                 is_context_analysis_request=False):
        super().__init__()
        self.model_to_use = model_to_use
        self.query_content_parts = query_content_parts
        self.source = source
        self.iteration_count = iteration_count
        self.generation_config = generation_config
        self.signals = WorkerSignals()
        self.is_cancelled = False
        self.is_context_analysis_request = is_context_analysis_request

    @Slot()
    def run(self):
        if self.is_cancelled:
            self.signals.error.emit("Request cancelled before start", self.query_content_parts, self.source, self.iteration_count, self.model_to_use.model_name)
            return
        try:
            response = self.model_to_use.generate_content(
                self.query_content_parts,
                generation_config=self.generation_config,
            )
            actions_json_str = None
            if self.is_context_analysis_request:
                actions_json_str = response.text
            if self.is_cancelled:
                self.signals.error.emit("Request cancelled during execution", self.query_content_parts, self.source, self.iteration_count, self.model_to_use.model_name)
                return
            self.signals.finished.emit(response, None, self.query_content_parts, self.source, self.iteration_count, self.model_to_use.model_name, actions_json_str if actions_json_str is not None else "")
        except Exception as e:
            print(f"[GeminiRunnable Error] Exception during API call: {e}")
            if not self.is_cancelled:
                 self.signals.error.emit(str(e), self.query_content_parts, self.source, self.iteration_count, self.model_to_use.model_name)

    def cancel(self):
        print(f"[GeminiRunnable] Attempting to cancel task for source {self.source}, iter {self.iteration_count}")
        self.is_cancelled = True

class HotkeySignal(QObject):
    toggle_overlay = Signal()
    trigger_screen_capture = Signal()


class MainApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Gemini Desktop Agent")
        self.setGeometry(100, 100, 1200, 850) # Increased height slightly for new layout

        # Set WA_TranslucentBackground if aiming for true desktop passthrough for blur
        # self.setAttribute(Qt.WA_TranslucentBackground)
        # self.setStyleSheet("background:transparent;") # Required if WA_TranslucentBackground is set

        main_widget = QWidget(); self.setCentralWidget(main_widget)
        # The main_layout will now be directly on the main_widget (centralWidget)
        # and will contain the QSplitter which then holds the columns.
        main_layout_for_splitter = QHBoxLayout(main_widget) # Use this for the splitter
        main_layout_for_splitter.setContentsMargins(5,5,5,5) # Small margin around splitter

        self.thread_pool = QThreadPool(); self.active_gemini_runnable = None
        self.gemini_model = None; self.gemini_vision_model = None
        self.attached_image_path = None; self.attached_ocr_text = None; self.current_iteration_data = None
        self.sessions: List[ChatSession] = []; self.current_session_id: Optional[str] = None
        db_manager.initialize_database()
        self.insight_overlay = InsightOverlay()
        self.insight_overlay.query_submitted.connect(self.handle_insight_overlay_query)
        self.insight_overlay.request_close.connect(self.handle_insight_overlay_close_request)
        self.insight_overlay.action_button_clicked_signal.connect(self.handle_context_action)
        self.insight_overlay.region_selection_initiated.connect(self.initiate_region_selection_for_overlay)
        self.region_selector_widget = None
        self.hotkey_signal = HotkeySignal()
        try:
            self.hotkey_listener_thread = threading.Thread(target=self.init_hotkey_listener, daemon=True)
            self.hotkey_listener_thread.start()
            self.hotkey_signal.toggle_overlay.connect(self.toggle_insight_overlay)
            self.hotkey_signal.trigger_screen_capture.connect(functools.partial(self.capture_screen_and_attach, True, None))
            print("Hotkey listener started.")
        except Exception as e:
            print(f"WARNING: Failed to initialize hotkey listener: {e}. Hotkeys will be disabled.")
        self.plugin_manager = PluginManager(plugin_folder="plugins")
        self.plugin_manager.plugin_loaded.connect(self.on_plugin_loaded)
        self.plugin_manager.plugin_error.connect(self.on_plugin_error)
        plugins_init_path = os.path.join("plugins", "__init__.py")
        if not os.path.exists(plugins_init_path):
            if not os.path.exists("plugins"): os.makedirs("plugins")
            with open(plugins_init_path, "w") as f: pass
        self.plugin_manager.discover_plugins(); self.plugin_manager.load_all_plugins()

        self._load_config_settings()
        self._setup_ui(main_layout_for_splitter) # Pass the layout for the splitter
        self._setup_tray_icon()
        self._load_or_create_initial_session()
        QTimer.singleShot(0, self.init_gemini_with_key_prompt)

    def _load_config_settings(self):
        self.config_path = self.get_config_path()
        self.app_settings = {"api_key": None, "auto_start_enabled": False}
        try:
            if os.path.exists(self.config_path):
                with open(self.config_path, 'r') as f:
                    loaded_settings = json.load(f)
                    for key, default_value in self.app_settings.items():
                        if key in loaded_settings:
                            self.app_settings[key] = loaded_settings[key]
                print(f"Loaded settings from {self.config_path}: {self.app_settings}")
        except json.JSONDecodeError as e:
            print(f"Error decoding JSON from {self.config_path}: {e}. Using defaults and attempting to overwrite corrupted file.")
            try:
                os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
                with open(self.config_path, 'w') as f:
                    json.dump(self.app_settings, f, indent=4)
                print(f"Corrupted config file was overwritten with defaults at {self.config_path}")
            except Exception as save_e:
                print(f"Could not overwrite corrupted config file: {save_e}")
        except Exception as e:
            print(f"Error loading config from {self.config_path}: {e}. Using defaults.")
        if not isinstance(self.app_settings.get("auto_start_enabled"), bool):
            self.app_settings["auto_start_enabled"] = False
        if self.app_settings.get("api_key") == "":
            self.app_settings["api_key"] = None

    def _save_config_settings(self):
        try:
            os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
            with open(self.config_path, 'w') as f:
                json.dump(self.app_settings, f, indent=4)
            print(f"Saved settings to {self.config_path}")
        except Exception as e:
            print(f"Error saving config to {self.config_path}: {e}")
            QMessageBox.warning(self, "Config Error", f"Could not save settings to {self.config_path}:\n{e}")

    def _setup_tray_icon(self):
        self.tray_icon = QSystemTrayIcon(self)
        app_icon = QIcon.fromTheme("application-x-executable", self.style().standardIcon(QStyle.SP_ComputerIcon))
        icons_dir = "icons"; custom_icon_path = os.path.join(icons_dir, "app_icon.png")
        if not os.path.exists(icons_dir):
            try: os.makedirs(icons_dir); print(f"Created '{icons_dir}' directory for application icons.")
            except OSError as e: print(f"Warning: Could not create '{icons_dir}' directory: {e}")
        if os.path.exists(custom_icon_path): app_icon = QIcon(custom_icon_path)
        elif app_icon.isNull():
            print("Warning: No suitable application icon found for tray. Using a default generated icon.")
            pixmap = QPixmap(32, 32); pixmap.fill(Qt.transparent)
            painter = QPainter(pixmap)
            try:
                font = painter.font(); font.setPointSize(18); painter.setFont(font)
                painter.setPen(Qt.blue); painter.drawText(pixmap.rect(), Qt.AlignCenter, "G")
            finally: painter.end()
            app_icon = QIcon(pixmap)
        self.tray_icon.setIcon(app_icon)
        self.tray_icon.setToolTip("Gemini Desktop Agent")
        tray_menu = QMenu(self)
        toggle_window_action = QAction("Show/Hide Agent", self)
        toggle_window_action.triggered.connect(self.toggle_main_window_visibility)
        tray_menu.addAction(toggle_window_action)
        tray_menu.addSeparator()
        self.auto_start_action = QAction("Start with System", self)
        self.auto_start_action.setCheckable(True)
        self.auto_start_action.setChecked(self.app_settings.get("auto_start_enabled", False))
        if autorun is None:
            self.auto_start_action.setEnabled(False)
            self.auto_start_action.setToolTip("Auto-start feature requires 'autorun' library (pip install autorun)")
        self.auto_start_action.triggered.connect(self.handle_auto_start_toggle)
        tray_menu.addAction(self.auto_start_action)
        tray_menu.addSeparator()
        quit_action = QAction("Quit Agent", self)
        quit_action.triggered.connect(self.actual_quit)
        tray_menu.addAction(quit_action)
        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.activated.connect(self.handle_tray_icon_activation)
        if QSystemTrayIcon.isSystemTrayAvailable():
            self.tray_icon.show(); print("System tray icon initialized.")
        else: print("Warning: System tray not available. Tray icon will not be shown.")
        self.is_hidden_to_tray = False

    def handle_tray_icon_activation(self, reason):
        if reason == QSystemTrayIcon.ActivationReason.Trigger: self.toggle_main_window_visibility()

    def toggle_main_window_visibility(self):
        if self.isHidden() or self.is_hidden_to_tray:
            self.showNormal(); self.activateWindow(); self.raise_(); self.is_hidden_to_tray = False
        else:
            self.hide(); self.is_hidden_to_tray = True
            if QSystemTrayIcon.isSystemTrayAvailable() and self.tray_icon.isVisible():
                self.tray_icon.showMessage("Agent Minimized", "Gemini Agent is running in the background.", QSystemTrayIcon.Information, 2000)
            else: print("Agent hidden (no system tray message as tray is not available/visible).")

    def actual_quit(self):
        print("Quitting application via tray menu.")
        if hasattr(self, 'tray_icon') and self.tray_icon.isVisible(): self.tray_icon.hide()
        if self.active_gemini_runnable:
            print("actual_quit: Cancelling active Gemini runnable."); self.active_gemini_runnable.cancel()
        print("actual_quit: Waiting for QThreadPool to finish...")
        self.thread_pool.clear(); self.thread_pool.waitForDone(1000)
        QApplication.instance().quit()

    @Slot(bool)
    def handle_auto_start_toggle(self, checked):
        if checked: self.enable_auto_start()
        else: self.disable_auto_start()
        self.auto_start_action.setChecked(self.app_settings.get("auto_start_enabled", False))

    def enable_auto_start(self):
        if not autorun:
            print("WARNING: 'autorun' library not available. Auto-start feature disabled.")
            QMessageBox.warning(self, "Auto-start Error", "The 'autorun' library is not installed or failed to import. Please install it to use this feature (`pip install autorun`).")
            self.app_settings["auto_start_enabled"] = False
            self._save_config_settings()
            return
        try:
            script_path = os.path.abspath(__file__)
            autorun.add("GeminiDesktopAgent", sys.executable, args=[script_path, "--started-from-autorun"])
            print("Auto-start enabled successfully.")
            self.statusBar().showMessage("Auto-start enabled.", 3000)
            self.app_settings["auto_start_enabled"] = True
        except Exception as e:
            print(f"Error enabling auto-start: {e}")
            QMessageBox.warning(self, "Auto-start Error", f"Could not enable auto-start: {e}")
            self.app_settings["auto_start_enabled"] = False
        self._save_config_settings()

    def disable_auto_start(self):
        if not autorun:
            print("WARNING: 'autorun' library not available. Cannot manage auto-start.")
            return
        try:
            autorun.remove("GeminiDesktopAgent")
            print("Auto-start disabled successfully.")
            self.statusBar().showMessage("Auto-start disabled.", 3000)
            self.app_settings["auto_start_enabled"] = False
        except Exception as e:
            print(f"Error disabling auto-start (entry might not exist or other issue): {e}")
            self.app_settings["auto_start_enabled"] = False
        self._save_config_settings()

    def _load_or_create_initial_session(self):
        self.sessions = db_manager.load_all_sessions()
        if not self.sessions:
            first_session = self._create_new_session(title="Initial Chat")
            db_manager.save_session(first_session)
            self._add_message_to_current_session("system", f"Chat session started: {first_session.title}")
        else:
            sorted_sessions = sorted(self.sessions, key=lambda s: s.last_modified_time, reverse=True)
            self.current_session_id = sorted_sessions[0].session_id
            current_s = self.get_current_session()
            if current_s:
                current_s.messages = db_manager.load_messages_for_session(self.current_session_id)
                self._redisplay_current_session_messages()
        self._update_history_panel()

    def _setup_ui(self, main_layout): # main_layout is QHBoxLayout for the central widget
        # Main splitter for three columns
        splitter = QSplitter(Qt.Horizontal)
        main_layout.addWidget(splitter) # Add splitter to the layout of central widget

        # --- Left Column (Navigation & Chat History) ---
        left_column_widget = QWidget()
        left_column_widget.setObjectName("LeftColumnWidget")
        left_column_layout = QVBoxLayout(left_column_widget)
        left_column_layout.setContentsMargins(10, 10, 10, 10)
        left_column_layout.setSpacing(8)

        # Profile/Logo area (Placeholder)
        profile_area_layout = QHBoxLayout()
        profile_pic_label = QLabel() # Placeholder for circle image
        profile_pic_label.setFixedSize(32, 32)
        profile_pic_label.setStyleSheet("background-color: #50fa7b; border-radius: 16px;") # Temp color
        profile_area_layout.addWidget(profile_pic_label)
        profile_area_layout.addStretch(1)
        left_column_layout.addLayout(profile_area_layout)

        chat_history_title = QLabel("Chat History")
        chat_history_title.setObjectName("TitleLabel")
        left_column_layout.addWidget(chat_history_title)

        self.history_search_field = QLineEdit(placeholderText="Search history...")
        left_column_layout.addWidget(self.history_search_field)

        self.new_chat_button = QPushButton("➕ New Chat")
        self.new_chat_button.clicked.connect(self.handle_new_chat_button)
        left_column_layout.addWidget(self.new_chat_button)

        self.history_list_widget = QListWidget()
        self.history_list_widget.setObjectName("historyPanel") # Keep for potential specific styling
        self.history_list_widget.itemClicked.connect(self._load_session_from_history_item)
        left_column_layout.addWidget(self.history_list_widget, 1) # Stretch factor

        # Bottom settings bar (Placeholder)
        left_bottom_bar_layout = QHBoxLayout()
        settings_btn = QPushButton(); settings_btn.setIcon(self.style().standardIcon(QStyle.SP_FileDialogDetailedView)) # Placeholder icon
        settings_btn.setToolTip("Settings")
        help_btn = QPushButton(); help_btn.setIcon(self.style().standardIcon(QStyle.SP_MessageBoxQuestion)) # Placeholder icon
        help_btn.setToolTip("Help")
        left_bottom_bar_layout.addWidget(settings_btn); left_bottom_bar_layout.addWidget(help_btn)
        left_bottom_bar_layout.addStretch(1)
        left_column_layout.addLayout(left_bottom_bar_layout)

        splitter.addWidget(left_column_widget)

        # --- Middle Column (Chat Window / KI Interaction) ---
        middle_column_widget = QWidget()
        middle_column_widget.setObjectName("MiddleColumnWidget")
        middle_column_layout = QVBoxLayout(middle_column_widget)
        middle_column_layout.setContentsMargins(0, 0, 0, 0) # No margins, panel has radius
        middle_column_layout.setSpacing(0) # No spacing, manage padding internally

        # Chat Header (Placeholder)
        chat_header_widget = QWidget()
        chat_header_widget.setObjectName("ChatHeaderWidget") # For styling
        chat_header_widget.setFixedHeight(50)
        chat_header_widget.setStyleSheet(f"background-color: {STYLE_CONSTANTS['PANEL_BG_COLOR']}; border-bottom: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']}; border-top-left-radius: {STYLE_CONSTANTS['BORDER_RADIUS']}; border-top-right-radius: {STYLE_CONSTANTS['BORDER_RADIUS']};")
        chat_header_layout = QHBoxLayout(chat_header_widget)
        chat_header_layout.setContentsMargins(10,0,10,0)
        ki_pic_label = QLabel(); ki_pic_label.setFixedSize(30,30); ki_pic_label.setStyleSheet("background-color: #6272a4; border-radius: 15px;")
        ki_name_label = QLabel("Gemini AI <small style='color:#50fa7b;'>● Active now</small>") # Rich text for status
        ki_name_label.setObjectName("TitleLabel") # Reuse title style

        video_call_btn = QPushButton(); video_call_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)); video_call_btn.setFixedSize(30,30) # Placeholder
        voice_call_btn = QPushButton(); voice_call_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume)); voice_call_btn.setFixedSize(30,30) # Placeholder
        more_menu_btn = QPushButton("..."); more_menu_btn.setFixedSize(30,30) # Placeholder

        chat_header_layout.addWidget(ki_pic_label); chat_header_layout.addWidget(ki_name_label); chat_header_layout.addStretch(1)
        chat_header_layout.addWidget(video_call_btn); chat_header_layout.addWidget(voice_call_btn); chat_header_layout.addWidget(more_menu_btn)
        middle_column_layout.addWidget(chat_header_widget)

        self.chat_area = QTextEdit(readOnly=True, placeholderText="Initializing Gemini Agent...")
        self.chat_area.setObjectName("ChatArea")
        self.chat_area.setTextInteractionFlags(Qt.TextBrowserInteraction)
        self.chat_area.setOpenExternalLinks(True)
        middle_column_layout.addWidget(self.chat_area, 1) # Stretch factor

        # Input Area
        input_composite_widget = QWidget() # Container for padding and consistent bg
        input_composite_widget.setObjectName("ChatInputComposite")
        input_composite_widget.setStyleSheet(f"background-color: {STYLE_CONSTANTS['PANEL_BG_COLOR']}; border-top: 1px solid {STYLE_CONSTANTS['BORDER_COLOR']}; border-bottom-left-radius: {STYLE_CONSTANTS['BORDER_RADIUS']}; border-bottom-right-radius: {STYLE_CONSTANTS['BORDER_RADIUS']};")
        input_composite_layout = QVBoxLayout(input_composite_widget)
        input_composite_layout.setContentsMargins(10,10,10,10); input_composite_layout.setSpacing(5)

        self.attached_image_preview_label = QLabel(alignment=Qt.AlignCenter)
        self.attached_image_preview_label.setFixedSize(80,80); self.attached_image_preview_label.hide()
        self.attached_image_preview_label.setStyleSheet(f"border: 1px dashed {STYLE_CONSTANTS['BORDER_COLOR']}; border-radius: {STYLE_CONSTANTS['BORDER_RADIUS_SM']}; background-color: rgba(0,0,0,0.1);")
        self.attached_image_preview_label.mousePressEvent = self.clear_attached_image_preview
        input_composite_layout.addWidget(self.attached_image_preview_label, 0, Qt.AlignLeft) # Show preview above input line

        input_line_layout = QHBoxLayout()
        # Placeholder for Plus icon button
        # attach_button = QPushButton("+"); attach_button.setFixedSize(35,35)
        # input_line_layout.addWidget(attach_button)

        self.input_field = QLineEdit(placeholderText="Type something or pick one from prompt gallery...")
        self.input_field.returnPressed.connect(self.handle_user_input)
        input_line_layout.addWidget(self.input_field, 1)

        # self.attach_image_button, self.screenshot_button moved here if needed, or use the "+" button
        # For now, keeping existing attach/screenshot buttons:
        self.attach_image_button = QPushButton(); self.attach_image_button.setIcon(self.style().standardIcon(QStyle.SP_FileLinkIcon)); self.attach_image_button.setToolTip("Attach Image")
        self.attach_image_button.clicked.connect(self.select_image_to_attach)
        input_line_layout.addWidget(self.attach_image_button)

        self.screenshot_button = QPushButton(); self.screenshot_button.setIcon(self.style().standardIcon(QStyle.SP_DesktopIcon)); self.screenshot_button.setToolTip("Capture Screen (Ctrl+Shift+C)")
        self.screenshot_button.clicked.connect(functools.partial(self.capture_screen_and_attach, True, None))
        input_line_layout.addWidget(self.screenshot_button)

        # Placeholder for Mic icon button
        # mic_button = QPushButton("Mic"); mic_button.setFixedSize(35,35)
        # input_line_layout.addWidget(mic_button)
        send_button = QPushButton(); send_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight)) # Placeholder icon
        send_button.setToolTip("Send Message")
        send_button.clicked.connect(self.handle_user_input)
        input_line_layout.addWidget(send_button)
        input_composite_layout.addLayout(input_line_layout)

        # Prompt suggestions (Placeholder)
        prompt_chips_layout = QHBoxLayout()
        # Example chip: chip1 = QPushButton("List recipes in JSON"); chip1.setObjectName("PromptChip")
        # prompt_chips_layout.addWidget(chip1)
        prompt_chips_layout.addStretch(1)
        input_composite_layout.addLayout(prompt_chips_layout)

        middle_column_layout.addWidget(input_composite_widget)
        splitter.addWidget(middle_column_widget)

        # --- Right Column (Settings / Tools / Details) ---
        right_column_widget = QWidget()
        right_column_widget.setObjectName("RightColumnWidget")
        right_column_layout = QVBoxLayout(right_column_widget)
        right_column_layout.setContentsMargins(10, 10, 10, 10)
        right_column_layout.setSpacing(8)

        run_settings_title = QLabel("Run Settings") # Placeholder
        run_settings_title.setObjectName("TitleLabel")
        right_column_layout.addWidget(run_settings_title)

        # Placeholders for settings elements
        # Model ComboBox
        model_label = QLabel("Model:")
        self.model_combo = QPushButton("Gemini Pro (Placeholder)") # Using QPushButton as temp dropdown
        # self.model_combo = QComboBox(); self.model_combo.addItems(["Gemini 1.5 Pro", "Gemini 1.0 Pro"])
        right_column_layout.addWidget(model_label); right_column_layout.addWidget(self.model_combo)

        # Temperature Slider
        temp_label = QLabel("Temperature: 0.9")
        self.temp_slider = QPushButton("|||||-----") # Using QPushButton as temp slider
        # self.temp_slider = QSlider(Qt.Horizontal)
        right_column_layout.addWidget(temp_label); right_column_layout.addWidget(self.temp_slider)

        tools_title = QLabel("Tools") # Placeholder
        tools_title.setObjectName("TitleLabel")
        right_column_layout.addWidget(tools_title)
        # Placeholder for tool toggles
        # tool1_checkbox = QCheckBox("Structured output"); right_column_layout.addWidget(tool1_checkbox)

        self.context_panel = QTextEdit(readOnly=True, placeholderText="Context / Search Sources / Files") # Re-purpose for general context
        self.context_panel.setObjectName("ContextPanel") # For specific styling if needed
        self.context_panel.setTextInteractionFlags(Qt.TextBrowserInteraction)
        self.context_panel.setOpenExternalLinks(True)
        right_column_layout.addWidget(QLabel("Context Output:"), 0) # Add a label for clarity
        right_column_layout.addWidget(self.context_panel, 1) # Stretch factor

        right_column_layout.addStretch(1) # Push elements to top
        splitter.addWidget(right_column_widget)

        # Set initial splitter sizes (adjust as needed)
        # Approximate Google AI Studio: Left: 20-25%, Middle: 50-60%, Right: 20-25%
        total_width = self.width() # Initial width
        splitter.setSizes([int(total_width*0.22), int(total_width*0.56), int(total_width*0.22)])
        splitter.setCollapsible(0, False); splitter.setCollapsible(1, False); splitter.setCollapsible(2, False) # Prevent collapsing

        self.statusBar().showMessage("Waiting for API Key...")
        self.input_field.setEnabled(False); self.attach_image_button.setEnabled(False); self.screenshot_button.setEnabled(False)


    def _create_new_session(self, title: Optional[str] = None) -> ChatSession:
        if title is None: title = f"Chat {len(self.sessions) + 1} ({datetime.datetime.now().strftime('%H:%M')})"
        session = ChatSession(title=title)
        self.sessions.append(session); self.current_session_id = session.session_id
        print(f"Created new session (in memory): ID={session.session_id}, Title='{session.title}'")
        return session

    def get_current_session(self) -> Optional[ChatSession]:
        if self.current_session_id:
            return next((s for s in self.sessions if s.session_id == self.current_session_id), None)
        if not self.sessions: return self._create_new_session("Initial Session (fallback)")
        self.current_session_id = sorted(self.sessions, key=lambda s: s.last_modified_time, reverse=True)[0].session_id
        return self.get_current_session()

    def _add_message_to_current_session(self, sender: str, text: str, image_path: Optional[str] = None, ocr_text: Optional[str] = None, is_thinking_message: bool = False, grounding_metadata: Optional[GroundingMetadata] = None):
        session = self.get_current_session()
        if not session:
            print("CRITICAL: No current session. Creating emergency session."); session = self._create_new_session("Emergency")
            db_manager.save_session(session)
            if hasattr(self, 'history_list_widget'): self._update_history_panel()
        formatted_text_for_ui = text
        if not is_thinking_message:
            if grounding_metadata:
                formatted_text_for_ui = self._format_text_with_citations(text, grounding_metadata)
            message_obj = session.add_message(sender, formatted_text_for_ui, image_path, ocr_text)
            db_manager.save_message(message_obj, session.session_id)
            session.last_modified_time = datetime.datetime.now()
            db_manager.save_session(session)

        if hasattr(self, 'chat_area') and session.session_id == self.current_session_id and \
           (self.current_iteration_data is None or self.current_iteration_data.get('source') == "main_chat" or sender == "system" or is_thinking_message):
            # Basic HTML structure for chat messages for styling potential
            # For actual Glasmorphismus on bubbles, this will need significant work (likely custom delegate or web view)
            # For now, simple styled text.

            bubble_style = "padding: 8px 12px; border-radius: 10px; margin-bottom: 8px; max-width: 70%;"
            align_style = ""

            if sender == "user":
                bubble_bg = STYLE_CONSTANTS['ACCENT_VIOLET'].replace("0.75", "0.6") # Slightly less opaque for bubbles
                align_style = "margin-left: auto; margin-right: 5px;" # Right align
            elif sender == "gemini":
                bubble_bg = STYLE_CONSTANTS['ACCENT_GREY'].replace("0.75", "0.6")
                align_style = "margin-left: 5px; margin-right: auto;" # Left align
            else: # System, error, plugin
                bubble_bg = "transparent"
                # For system messages, we might not want a bubble, just text.
                # Using existing logic which prepends sender name.
                display_parts = []
                if sender == "system_error": display_parts.append("<b>Error:</b>")
                elif sender == "plugin_result": display_parts.append("<b>Plugin:</b>")
                else: display_parts.append(f"<i>{sender.capitalize()}:</i>") # Italicize system messages

                if image_path and not is_thinking_message: display_parts.append(f"<br>[<i>Image: {os.path.basename(image_path)}</i>]")
                if ocr_text and image_path and not is_thinking_message: display_parts.append("<br>[<i>OCR Text extracted</i>]")
                elif ocr_text and not is_thinking_message: display_parts.append(f"<br>[<i>OCR: {ocr_text[:30]}...</i>]")

                display_parts.append(formatted_text_for_ui.replace("\n", "<br>"))
                self.chat_area.append("<div>" + " ".join(display_parts) + "</div><br>")
                return


            # For user/gemini messages with bubbles:
            # This HTML structure is a basic attempt. Real chat bubbles are complex.
            # QTextEdit's HTML support is limited.
            # A simple approach with background color on a div:
            html_message = f"""
                <div style='display: flex; justify-content: {'flex-end' if sender == 'user' else 'flex-start'};'>
                    <div style='background-color: {bubble_bg}; {bubble_style} {align_style} color: {STYLE_CONSTANTS['TEXT_COLOR_LIGHT']};'>
                        <b>{sender.capitalize()}:</b><br>
                        {formatted_text_for_ui.replace("\n", "<br>")}
                    </div>
                </div>
                <br>
            """
            # self.chat_area.append(html_message) # This will likely not render flexbox correctly.
            # Fallback to simpler append for now, styling will be main focus later.

            plain_display_parts = []
            if sender == "user": plain_display_parts.append("<b>You:</b>")
            elif sender == "gemini": plain_display_parts.append("<b>Gemini:</b>")
            # ... (other sender types if needed for non-bubble display)

            if image_path and not is_thinking_message: plain_display_parts.append(f"<br>[<i>Image: {os.path.basename(image_path)}</i>]")
            if ocr_text and image_path and not is_thinking_message: plain_display_parts.append("<br>[<i>OCR Text extracted</i>]")
            elif ocr_text and not is_thinking_message: plain_display_parts.append(f"<br>[<i>OCR: {ocr_text[:30]}...</i>]")

            plain_display_parts.append(formatted_text_for_ui.replace("\n", "<br>"))
            self.chat_area.append(" ".join(plain_display_parts) + "<br>")


    @Slot()
    def handle_new_chat_button(self):
        print("New Chat button clicked.")
        new_session = self._create_new_session()
        db_manager.save_session(new_session)
        self.chat_area.clear(); self.context_panel.clear()
        self._add_message_to_current_session("system", f"New chat started: {new_session.title}")
        self._update_history_panel()

    def _update_history_panel(self):
        self.history_list_widget.clear()
        sorted_sessions = sorted(self.sessions, key=lambda s: s.last_modified_time, reverse=True)
        self.sessions = sorted_sessions
        for session in self.sessions:
            item_text = session.title if session.title else f"Session ({session.start_time.strftime('%Y-%m-%d %H:%M')})"
            # For custom item rendering later:
            # list_item_widget = QWidget()
            # item_layout = QHBoxLayout(list_item_widget)
            # ... add labels for pic, name, last_msg, timestamp
            # item = QListWidgetItem(self.history_list_widget)
            # item.setSizeHint(list_item_widget.sizeHint())
            # self.history_list_widget.setItemWidget(item, list_item_widget)
            item = QListWidgetItem(item_text); item.setData(Qt.UserRole, session.session_id)
            self.history_list_widget.addItem(item)
            if session.session_id == self.current_session_id: self.history_list_widget.setCurrentItem(item)

    def _redisplay_current_session_messages(self):
        self.chat_area.clear(); self.context_panel.clear()
        session = self.get_current_session()
        if session:
            self.chat_area.append(f"<i>Loaded chat: {session.title}</i><br><br>") # Add some space
            for msg in session.messages:
                # Using the same logic as _add_message_to_current_session for display
                # This will need to be updated if chat bubble styling is complex
                self._add_message_to_current_session(msg.sender, msg.text, msg.image_path, msg.ocr_text, is_thinking_message=False) # Ensure it's not treated as thinking
    # ... (The rest of the MainApp methods from previous version) ...
    # init_gemini_with_key_prompt, get_config_path, load_api_key_from_config, save_api_key_to_config,
    # show_api_key_error, capture_screen_and_attach, select_image_to_attach, clear_attached_image_preview,
    # handle_user_input, toggle_insight_overlay, _request_contextual_actions_from_gemini,
    # handle_insight_overlay_query, handle_insight_overlay_close_request, handle_context_action,
    # _start_gemini_request, process_gemini_query, handle_gemini_finished, handle_gemini_error,
    # _format_text_with_citations, _display_grounding_sources, _parse_plugin_params,
    # enable_input_areas, remove_last_chat_message, on_plugin_loaded, on_plugin_error,
    # init_hotkey_listener, initiate_region_selection_for_overlay, handle_region_selection_for_overlay,
    # _process_captured_region_for_overlay, handle_region_selection_cancelled_for_overlay, closeEvent

    def init_gemini_with_key_prompt(self):
        api_key_from_config = self.app_settings.get("api_key")
        if api_key_from_config:
            api_key = api_key_from_config
        elif os.environ.get("GOOGLE_API_KEY"):
            api_key = os.environ.get("GOOGLE_API_KEY")
        else:
            api_key, should_save = ApiKeyDialog.get_api_key_and_save_preference(self)
            if not api_key: self.show_api_key_error("No API Key provided."); return
            if should_save:
                self.app_settings["api_key"] = api_key; self._save_config_settings()
        try:
            if not api_key: self.show_api_key_error("API Key not available."); return
            genai.configure(api_key=api_key)
            self.gemini_model = genai.GenerativeModel(model_name='gemini-pro')
            self.gemini_vision_model = genai.GenerativeModel('gemini-pro-vision')
            self.enable_input_areas("main_chat"); self.statusBar().showMessage("Gemini Ready.")
            self.chat_area.setPlaceholderText("Ask Gemini..."); print("Gemini models initialized.")
        except Exception as e:
            error_msg = f"Failed to init Gemini: {e}."
            if "API key not valid" in str(e):
                error_msg += " Check key & Gemini API enablement."
                if self.app_settings.get("api_key") == api_key:
                    self.app_settings["api_key"] = None; self._save_config_settings()
            self.show_api_key_error(error_msg)

    def get_config_path(self):
        home = os.path.expanduser("~"); app_data_dir_name = ".gemini_desktop_agent"
        app_dir = os.path.join(home, app_data_dir_name)
        if not os.path.exists(app_dir):
            try: os.makedirs(app_dir)
            except OSError: print(f"Warning: Could not create app data directory: {app_dir}"); return "gemini_agent_config.json"
        return os.path.join(app_dir, "config.json")

    def load_api_key_from_config(self, path): return self.app_settings.get("api_key")
    def save_api_key_to_config(self, key, path): self.app_settings["api_key"] = key; self._save_config_settings()

    def show_api_key_error(self, error_message="API Key/Model Init Error."):
        if threading.current_thread() is not threading.main_thread(): print(f"API Key Err (non-GUI): {error_message}"); return
        QMessageBox.critical(self, "API Key Error", f"{error_message}\nPlease verify your API key and ensure the Google AI (Gemini) API is enabled for your project.\nThe application will have limited functionality.")
        for widget_name in ["input_field", "attach_image_button", "screenshot_button"]:
            if hasattr(self, widget_name) and getattr(self,widget_name): getattr(self, widget_name).setEnabled(False)
        if hasattr(self, 'chat_area'): self.chat_area.setPlaceholderText("Gemini features disabled (API key error).")
        self.statusBar().showMessage("Gemini features disabled. API Key error.")

    @Slot(bool, QRect)
    def capture_screen_and_attach(self, for_main_window_attachment=True, region: Optional[QRect] = None):
        if for_main_window_attachment and (self.attached_image_path or self.attached_ocr_text): self.clear_attached_image_preview()
        img_path, ocr_text_val = None, None
        try:
            with mss.mss() as sct:
                monitor_to_capture = sct.monitors[1]
                if region: capture_area = {"top": region.y() + monitor_to_capture["top"], "left": region.x() + monitor_to_capture["left"], "width": region.width(), "height": region.height(), "mon": monitor_to_capture.get("mon", 1)}
                else: capture_area = monitor_to_capture
                sct_img = sct.grab(capture_area); pil_image = Image.frombytes('RGB', sct_img.size, sct_img.rgb)
                try:
                    ocr_text_val = pytesseract.image_to_string(pil_image)
                    if not (ocr_text_val and ocr_text_val.strip()): ocr_text_val = None
                    if ocr_text_val and for_main_window_attachment: self._add_message_to_current_session("system", "OCR extracted from screen" + (" region." if region else "."))
                except pytesseract.TesseractNotFoundError:
                    msg = "Tesseract OCR not found. OCR disabled."
                    if for_main_window_attachment: QMessageBox.warning(self, "OCR Error", msg); self._add_message_to_current_session("system", f"Warning: {msg}")
                    else: print(f"OCR Err for overlay context: {msg}")
                    ocr_text_val = None
                except Exception as e: print(f"OCR error: {e}"); ocr_text_val = None
                ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f"); filename_prefix = "screenshot_region_" if region else "screenshot_full_"
                app_temp_dir = os.path.join(tempfile.gettempdir(), "gemini_desktop_agent_captures")
                if not os.path.exists(app_temp_dir): os.makedirs(app_temp_dir, exist_ok=True)
                img_path = os.path.join(app_temp_dir, f"{filename_prefix}{ts}.png"); pil_image.save(img_path, "PNG")
                if for_main_window_attachment:
                    self.attached_image_path = img_path; self.attached_ocr_text = ocr_text_val
                    pixmap = QPixmap(img_path)
                    if pixmap.isNull(): self.attached_image_path = None; self.attached_ocr_text = None; return None,None
                    self.attached_image_preview_label.setPixmap(pixmap.scaled(self.attached_image_preview_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation))
                    self.attached_image_preview_label.setToolTip(f"Screenshot: {os.path.basename(img_path)}\n(Click to remove)"); self.attached_image_preview_label.show()
                    self.input_field.setPlaceholderText("Screenshot attached. Add prompt or send.")
                    self._add_message_to_current_session("system", "Screenshot" + (" region" if region else "") +" attached.")
            return img_path, ocr_text_val
        except Exception as e:
            err_msg = f"Screen Capture Error: {e}"; print(err_msg);
            if for_main_window_attachment: QMessageBox.warning(self, "Screen Capture Error", err_msg); self._add_message_to_current_session("system", f"Error: {e}")
            return None, None

    @Slot()
    def select_image_to_attach(self):
        if self.attached_image_path or self.attached_ocr_text: self.clear_attached_image_preview()
        f_path, _ = QFileDialog.getOpenFileName(self, "Select Image", "", "Images (*.png *.jpg *.jpeg *.webp)")
        if not f_path: return
        if os.path.getsize(f_path) > 4*1024*1024: QMessageBox.warning(self, "Image Too Large", "Max 4MB."); return
        self.attached_image_path = f_path; self.attached_ocr_text = None
        px = QPixmap(f_path)
        if px.isNull(): self.attached_image_path=None; return
        self.attached_image_preview_label.setPixmap(px.scaled(self.attached_image_preview_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.attached_image_preview_label.setToolTip(f"Attached: {os.path.basename(f_path)}\n(Click to remove)"); self.attached_image_preview_label.show()
        self.input_field.setPlaceholderText("Image file attached. Add prompt or send.")
        self._add_message_to_current_session("system", f"Image file {os.path.basename(f_path)} attached.")

    def clear_attached_image_preview(self, event=None):
        if self.attached_image_path: self._add_message_to_current_session("system", f"Attachment cleared.")
        self.attached_image_path = None; self.attached_ocr_text = None
        self.attached_image_preview_label.hide(); self.attached_image_preview_label.setPixmap(QPixmap())
        self.input_field.setPlaceholderText("Type message or attach image...")

    @Slot()
    def handle_user_input(self):
        txt = self.input_field.text().strip(); current_img_path = self.attached_image_path; current_ocr_text = self.attached_ocr_text
        if not txt and not current_img_path: return
        active_model = self.gemini_vision_model if current_img_path else self.gemini_model
        if not active_model: self.show_api_key_error("Gemini model not ready."); return
        self._add_message_to_current_session("user", txt, image_path=current_img_path, ocr_text=current_ocr_text)
        parts = []; final_txt_for_gemini = txt
        if current_ocr_text: final_txt_for_gemini = f"OCR Context:\n{current_ocr_text}\n\nPrompt:\n{txt}" if txt else f"OCR Context:\n{current_ocr_text}\n\nPrompt: Analyze."
        if final_txt_for_gemini: parts.append({'text': final_txt_for_gemini})
        if current_img_path:
            try:
                _, ext = os.path.splitext(current_img_path); mime = f"image/{ext[1:].lower().replace('jpg','jpeg')}"
                with open(current_img_path,"rb") as f: parts.append({"inline_data":{"mime_type":mime,"data":f.read()}})
            except Exception as e: self._add_message_to_current_session("system_error", f"Error preparing image: {e}"); self.clear_attached_image_preview(); return
        if not parts: self._add_message_to_current_session("system_error", "Error: No content to send."); return
        self.input_field.clear();
        if self.attached_image_path or self.attached_ocr_text: self.clear_attached_image_preview()
        available_tools = self.plugin_manager.get_all_tool_declarations()
        generation_config = genai_types.GenerationConfig(tools=available_tools if available_tools else None)
        self.process_gemini_query(parts, "main_chat", active_model, current_img_path, generation_config=generation_config)

    @Slot()
    def toggle_insight_overlay(self):
        if self.insight_overlay.isVisible(): self.insight_overlay.hide_overlay()
        else:
            image_path, ocr_text = self.capture_screen_and_attach(for_main_window_attachment=False, region=None)
            self.insight_overlay.set_initial_context(image_path, ocr_text)
            if self.attached_image_path or self.attached_ocr_text: self.clear_attached_image_preview()
            self.insight_overlay.show_overlay()
            if image_path or ocr_text: self._request_contextual_actions_from_gemini(image_path, ocr_text)
            else:
                self.insight_overlay.remove_last_message_from_display()
                self.insight_overlay.chat_display.setPlaceholderText("No screen content. Ask or 'Capture Region'.")
                self.insight_overlay.update_suggested_actions([])

    def _request_contextual_actions_from_gemini(self, image_path: Optional[str], ocr_text: Optional[str]):
        model_to_use = self.gemini_vision_model if image_path else self.gemini_model
        if not model_to_use:
             self.insight_overlay.update_suggested_actions([]); self.insight_overlay.receive_gemini_response("Error: Context model not ready."); return
        prompt_parts = []; available_actions_desc = ("Actions: 'email', 'url', 'copy_text', 'search_web_for_text', 'summarize_text'.")
        prompt_text = ( "Analyze screen context (image/OCR). Suggest 3-4 relevant actions.\n" f"{available_actions_desc}\n" "JSON ONLY: {\"detected_actions\": [{\"label\": ..., \"type\": ..., \"value\": ...}], \"summary\": \"Optional brief summary.\"}\n" "If no actions, {\"detected_actions\": []}.\n" )
        if ocr_text: prompt_text += f"OCR (max 1500 chars):\n\"\"\"\n{ocr_text[:1500]}\n\"\"\"\n"
        if image_path: prompt_text += "Image provided.\n"
        prompt_parts.append({'text': prompt_text})
        if image_path:
            try:
                _, ext = os.path.splitext(image_path); mime = f"image/{ext[1:].lower().replace('jpg','jpeg')}"
                with open(image_path, "rb") as f: img_bytes = f.read()
                prompt_parts.append({"inline_data": {"mime_type": mime, "data": img_bytes}})
            except Exception as e:
                print(f"Error image for context analysis: {e}")
                if not ocr_text: self.insight_overlay.update_suggested_actions([]); self.insight_overlay.receive_gemini_response("Error: Could not prep context."); return
        if not ocr_text and not image_path: self.insight_overlay.update_suggested_actions([]); self.insight_overlay.receive_gemini_response("No content to analyze."); return
        self.process_gemini_query(parts=prompt_parts, source="insight_overlay_context_analysis", model=model_to_use, is_context_analysis=True, generation_config=genai_types.GenerationConfig(temperature=0.2))

    @Slot(str)
    def handle_insight_overlay_query(self, query_text):
        active_model = self.gemini_model
        if not active_model: self.insight_overlay.receive_gemini_response("Error: Gemini model not ready."); return
        self.insight_overlay.add_message_to_display("Gemini", "<i>Thinking...</i>")
        gemini_parts = []; final_text_for_gemini = query_text
        ocr_context = self.insight_overlay.context_ocr_text; img_context_path = self.insight_overlay.context_image_path
        if img_context_path or ocr_context:
            prompt_prefix = "Screen context:"
            if img_context_path and ocr_context: prompt_prefix += f" (image provided, OCR: \"{ocr_context[:300]}...\")"
            elif img_context_path: prompt_prefix += " (image provided)"
            elif ocr_context: prompt_prefix += f" (OCR: \"{ocr_context[:300]}...\")"
            final_text_for_gemini = f"{prompt_prefix}\nUser query: {query_text}"
        if final_text_for_gemini: gemini_parts.append({'text': final_text_for_gemini})
        if img_context_path:
            active_model = self.gemini_vision_model
            if not active_model: self.insight_overlay.receive_gemini_response("Error: Vision model not ready."); return
            try:
                _,ext=os.path.splitext(img_context_path); mime=f"image/{ext[1:].lower().replace('jpg','jpeg')}"
                with open(img_context_path,"rb") as f: gemini_parts.append({"inline_data":{"mime_type":mime,"data":f.read()}})
            except Exception as e: self.insight_overlay.receive_gemini_response(f"Error prep image: {e}"); return
        if not gemini_parts: self.insight_overlay.receive_gemini_response("Error: No content."); return
        self.process_gemini_query(gemini_parts, "insight_overlay_chat", active_model, img_context_path, generation_config=None)

    @Slot()
    def handle_insight_overlay_close_request(self):
        if self.insight_overlay.isVisible(): self.insight_overlay.hide()
        if self.active_gemini_runnable and (self.active_gemini_runnable.source.startswith("insight_overlay")):
            self.active_gemini_runnable.cancel(); self.active_gemini_runnable = None
        if self.current_iteration_data and (self.current_iteration_data['source'].startswith("insight_overlay")):
            self.current_iteration_data = None

    @Slot(str, object)
    def handle_context_action(self, action_type: str, action_value):
        self._add_message_to_current_session("system", f"Context Action: '{action_type}' for '{str(action_value)[:50]}...'")
        self.insight_overlay.add_message_to_display("System", f"Action: {action_type}...")
        QApplication.processEvents()
        if action_type == "email":
            try: webbrowser.open(f"mailto:{action_value}")
            except Exception as e: self._add_message_to_current_session("system_error", f"Mailto fail: {e}")
        elif action_type == "url":
            try:
                url = str(action_value);
                if not (url.startswith("http://") or url.startswith("https://")): url = f"https://{url}"
                webbrowser.open(url)
            except Exception as e: self._add_message_to_current_session("system_error", f"URL open fail: {e}")
        elif action_type == "copy_text":
            try:
                QApplication.clipboard().setText(str(action_value))
                self.statusBar().showMessage(f"Copied: '{str(action_value)[:30]}...'", 3000)
                self.insight_overlay.add_message_to_display("System", "Text copied.")
            except Exception as e: self._add_message_to_current_session("system_error", f"Clipboard fail: {e}")
        elif action_type == "search_web_for_text":
            try:
                query = str(action_value); search_url = f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}"
                webbrowser.open(search_url)
                self.insight_overlay.add_message_to_display("System", f"Searching: {query}")
            except Exception as e: self._add_message_to_current_session("system_error", f"Web search fail: {e}")
        elif action_type == "summarize_text":
            self.insight_overlay.add_message_to_display("Gemini (Summary)", str(action_value))
        else:
            self._add_message_to_current_session("system_error", f"Unknown context action: '{action_type}'.")
            self.insight_overlay.add_message_to_display("System", f"Unknown action: {action_type}")

    def _start_gemini_request(self):
        if not self.current_iteration_data: print("Error: _start_gemini_request no iter_data."); return False
        iter_data = self.current_iteration_data; iter_display_count = iter_data.get('iteration_count', 0) + 1
        if iter_data['source'] == "main_chat":
            thinking_msg_text = f"<i>Gemini (Iter {iter_display_count}): Thinking...</i>"
            self._add_message_to_current_session("system", thinking_msg_text, is_thinking_message=True)
            iter_data['last_thinking_message_text_content'] = thinking_msg_text
        QApplication.processEvents()
        if self.active_gemini_runnable: self.active_gemini_runnable.cancel()
        runnable = GeminiRunnable( iter_data['model_to_use'], iter_data['current_content_parts'], iter_data['source'], iter_data['iteration_count'], generation_config=iter_data.get('generation_config'), is_context_analysis_request=iter_data.get('is_context_analysis_request', False) )
        runnable.signals.finished.connect(self.handle_gemini_finished)
        runnable.signals.error.connect(self.handle_gemini_error)
        self.active_gemini_runnable = runnable; self.thread_pool.start(runnable)
        return True

    def process_gemini_query(self, parts, source, model, img_path=None, is_cont=False, is_context_analysis=False, generation_config=None):
        if not is_cont:
            if self.active_gemini_runnable and (self.active_gemini_runnable.source == source or source in ["main_chat", "insight_overlay_context_analysis"]):
                self.active_gemini_runnable.cancel(); self.active_gemini_runnable = None
            if not model:
                err_msg = f"Error: Model not available for {source}."
                if source.startswith("insight_overlay"): self.insight_overlay.receive_gemini_response(err_msg)
                else: self._add_message_to_current_session("system_error", err_msg)
                self.enable_input_areas(source); return False
            initial_txt = next((p['text'] for p in parts if 'text' in p), "[No text prompt]")
            max_iter = 3 if source == "main_chat" and not is_context_analysis else 1
            self.current_iteration_data = { 'source': source, 'iteration_count': 0, 'max_iterations': max_iter, 'model_to_use': model, 'original_image_path': img_path, 'initial_user_prompt_text': initial_txt, 'last_thinking_message_text_content': None, 'original_query_content': list(parts), 'current_content_parts': list(parts), 'is_context_analysis_request': is_context_analysis, 'generation_config': generation_config }
        else:
            if not self.current_iteration_data or self.current_iteration_data['source'] != source:
                err_msg = f"Error: Mismatched continuation for {source}."
                if source.startswith("insight_overlay"): self.insight_overlay.receive_gemini_response(err_msg)
                else: self._add_message_to_current_session("system_error", err_msg)
                self.enable_input_areas(source); return False
            self.current_iteration_data['current_content_parts'] = list(parts)
            self.current_iteration_data['model_to_use'] = model if model else self.current_iteration_data.get('model_to_use', self.gemini_model)
            self.current_iteration_data['is_context_analysis_request'] = is_context_analysis
            self.current_iteration_data['generation_config'] = generation_config
        if source == "main_chat" and not is_cont:
            self.input_field.setEnabled(False); self.attach_image_button.setEnabled(False); self.screenshot_button.setEnabled(False)
        return self._start_gemini_request()

    @Slot(object, str, list, str, int, str, str)
    def handle_gemini_finished(self, resp_obj, _, query_parts_worker, src_worker, iter_worker, model_name_worker, actions_json_str=""):
        iter_data = self.current_iteration_data
        if not iter_data or iter_data['source'] != src_worker or iter_data['iteration_count'] != iter_worker:
            print(f"Info: Stale Gemini response {src_worker} (iter {iter_worker}). Current: {iter_data.get('iteration_count','N/A')}. Ignoring.");
            if self.active_gemini_runnable and self.active_gemini_runnable.source == src_worker : self.active_gemini_runnable = None
            return
        if self.active_gemini_runnable and self.active_gemini_runnable.source == src_worker and self.active_gemini_runnable.iteration_count == iter_worker:
            if self.active_gemini_runnable.is_cancelled:
                 print(f"Info: Response for CANCELLED task {src_worker} iter {iter_worker}. Ignoring.")
                 self.active_gemini_runnable = None
                 if src_worker == "main_chat": self.enable_input_areas(src_worker)
                 return
            self.active_gemini_runnable = None
        model_response_content = resp_obj.candidates[0].content if resp_obj.candidates and resp_obj.candidates[0].content else None
        if iter_data.get('is_context_analysis_request') and src_worker == "insight_overlay_context_analysis":
            self.insight_overlay.remove_last_message_from_display()
            parsed_actions = []; summary_text_from_ai = None
            if actions_json_str:
                try:
                    payload = json.loads(actions_json_str)
                    parsed_actions = payload.get("detected_actions", []); summary_text_from_ai = payload.get("summary")
                    if not isinstance(parsed_actions, list): parsed_actions = []
                except json.JSONDecodeError:
                    print(f"JSONDecodeError AI actions: {actions_json_str}")
                    summary_text_from_ai = resp_obj.text if resp_obj.text and resp_obj.text != actions_json_str else "Error parsing AI suggestions."
            self.insight_overlay.update_suggested_actions(parsed_actions)
            final_insight_message = summary_text_from_ai or "Context analyzed."
            if not parsed_actions and not summary_text_from_ai:
                final_insight_message = resp_obj.text if resp_obj.text and resp_obj.text != actions_json_str else "No actions/summary. Ask or capture new region."
            self.insight_overlay.receive_gemini_response(final_insight_message)
            self.current_iteration_data = None; return
        if src_worker == "insight_overlay_chat":
            self.insight_overlay.remove_last_message_from_display()
            self.insight_overlay.receive_gemini_response(resp_obj.text if resp_obj.text else "Sorry, I couldn't process that.")
            if not resp_obj.text and resp_obj.candidates: print(f"Gemini API (Insight Chat) details: {resp_obj.candidates}")
            self.current_iteration_data = None; return
        if iter_data['source'] == "main_chat":
            if iter_data.get('last_thinking_message_text_content'): self.remove_last_chat_message(iter_data['last_thinking_message_text_content'])
            iter_data['last_thinking_message_text_content'] = None
            final_text_from_gemini = resp_obj.text if resp_obj.text else ""
            grounding_metadata = resp_obj.candidates[0].grounding_metadata if resp_obj.candidates and resp_obj.candidates[0].grounding_metadata else None
            if grounding_metadata and grounding_metadata.web_search_queries:
                self._add_message_to_current_session("system", f"<i>Gemini used Google Search (Queries: {', '.join(grounding_metadata.web_search_queries)}). Sources below.</i>")
                self._display_grounding_sources(grounding_metadata)
            else: grounding_metadata = None
            function_call_present_in_response = False; function_calls_to_execute = []
            if model_response_content and model_response_content.parts:
                for part in model_response_content.parts:
                    if part.function_call and part.function_call.name:
                        function_call_present_in_response = True; function_calls_to_execute.append(part.function_call)
            if final_text_from_gemini or not function_call_present_in_response:
                 self._add_message_to_current_session("gemini", final_text_from_gemini if final_text_from_gemini else "[No text content]", grounding_metadata=grounding_metadata)
            if function_calls_to_execute and iter_data['iteration_count'] < iter_data['max_iterations']:
                all_function_response_parts = []
                self._add_message_to_current_session("system", f"<i>Gemini suggests function call(s). Processing...</i>")
                for fc_obj in function_calls_to_execute:
                    fc_name = fc_obj.name; fc_args = dict(fc_obj.args)
                    self._add_message_to_current_session("system", f"<i>Plugin Call: {fc_name}({fc_args})</i>")
                    plugin_fn = self.plugin_manager.get_plugin_function(fc_name)
                    if plugin_fn:
                        try:
                            plugin_res = plugin_fn(**fc_args)
                            self._add_message_to_current_session("plugin_result", f"Plugin '{fc_name}' Result:\n{str(plugin_res)[:1000]}")
                            all_function_response_parts.append(genai_types.Part.from_function_response(name=fc_name, response={"result": plugin_res}))
                        except Exception as ex:
                            self._add_message_to_current_session("system_error", f"Error plugin '{fc_name}': {ex}")
                            all_function_response_parts.append(genai_types.Part.from_function_response(name=fc_name, response={"error": str(ex)}))
                    else:
                        self._add_message_to_current_session("system_error", f"Plugin func '{fc_name}' not found locally.")
                        all_function_response_parts.append(genai_types.Part.from_function_response(name=fc_name, response={"error": f"Function {fc_name} not implemented."}))
                iter_data['iteration_count'] += 1
                next_parts_for_gemini = list(iter_data['current_content_parts']);
                if model_response_content: next_parts_for_gemini.append(model_response_content)
                next_parts_for_gemini.extend(all_function_response_parts)
                current_tools = self.plugin_manager.get_all_tool_declarations()
                next_gen_config = genai_types.GenerationConfig(tools=current_tools if current_tools else None)
                self.process_gemini_query(next_parts_for_gemini, src_worker, iter_data['model_to_use'], iter_data['original_image_path'], is_cont=True, generation_config=next_gen_config)
                return
            if not function_calls_to_execute and iter_data['model_to_use'] != self.gemini_vision_model:
                iter_data['iteration_count'] += 1
                plugin_match_regex = re.search(r"\[PLUGIN_CALL:\s*(\w+)(.*?)\]", final_text_from_gemini)
                if plugin_match_regex and iter_data['iteration_count'] < iter_data['max_iterations']:
                    name, p_str = plugin_match_regex.groups(); name=name.strip(); p_str=p_str.strip()
                    self._add_message_to_current_session("system", f"<i>Gemini (regex): Using plugin '{name}'...</i>")
                    params = self._parse_plugin_params(p_str); fn = self.plugin_manager.get_plugin_function_by_invoke_command(name)
                    next_p_text = ""
                    if fn:
                        try:
                            res = fn(**params); self._add_message_to_current_session("plugin_result", f"Plugin '{name}' Result:\n{res}")
                            next_p_text = f"Original: '{iter_data['initial_user_prompt_text']}'. Plugin '{name}'({params}) -> {res}. Final answer."
                        except Exception as e: self._add_message_to_current_session("system_error", f"Plugin Error (regex): {e}"); next_p_text = f"Plugin '{name}' fail: {e}. Skip."
                    else: self._add_message_to_current_session("system_error", f"Plugin '{name}' (regex) not found."); next_p_text = f"Plugin '{name}' not found. Skip."
                    self.process_gemini_query([{'text': next_p_text}], iter_data['source'], self.gemini_model, is_cont=True, generation_config=None)
                    return
            if plugin_match_regex and not (iter_data['iteration_count'] < iter_data['max_iterations']):
                 self._add_message_to_current_session("system", "<i>Max plugin iterations (regex).</i>")
            if function_call_present_in_response and not final_text_from_gemini and not (function_calls_to_execute and iter_data['iteration_count'] < iter_data['max_iterations']):
                 self._add_message_to_current_session("gemini", "[Function call processed, no further text.]")
            elif not final_text_from_gemini and not grounding_metadata and not function_call_present_in_response and not plugin_match_regex:
                 self._add_message_to_current_session("gemini", "[No specific output.]")
            self.enable_input_areas(iter_data['source']); self.current_iteration_data = None

    @Slot(str, list, str, int, str)
    def handle_gemini_error(self, err_msg, query_parts_worker, src_worker, iter_worker, model_name_worker):
        iter_data = self.current_iteration_data
        if not iter_data or iter_data['source'] != src_worker or iter_data['iteration_count'] != iter_worker: print(f"Info: Stale Gemini ERROR {src_worker}. Ignoring."); return
        if self.active_gemini_runnable and self.active_gemini_runnable.source == src_worker and self.active_gemini_runnable.iteration_count == iter_worker:
            if self.active_gemini_runnable.is_cancelled: print(f"Info: Error for CANCELLED task {src_worker} iter {iter_worker}. Err: {err_msg}. Ignoring."); self.active_gemini_runnable = None; return
            self.active_gemini_runnable = None
        if iter_data.get('is_context_analysis_request') and src_worker == "insight_overlay_context_analysis":
            self.insight_overlay.remove_last_message_from_display(); self.insight_overlay.receive_gemini_response(f"Error analyzing context: {err_msg}")
        elif src_worker == "insight_overlay_chat":
            self.insight_overlay.remove_last_message_from_display(); self.insight_overlay.receive_gemini_response(f"Error: {err_msg}")
        elif iter_data.get('last_thinking_message_text_content') and src_worker == "main_chat":
            self.remove_last_chat_message(iter_data['last_thinking_message_text_content'])
        if iter_data : iter_data['last_thinking_message_text_content'] = None
        if src_worker == "main_chat": self._add_message_to_current_session("system_error", f"Gemini API Error (Iter {iter_data.get('iteration_count',0) + 1}): {err_msg}")
        self.enable_input_areas(src_worker if iter_data else None);
        if iter_data: self.current_iteration_data = None

    def _format_text_with_citations(self, text: str, grounding_metadata: GroundingMetadata) -> str:
        if not text or not grounding_metadata or not hasattr(grounding_metadata, 'grounding_supports') or not grounding_metadata.grounding_supports: return text
        modified_text = list(text); insertions = []
        for support in grounding_metadata.grounding_supports:
            if hasattr(support, 'segment') and support.segment:
                end_index = support.segment.end_index; citation_links = []
                if hasattr(support, 'grounding_chunk_indices') and support.grounding_chunk_indices:
                    for i in support.grounding_chunk_indices:
                        if hasattr(grounding_metadata, 'grounding_chunks') and i < len(grounding_metadata.grounding_chunks): citation_links.append(f"[{i+1}]")
                if citation_links: insertions.append((end_index, f" {''.join(citation_links)}"))
        insertions.sort(key=lambda x: x[0], reverse=True)
        for index, citation_str in insertions: modified_text.insert(min(index, len(modified_text)), citation_str)
        return "".join(modified_text)

    def _display_grounding_sources(self, grounding_metadata: GroundingMetadata):
        self.context_panel.clear()
        if hasattr(grounding_metadata, 'grounding_chunks') and grounding_metadata.grounding_chunks:
            self.context_panel.append("<b>Sources from Google Search:</b><br>")
            for i, chunk in enumerate(grounding_metadata.grounding_chunks):
                if hasattr(chunk, 'web') and chunk.web:
                    title = chunk.web.title or "Source"; uri = chunk.web.uri or "#"
                    self.context_panel.append(f"{i+1}. <a href='{uri}'>{title}</a><br><small style='color:gray;'>{uri}</small><br>")
        else: self.context_panel.append("No specific search sources provided.")

    def _parse_plugin_params(self, params_str: str) -> dict:
        params = {};
        if params_str and params_str.startswith(','): params_str = params_str[1:].strip()
        for match in re.finditer(r"(\w+):\s*(\"(.*?)\"|([\w.-]+))", params_str):
            key, _, quoted_val, unquoted_val = match.groups(); val_str = quoted_val if quoted_val is not None else unquoted_val
            if val_str.isdigit(): params[key] = int(val_str)
            elif val_str.lower() == "true": params[key] = True
            elif val_str.lower() == "false": params[key] = False
            else:
                try: params[key] = float(val_str)
                except ValueError: params[key] = val_str
        return params

    def enable_input_areas(self, source=None):
        if source == "main_chat" or source is None:
            self.input_field.setEnabled(True); self.attach_image_button.setEnabled(True)
            if hasattr(self, 'screenshot_button'): self.screenshot_button.setEnabled(True)
            self.input_field.setFocus()

    def remove_last_chat_message(self, expected_msg_text_content):
        if not expected_msg_text_content: return
        cursor = self.chat_area.textCursor(); cursor.movePosition(QTextCursor.End)
        cursor.select(QTextCursor.BlockUnderCursor); last_line_html = cursor.selection().toHtml()
        temp_doc = QTextDocument(); temp_doc.setHtml(last_line_html)
        last_line_plain = temp_doc.toPlainText().strip()
        expected_plain = expected_msg_text_content.replace("<i>","").replace("</i>","").strip()
        if expected_plain in last_line_plain :
            cursor.removeSelectedText(); cursor.movePosition(QTextCursor.End)
            if self.chat_area.toPlainText().strip().endswith("\n\n"): cursor.deletePreviousChar()
            print(f"Removed last message matching: '{expected_plain}'")
        else: print(f"Did not remove last message. Expected: '{expected_plain}', Found: '{last_line_plain}'")

    @Slot(str, object)
    def on_plugin_loaded(self, name, _): self._add_message_to_current_session("system", f"<i>Plugin '{name}' loaded.</i>")
    @Slot(str, str)
    def on_plugin_error(self, name, err): self._add_message_to_current_session("system_error", f"Error loading plugin '{name}': {err}")

    def init_hotkey_listener(self):
        try: from pynput import keyboard
        except ImportError as e: print(f"WARNING: pynput.keyboard import failed: {e}. Hotkeys disabled."); return
        self.current_keys = set()
        self.HOTKEY_TOGGLE_OVERLAY = {keyboard.Key.ctrl_l, keyboard.Key.shift, keyboard.KeyCode.from_char('g')}
        self.HOTKEY_SCREEN_CAPTURE = {keyboard.Key.ctrl_l, keyboard.Key.shift, keyboard.KeyCode.from_char('c')}
        self.hotkey_overlay_triggered = False; self.hotkey_capture_triggered = False
        def on_press(key):
            self.current_keys.add(key)
            if all(k in self.current_keys for k in self.HOTKEY_TOGGLE_OVERLAY) and not self.hotkey_overlay_triggered:
                self.hotkey_signal.toggle_overlay.emit(); self.hotkey_overlay_triggered = True
            elif all(k in self.current_keys for k in self.HOTKEY_SCREEN_CAPTURE) and not self.hotkey_capture_triggered:
                self.hotkey_signal.trigger_screen_capture.emit(); self.hotkey_capture_triggered = True
        def on_release(key):
            if key in self.HOTKEY_TOGGLE_OVERLAY: self.hotkey_overlay_triggered = False
            if key in self.HOTKEY_SCREEN_CAPTURE: self.hotkey_capture_triggered = False
            try: self.current_keys.remove(key)
            except KeyError: pass
        listener = keyboard.Listener(on_press=on_press, on_release=on_release); listener.start()

    def initiate_region_selection_for_overlay(self):
        if self.insight_overlay.isVisible(): self.insight_overlay.hide()
        self.region_selector_widget = RegionSelectorWidget()
        self.region_selector_widget.region_selected.connect(self.handle_region_selection_for_overlay)
        self.region_selector_widget.selection_cancelled.connect(self.handle_region_selection_cancelled_for_overlay)
        self.region_selector_widget.showFullScreen(); self.region_selector_widget.activateWindow()

    @Slot(QRect)
    def handle_region_selection_for_overlay(self, region_qrect):
        if self.region_selector_widget: self.region_selector_widget.close(); self.region_selector_widget = None
        if not region_qrect.isNull() and region_qrect.isValid():
            self._process_captured_region_for_overlay(region_qrect)
        else:
            if not self.insight_overlay.isVisible(): self.insight_overlay.show_overlay()
            self.insight_overlay.activateWindow()

    def _process_captured_region_for_overlay(self, region_qrect: QRect):
        image_path, ocr_text = self.capture_screen_and_attach(for_main_window_attachment=False, region=region_qrect)
        self.insight_overlay.set_initial_context(image_path, ocr_text)
        if image_path or ocr_text: self._request_contextual_actions_from_gemini(image_path, ocr_text)
        else:
            self.insight_overlay.remove_last_message_from_display()
            self.insight_overlay.chat_display.setPlaceholderText("No content from region. Ask or try again.")
            self.insight_overlay.update_suggested_actions([])
        if not self.insight_overlay.isVisible(): self.insight_overlay.show_overlay()
        self.insight_overlay.activateWindow()

    @Slot()
    def handle_region_selection_cancelled_for_overlay(self):
        if self.region_selector_widget: self.region_selector_widget.close(); self.region_selector_widget = None
        if not self.insight_overlay.isVisible(): self.insight_overlay.show_overlay()
        self.insight_overlay.activateWindow()

    def closeEvent(self, event):
        if hasattr(self, 'tray_icon') and self.tray_icon.isVisible():
            event.ignore(); self.hide(); self.is_hidden_to_tray = True
            self.tray_icon.showMessage( "Agent Minimized", "Gemini Agent is running in the system tray.", QSystemTrayIcon.Information, 2000 )
        else:
            print("closeEvent: Defaulting to quit (tray not visible/setup).")
            self.actual_quit(); super().closeEvent(event)

if __name__ == "__main__":
    QApplication.setApplicationName("Gemini Desktop Agent")
    QApplication.setApplicationVersion("0.6.0-glaze")
    app = QApplication(sys.argv)
    app.setStyleSheet(get_base_stylesheet())
    app.setQuitOnLastWindowClosed(False)
    window = MainApp()
    if "--started-from-autorun" not in sys.argv: window.show()
    else:
        print("Started via autorun. Main window hidden.")
        if hasattr(window, 'tray_icon') and window.tray_icon.isVisible():
             window.tray_icon.showMessage("Agent Started", "Gemini Agent has started in the background.", QSystemTrayIcon.Information, 1500)
    sys.exit(app.exec())