main.py

"""
PyDisplayWindow Pro - Ultra High Quality Display Capture Stream Application

A professional screen capture application with ultra-high quality rendering,
smooth 60-144 FPS streaming, hardware acceleration support, and advanced
features for streaming platforms like Discord, TikTok, OBS, etc.

Author: PyDisplayWindow Team
Version: 2.0.0 Pro
"""

import sys
import json
import os
import signal
import logging
import time
import threading
import queue
from pathlib import Path
from typing import Optional, List, Dict, Tuple, Callable, Union
from dataclasses import dataclass, asdict, field
from enum import Enum, auto
from collections import deque
import ctypes
from ctypes import wintypes

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger('PyDisplayWindowPro')

import numpy as np
from PIL import Image, ImageFilter, ImageEnhance
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QPushButton, QComboBox, QDialog, QDialogButtonBox,
    QGroupBox, QSpinBox, QCheckBox, QSlider, QStatusBar, QMenuBar,
    QMenu, QFileDialog, QMessageBox, QFrame, QSizePolicy, QGridLayout,
    QProgressBar, QTabWidget, QRadioButton, QButtonGroup
)
from PyQt6.QtCore import (
    Qt, QTimer, pyqtSignal, QObject, QThread, QSize, QSettings,
    QMutex, QWaitCondition, QRect
)
from PyQt6.QtGui import (
    QImage, QPixmap, QIcon, QKeySequence, QAction, QFont,
    QCloseEvent, QResizeEvent, QPaintEvent, QPainter, QPen, QColor,
    QSurfaceFormat, QOpenGLContext
)

from ctypes import wintypes

# Optional high-performance libraries
PIL_AVAILABLE = False

try:
    from PIL import ImageGrab, Image
    PIL_AVAILABLE = True
except ImportError:
    pass

try:
    import cv2
    CV2_AVAILABLE = True
except ImportError:
    CV2_AVAILABLE = False
    logger.warning("OpenCV not available. Advanced processing disabled.")

try:
    import dxcam
    DXCAM_AVAILABLE = True
    logger.info("dxcam (DXGI) available — ultra-fast hardware capture enabled")
except Exception:
    DXCAM_AVAILABLE = False
    logger.warning("dxcam not available. Falling back to mss/PIL.")

try:
    import mss
    MSS_AVAILABLE = True
    logger.info("mss available as fallback capture backend")
except ImportError:
    MSS_AVAILABLE = False


# =============================================================================
# Configuration & Data Classes
# =============================================================================

class CaptureMode(Enum):
    FULL_SCREEN = "full_screen"
    CUSTOM_REGION = "custom_region"


class QualityPreset(Enum):
    PERFORMANCE = auto()
    BALANCED = auto()
    HIGH_QUALITY = auto()
    ULTRA = auto()
    MAXIMUM = auto()


@dataclass
class DisplayInfo:
    """Information about a connected display/monitor."""
    index: int
    name: str
    width: int
    height: int
    x: int
    y: int
    is_primary: bool
    refresh_rate: int = 60
    
    def __str__(self) -> str:
        primary_tag = " [Primary]" if self.is_primary else ""
        return f"{self.name}{primary_tag} ({self.width}x{self.height} @ {self.refresh_rate}Hz)"


@dataclass
class CaptureSettings:
    """Advanced capture settings for professional quality."""
    # Frame Rate
    target_fps: int = 60
    vsync_enabled: bool = True
    adaptive_sync: bool = True
    
    # Quality
    quality_preset: QualityPreset = QualityPreset.HIGH_QUALITY
    scale_factor: float = 1.0
    use_lanczos_scaling: bool = True
    enable_sharpening: bool = True
    sharpening_amount: float = 1.2
    color_enhancement: bool = True
    
    # Buffering
    buffer_size: int = 3
    enable_triple_buffering: bool = True
    max_frame_latency: int = 2
    
    # Hardware
    use_hardware_acceleration: bool = True
    gpu_decode: bool = False
    prefer_gpu_rendering: bool = True
    
    # Cursor
    capture_cursor: bool = True
    cursor_smoothing: bool = True
    cursor_shadow: bool = True
    cursor_scale: float = 1.0
    
    # Performance
    dynamic_quality_adjust: bool = True
    min_quality_threshold: float = 0.85
    drop_frames_on_lag: bool = True
    
    # Display
    enable_hdr_support: bool = False
    color_space: str = "sRGB"
    bit_depth: int = 8
    
    def to_dict(self) -> Dict:
        data = asdict(self)
        data['quality_preset'] = self.quality_preset.name
        return data
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'CaptureSettings':
        if 'quality_preset' in data:
            data['quality_preset'] = QualityPreset[data['quality_preset']]
        return cls(**data)


@dataclass
class AppSettings:
    """Application settings and preferences."""
    # Core settings
    target_fps: int = 60
    capture_mode: str = "full_screen"
    selected_display: int = 0
    
    # UI settings
    show_fps: bool = True
    always_on_top: bool = False  # DEFAULT: OFF - User can enable if needed
    maintain_aspect_ratio: bool = True
    enable_preview: bool = True
    presentation_mode: bool = True
    
    # Legacy quality (deprecated, use capture_settings)
    quality: int = 95
    scale_factor: float = 1.0
    
    # Advanced capture settings
    capture_settings: CaptureSettings = field(default_factory=CaptureSettings)
    
    # Logging
    enable_logging: bool = True
    log_level: str = "INFO"
    
    def to_dict(self) -> Dict:
        data = asdict(self)
        data['capture_settings'] = self.capture_settings.to_dict()
        return data
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'AppSettings':
        if 'capture_settings' in data:
            data['capture_settings'] = CaptureSettings.from_dict(data['capture_settings'])
        else:
            # Create default settings
            data['capture_settings'] = CaptureSettings()
        return cls(**data)


# =============================================================================
# High-Performance Frame Buffer
# =============================================================================

class FrameBuffer:
    """Triple-buffered frame storage for smooth playback."""
    
    def __init__(self, size: int = 3):
        self.size = max(2, min(size, 5))
        self._buffers: deque = deque(maxlen=self.size)
        self._mutex = threading.Lock()  # Use threading.Lock instead of QMutex
        self._write_index = 0
        self._read_index = 0
        self._frame_count = 0
        
    def write(self, frame: np.ndarray, timestamp: float) -> bool:
        """Write frame to buffer. Returns True if successful."""
        with self._mutex:
            if len(self._buffers) >= self.size:
                # Drop oldest frame
                self._buffers.popleft()
            
            # Store frame with metadata
            frame_data = {
                'frame': frame,
                'timestamp': timestamp,
                'index': self._frame_count
            }
            self._buffers.append(frame_data)
            self._frame_count += 1
            return True
    
    def read(self) -> Optional[Tuple[np.ndarray, float]]:
        """Read latest frame from buffer."""
        with self._mutex:
            if not self._buffers:
                return None
            
            # Return the most recent frame
            latest = self._buffers[-1]
            return latest['frame'], latest['timestamp']
    
    def get_latency(self) -> float:
        """Get current buffer latency in frames."""
        with self._mutex:
            return len(self._buffers)
    
    def clear(self):
        """Clear all buffered frames."""
        with self._mutex:
            self._buffers.clear()
            self._frame_count = 0


# =============================================================================
# Hardware Acceleration Detector
# =============================================================================

class HardwareAcceleration:
    """Detect and manage hardware acceleration capabilities."""
    
    @staticmethod
    def check_d3d11_support() -> bool:
        """Check for Direct3D 11 support on Windows."""
        try:
            # Load D3D11 library
            d3d11 = ctypes.windll.d3d11
            return True
        except Exception:
            return False
    
    @staticmethod
    def check_opengl_support() -> bool:
        """Check for OpenGL support."""
        try:
            from PyQt6.QtOpenGL import QOpenGLVersionProfile
            return True
        except ImportError:
            return False
    
    @staticmethod
    def get_optimal_settings() -> Dict:
        """Get optimal hardware acceleration settings."""
        return {
            'd3d11_available': HardwareAcceleration.check_d3d11_support(),
            'opengl_available': HardwareAcceleration.check_opengl_support(),
            'recommended_buffer': 3,
            'use_gpu_scaling': True,
            'prefer_native_capture': True
        }


# =============================================================================
# Display Detection (Enhanced)
# =============================================================================

class DisplayManager:
    """Manages display/monitor detection with refresh rate info."""
    
    @staticmethod
    def get_refresh_rate(device_name: Optional[str] = None) -> int:
        """Get the refresh rate of a display using Windows API."""
        try:
            user32 = ctypes.windll.user32

            class DEVMODEW(ctypes.Structure):
                _fields_ = [
                    ("dmDeviceName", wintypes.WCHAR * 32),
                    ("dmSpecVersion", wintypes.WORD),
                    ("dmDriverVersion", wintypes.WORD),
                    ("dmSize", wintypes.WORD),
                    ("dmDriverExtra", wintypes.WORD),
                    ("dmFields", wintypes.DWORD),
                    ("dmPositionX", wintypes.LONG),
                    ("dmPositionY", wintypes.LONG),
                    ("dmDisplayOrientation", wintypes.DWORD),
                    ("dmDisplayFixedOutput", wintypes.DWORD),
                    ("dmColor", wintypes.SHORT),
                    ("dmDuplex", wintypes.SHORT),
                    ("dmYResolution", wintypes.SHORT),
                    ("dmTTOption", wintypes.SHORT),
                    ("dmCollate", wintypes.SHORT),
                    ("dmFormName", wintypes.WCHAR * 32),
                    ("dmLogPixels", wintypes.WORD),
                    ("dmBitsPerPel", wintypes.DWORD),
                    ("dmPelsWidth", wintypes.DWORD),
                    ("dmPelsHeight", wintypes.DWORD),
                    ("dmDisplayFlags", wintypes.DWORD),
                    ("dmDisplayFrequency", wintypes.DWORD),
                    ("dmICMMethod", wintypes.DWORD),
                    ("dmICMIntent", wintypes.DWORD),
                    ("dmMediaType", wintypes.DWORD),
                    ("dmDitherType", wintypes.DWORD),
                    ("dmReserved1", wintypes.DWORD),
                    ("dmReserved2", wintypes.DWORD),
                    ("dmPanningWidth", wintypes.DWORD),
                    ("dmPanningHeight", wintypes.DWORD),
                ]

            ENUM_CURRENT_SETTINGS = -1
            dm = DEVMODEW()
            dm.dmSize = ctypes.sizeof(DEVMODEW)
            dev = device_name if device_name else None
            if user32.EnumDisplaySettingsW(dev, ENUM_CURRENT_SETTINGS, ctypes.byref(dm)):
                hz = int(dm.dmDisplayFrequency)
                if hz > 0:
                    return hz
        except Exception as e:
            logger.debug(f"Could not get refresh rate: {e}")

        return 60
    
    @staticmethod
    def get_available_displays() -> List[DisplayInfo]:
        """Get list of all available displays using Windows API."""
        displays = []
        
        try:
            user32 = ctypes.windll.user32

            class RECT(ctypes.Structure):
                _fields_ = [("left", wintypes.LONG), ("top", wintypes.LONG), ("right", wintypes.LONG), ("bottom", wintypes.LONG)]

            class MONITORINFOEXW(ctypes.Structure):
                _fields_ = [
                    ("cbSize", wintypes.DWORD),
                    ("rcMonitor", RECT),
                    ("rcWork", RECT),
                    ("dwFlags", wintypes.DWORD),
                    ("szDevice", wintypes.WCHAR * 32),
                ]

            MONITORINFOF_PRIMARY = 0x00000001

            class DEVMODEW(ctypes.Structure):
                _fields_ = [
                    ("dmDeviceName", wintypes.WCHAR * 32),
                    ("dmSpecVersion", wintypes.WORD),
                    ("dmDriverVersion", wintypes.WORD),
                    ("dmSize", wintypes.WORD),
                    ("dmDriverExtra", wintypes.WORD),
                    ("dmFields", wintypes.DWORD),
                    ("dmPositionX", wintypes.LONG),
                    ("dmPositionY", wintypes.LONG),
                    ("dmDisplayOrientation", wintypes.DWORD),
                    ("dmDisplayFixedOutput", wintypes.DWORD),
                    ("dmColor", wintypes.SHORT),
                    ("dmDuplex", wintypes.SHORT),
                    ("dmYResolution", wintypes.SHORT),
                    ("dmTTOption", wintypes.SHORT),
                    ("dmCollate", wintypes.SHORT),
                    ("dmFormName", wintypes.WCHAR * 32),
                    ("dmLogPixels", wintypes.WORD),
                    ("dmBitsPerPel", wintypes.DWORD),
                    ("dmPelsWidth", wintypes.DWORD),
                    ("dmPelsHeight", wintypes.DWORD),
                    ("dmDisplayFlags", wintypes.DWORD),
                    ("dmDisplayFrequency", wintypes.DWORD),
                    ("dmICMMethod", wintypes.DWORD),
                    ("dmICMIntent", wintypes.DWORD),
                    ("dmMediaType", wintypes.DWORD),
                    ("dmDitherType", wintypes.DWORD),
                    ("dmReserved1", wintypes.DWORD),
                    ("dmReserved2", wintypes.DWORD),
                    ("dmPanningWidth", wintypes.DWORD),
                    ("dmPanningHeight", wintypes.DWORD),
                ]

            ENUM_CURRENT_SETTINGS = -1

            found: List[Tuple[str, int, int, int, int, bool, int]] = []

            def _get_settings(device: str) -> Optional[DEVMODEW]:
                dm = DEVMODEW()
                dm.dmSize = ctypes.sizeof(DEVMODEW)
                if user32.EnumDisplaySettingsW(device, ENUM_CURRENT_SETTINGS, ctypes.byref(dm)):
                    return dm
                return None

            MONITORENUMPROC = ctypes.WINFUNCTYPE(
                wintypes.BOOL,
                wintypes.HMONITOR,
                wintypes.HDC,
                ctypes.POINTER(RECT),
                wintypes.LPARAM,
            )

            def enum_proc(hmonitor, hdc, lprect, lparam):
                mi = MONITORINFOEXW()
                mi.cbSize = ctypes.sizeof(MONITORINFOEXW)
                if not user32.GetMonitorInfoW(hmonitor, ctypes.byref(mi)):
                    return True

                dev = mi.szDevice
                dm = _get_settings(dev)
                if dm is None:
                    rc = mi.rcMonitor
                    left = int(rc.left)
                    top = int(rc.top)
                    width = int(rc.right - rc.left)
                    height = int(rc.bottom - rc.top)
                    hz = DisplayManager.get_refresh_rate(dev)
                else:
                    left = int(dm.dmPositionX)
                    top = int(dm.dmPositionY)
                    width = int(dm.dmPelsWidth)
                    height = int(dm.dmPelsHeight)
                    hz = int(dm.dmDisplayFrequency) if int(dm.dmDisplayFrequency) > 0 else DisplayManager.get_refresh_rate(dev)

                is_primary = bool(mi.dwFlags & MONITORINFOF_PRIMARY)
                found.append((dev, left, top, width, height, is_primary, hz))
                return True

            user32.EnumDisplayMonitors(None, None, MONITORENUMPROC(enum_proc), 0)

            if not found:
                raise RuntimeError("No monitors detected")

            for i, (dev, left, top, width, height, is_primary, hz) in enumerate(found, start=1):
                displays.append(DisplayInfo(
                    index=i,
                    name=f"{dev} ({width}x{height} @ {hz}Hz)",
                    width=width,
                    height=height,
                    x=left,
                    y=top,
                    is_primary=is_primary,
                    refresh_rate=hz,
                ))

        except Exception as e:
            logger.error(f"Error detecting displays: {e}")
            user32 = ctypes.windll.user32
            width = int(user32.GetSystemMetrics(0))
            height = int(user32.GetSystemMetrics(1))
            hz = DisplayManager.get_refresh_rate(None)
            displays.append(DisplayInfo(
                index=1,
                name=f"Primary ({width}x{height} @ {hz}Hz)",
                width=width,
                height=height,
                x=0,
                y=0,
                is_primary=True,
                refresh_rate=hz,
            ))
        
        return displays
    
    @staticmethod
    def get_primary_display() -> Optional[DisplayInfo]:
        """Get the primary display."""
        displays = DisplayManager.get_available_displays()
        for display in displays:
            if display.is_primary:
                return display
        return displays[0] if displays else None

    @staticmethod
    def get_recommended_fps(display_info: DisplayInfo) -> int:
        """Get recommended FPS based on display refresh rate."""
        if display_info.refresh_rate >= 144:
            return 144
        elif display_info.refresh_rate >= 120:
            return 120
        elif display_info.refresh_rate >= 60:
            return 60
        else:
            return display_info.refresh_rate


# =============================================================================
# Screen Capture Engine
# =============================================================================

class CaptureSignals(QObject):
    """Signals emitted by the capture worker."""
    frame_captured = pyqtSignal(np.ndarray)
    capture_error = pyqtSignal(str)
    fps_updated = pyqtSignal(float)
    performance_warning = pyqtSignal(str)
    quality_adjusted = pyqtSignal(float)
    request_window_opacity = pyqtSignal(float)


class CaptureWorker(QThread):
    """Professional capture worker with advanced features."""
    
    def __init__(self, display_info: DisplayInfo, settings: Union[int, 'CaptureSettings'] = 60, capture_cursor: bool = True):
        super().__init__()
        self.signals = CaptureSignals()
        self.display_info = display_info
        self._lock = threading.Lock()
        
        # Support both old (int) and new (CaptureSettings) interface
        if isinstance(settings, CaptureSettings):
            self.capture_settings = settings
            self.target_fps = settings.target_fps
            self.capture_cursor = settings.capture_cursor
        else:
            # Legacy support: settings is just FPS integer
            self.target_fps = settings
            self.capture_cursor = capture_cursor
            self.capture_settings = CaptureSettings(target_fps=settings, capture_cursor=capture_cursor)
        
        self.is_running = False
        self.frame_time = 1.0 / self.target_fps
        
    def set_cursor_capture(self, enabled: bool):
        """Enable/disable cursor capture."""
        with self._lock:
            self.capture_cursor = enabled
    
    def _draw_cursor(self, img: np.ndarray, monitor: Dict) -> np.ndarray:
        """
        Draw mouse cursor onto a screenshot (numpy RGB array).
        Uses dual-pass GDI technique: render cursor on black AND white
        background, then derive the true cursor pixels and alpha mask.
        This correctly handles monochrome (arrow) and color cursors alike.
        """
        try:
            user32 = ctypes.windll.user32
            gdi32  = ctypes.windll.gdi32

            # --- 1. Query cursor state ---
            class CURSORINFO(ctypes.Structure):
                _fields_ = [
                    ("cbSize",      wintypes.DWORD),
                    ("flags",       wintypes.DWORD),
                    ("hCursor",     wintypes.HCURSOR),
                    ("ptScreenPos", wintypes.POINT),
                ]

            ci = CURSORINFO()
            ci.cbSize = ctypes.sizeof(CURSORINFO)
            if not user32.GetCursorInfo(ctypes.byref(ci)):
                return img
            if not (ci.flags & 0x1):   # CURSOR_SHOWING
                return img

            class ICONINFO(ctypes.Structure):
                _fields_ = [
                    ("fIcon",    wintypes.BOOL),
                    ("xHotspot", wintypes.DWORD),
                    ("yHotspot", wintypes.DWORD),
                    ("hbmMask",  wintypes.HBITMAP),
                    ("hbmColor", wintypes.HBITMAP),
                ]

            ii = ICONINFO()
            if not user32.GetIconInfo(ci.hCursor, ctypes.byref(ii)):
                return img

            hot_x = int(ii.xHotspot)
            hot_y = int(ii.yHotspot)
            pos_x = int(ci.ptScreenPos.x) - int(monitor["left"]) - hot_x
            pos_y = int(ci.ptScreenPos.y) - int(monitor["top"])  - hot_y

            CSIZE = 64   # cursor render size

            # --- 2. BITMAPINFOHEADER for top-down 32-bit DIB ---
            class BITMAPINFOHEADER(ctypes.Structure):
                _fields_ = [
                    ("biSize",          wintypes.DWORD),
                    ("biWidth",         wintypes.LONG),
                    ("biHeight",        wintypes.LONG),
                    ("biPlanes",        wintypes.WORD),
                    ("biBitCount",      wintypes.WORD),
                    ("biCompression",   wintypes.DWORD),
                    ("biSizeImage",     wintypes.DWORD),
                    ("biXPelsPerMeter", wintypes.LONG),
                    ("biYPelsPerMeter", wintypes.LONG),
                    ("biClrUsed",       wintypes.DWORD),
                    ("biClrImportant",  wintypes.DWORD),
                ]

            def _render_on_bg(fill_rop: int) -> Optional[np.ndarray]:
                """Render cursor over a solid background (BLACKNESS or WHITENESS)."""
                hdc_s = user32.GetDC(None)
                hdc_m = gdi32.CreateCompatibleDC(hdc_s)
                bmi   = BITMAPINFOHEADER()
                bmi.biSize     = ctypes.sizeof(BITMAPINFOHEADER)
                bmi.biWidth    = CSIZE
                bmi.biHeight   = -CSIZE   # top-down
                bmi.biPlanes   = 1
                bmi.biBitCount = 32
                bmi.biCompression = 0     # BI_RGB
                bits = ctypes.c_void_p()
                hbm  = gdi32.CreateDIBSection(hdc_m, ctypes.byref(bmi), 0,
                                              ctypes.byref(bits), None, 0)
                if not hbm:
                    gdi32.DeleteDC(hdc_m)
                    user32.ReleaseDC(None, hdc_s)
                    return None
                old = gdi32.SelectObject(hdc_m, hbm)
                gdi32.PatBlt(hdc_m, 0, 0, CSIZE, CSIZE, fill_rop)
                user32.DrawIconEx(hdc_m, 0, 0, ci.hCursor,
                                  CSIZE, CSIZE, 0, None, 0x0003)  # DI_NORMAL
                buf = (ctypes.c_ubyte * (CSIZE * CSIZE * 4)).from_address(bits.value)
                arr = np.frombuffer(buf, dtype=np.uint8).reshape((CSIZE, CSIZE, 4)).copy()
                gdi32.SelectObject(hdc_m, old)
                gdi32.DeleteObject(hbm)
                gdi32.DeleteDC(hdc_m)
                user32.ReleaseDC(None, hdc_s)
                return arr   # BGRA

            BLACKNESS = 0x00000042
            WHITENESS = 0x00FF0062
            on_black = _render_on_bg(BLACKNESS)
            on_white = _render_on_bg(WHITENESS)

            # free GDI resources
            try:
                if ii.hbmMask:  gdi32.DeleteObject(ii.hbmMask)
                if ii.hbmColor: gdi32.DeleteObject(ii.hbmColor)
            except Exception:
                pass

            if on_black is None or on_white is None:
                return img

            # --- 3. Dual-pass: recover cursor colour + alpha ---
            # Over black:  result = cursor_color * alpha
            # Over white:  result = cursor_color * alpha + (1-alpha)*255
            # Therefore:   alpha  = 1 - (on_white - on_black) / 255
            #              color  = on_black / alpha
            b_f = on_black[:, :, :3].astype(np.float32)  # BGR
            w_f = on_white[:, :, :3].astype(np.float32)

            alpha_f    = 1.0 - np.clip((w_f - b_f) / 255.0, 0.0, 1.0)
            alpha_mask = alpha_f.max(axis=2, keepdims=True)              # (H,W,1)

            with np.errstate(divide='ignore', invalid='ignore'):
                color_bgr = np.where(
                    alpha_mask > 0.02,
                    np.clip(b_f / np.maximum(alpha_mask, 0.02), 0, 255),
                    b_f
                )
            # BGR -> RGB
            cursor_rgb = color_bgr[:, :, ::-1].astype(np.uint8)

            # --- 4. Composite onto the screenshot ---
            h, w = img.shape[:2]
            x0 = max(0, pos_x);       y0 = max(0, pos_y)
            x1 = min(w, pos_x+CSIZE); y1 = min(h, pos_y+CSIZE)
            if x0 >= x1 or y0 >= y1:
                return img

            cx0 = x0 - pos_x;  cy0 = y0 - pos_y
            cx1 = cx0+(x1-x0); cy1 = cy0+(y1-y0)

            roi  = img[y0:y1, x0:x1].astype(np.float32)
            cur  = cursor_rgb[cy0:cy1, cx0:cx1].astype(np.float32)
            alp  = alpha_mask[cy0:cy1, cx0:cx1]

            img[y0:y1, x0:x1] = np.clip(
                cur * alp + roi * (1.0 - alp), 0, 255
            ).astype(np.uint8)
            return img

        except Exception as e:
            logger.debug(f"Cursor draw error: {e}")
            return img
    
    def _apply_quality_enhancements(self, img: np.ndarray) -> np.ndarray:
        """
        Lightweight quality pass: only a gentle unsharp mask when sharpening
        is requested. CLAHE is intentionally removed — it distorts text and
        anti-aliased elements, making them look blurry / noisy.
        Maximum quality = zero processing (native pixels are best).
        """
        if not CV2_AVAILABLE:
            return img

        # Maximum / Ultra preset: return native pixels untouched
        if self.capture_settings.quality_preset in (
            QualityPreset.MAXIMUM, QualityPreset.ULTRA
        ):
            return img

        try:
            if self.capture_settings.enable_sharpening:
                # Gentle unsharp mask (much softer than the old 9-kernel)
                blurred = cv2.GaussianBlur(img, (0, 0), sigmaX=1.0)
                img = cv2.addWeighted(img, 1.3, blurred, -0.3, 0)
        except Exception as e:
            logger.debug(f"Enhancement error: {e}")

        return img

    def _lanczos_resize(self, img: np.ndarray, target_size: Tuple[int, int]) -> np.ndarray:
        """High-quality Lanczos resampling."""
        if CV2_AVAILABLE:
            return cv2.resize(img, target_size, interpolation=cv2.INTER_LANCZOS4)
        return img
    
    def set_display(self, display_info: DisplayInfo):
        """Change the display being captured."""
        with self._lock:
            self.display_info = display_info
    
    def set_fps(self, fps: int):
        """Update target FPS."""
        with self._lock:
            self.target_fps = fps
            self.frame_time = 1.0 / fps
    
    def stop(self):
        """Stop the capture loop."""
        self.is_running = False
        self.wait(1000)  # Wait up to 1 second for thread to finish
    
    # ------------------------------------------------------------------
    # Backend-specific capture helpers
    # ------------------------------------------------------------------

    def _capture_frame_dxcam(self, camera) -> Optional[np.ndarray]:
        """Grab one frame via dxcam (DXGI Desktop Duplication)."""
        frame = camera.get_latest_frame()
        return frame   # already RGB numpy uint8, or None if no new frame

    def _capture_frame_mss(self, sct, mon_dict: Dict) -> np.ndarray:
        """Grab one frame via mss (fast GDI)."""
        shot = sct.grab(mon_dict)
        img  = np.array(shot)               # BGRA
        return img[:, :, 2::-1].copy()      # -> RGB

    def _capture_frame_pil(self, bbox: Tuple) -> Optional[np.ndarray]:
        """Grab one frame via Pillow ImageGrab (slowest, always available)."""
        try:
            pil_img = ImageGrab.grab(bbox=bbox, all_screens=True)
        except TypeError:
            pil_img = ImageGrab.grab(bbox)
        img = np.asarray(pil_img)
        if img.size == 0:
            return None
        if len(img.shape) == 2:
            img = np.stack([img, img, img], axis=-1)
        elif img.shape[2] == 4:
            img = img[:, :, :3]
        return img.copy()

    def _emit_fps(self, frame_count: int, fps_time: float) -> Tuple[int, float]:
        elapsed = time.time() - fps_time
        if elapsed >= 1.0:
            self.signals.fps_updated.emit(frame_count / elapsed)
            return 0, time.time()
        return frame_count, fps_time

    # ------------------------------------------------------------------
    # Main run loop
    # ------------------------------------------------------------------

    def run(self):
        """Main capture loop — tries dxcam → mss → PIL in order."""
        self.is_running = True

        with self._lock:
            display          = self.display_info
            capture_cursor   = self.capture_cursor
            settings         = self.capture_settings

        monitor_dict = {
            "left":   display.x,
            "top":    display.y,
            "width":  display.width,
            "height": display.height,
        }
        bbox = (display.x, display.y,
                display.x + display.width,
                display.y + display.height)

        # ---- Choose backend ----
        if DXCAM_AVAILABLE:
            self._run_dxcam(display, settings, capture_cursor)
        elif MSS_AVAILABLE:
            self._run_mss(monitor_dict, settings, capture_cursor)
        elif PIL_AVAILABLE:
            self._run_pil(bbox, settings, capture_cursor)
        else:
            self.signals.capture_error.emit(
                "No capture backend available. Install dxcam or mss.")

    # ---- dxcam backend (DXGI, hardware, true 60-144 FPS) ----
    def _run_dxcam(self, display: DisplayInfo, settings: 'CaptureSettings',
                   capture_cursor: bool):
        import dxcam
        camera = None
        try:
            # Find the dxcam output index matching our monitor
            # dxcam output_idx corresponds to monitor index (0-based)
            output_idx = max(0, display.index - 1)
            camera = dxcam.create(
                output_idx=output_idx,
                output_color="RGB"
            )
            # with_cursor not supported on all dxcam builds; catch gracefully
            try:
                camera = dxcam.create(
                    output_idx=output_idx,
                    output_color="RGB"
                )
            except Exception:
                pass

            target_fps = settings.target_fps
            camera.start(target_fps=target_fps, video_mode=True)
            logger.info(f"dxcam started: output_idx={output_idx}, "
                        f"target_fps={target_fps}")

            frame_count = 0
            fps_time    = time.time()
            monitor_dict = {
                "left":   display.x,
                "top":    display.y,
                "width":  display.width,
                "height": display.height,
            }

            while self.is_running:
                with self._lock:
                    capture_cursor = self.capture_cursor
                    settings       = self.capture_settings

                img = camera.get_latest_frame()
                if img is None:
                    # No new frame yet — yield and retry
                    time.sleep(0.001)
                    continue

                # img is already RGB uint8 from dxcam
                img = img.copy()

                # Apply enhancements (lightweight only)
                img = self._apply_quality_enhancements(img)

                # Draw cursor (dxcam doesn't include it by default)
                if capture_cursor:
                    img = self._draw_cursor(img, monitor_dict)

                self.signals.frame_captured.emit(img)

                frame_count += 1
                frame_count, fps_time = self._emit_fps(frame_count, fps_time)

        except Exception as e:
            import traceback
            logger.error(f"dxcam error: {e}\n{traceback.format_exc()}")
            self.signals.capture_error.emit(
                f"dxcam failed: {e} — falling back to mss")
            # Graceful fallback
            if MSS_AVAILABLE:
                monitor_dict = {
                    "left":   display.x,
                    "top":    display.y,
                    "width":  display.width,
                    "height": display.height,
                }
                self._run_mss(monitor_dict, settings, capture_cursor)
        finally:
            try:
                if camera is not None:
                    camera.stop()
                    del camera
            except Exception:
                pass

    # ---- mss backend (fast GDI, ~30-60 FPS) ----
    def _run_mss(self, monitor_dict: Dict, settings: 'CaptureSettings',
                 capture_cursor: bool):
        import mss as mss_module
        logger.info("Using mss capture backend")
        frame_count = 0
        fps_time    = time.time()

        with mss_module.mss() as sct:
            while self.is_running:
                loop_start = time.time()

                with self._lock:
                    capture_cursor = self.capture_cursor
                    settings       = self.capture_settings

                try:
                    img = self._capture_frame_mss(sct, monitor_dict)
                    img = self._apply_quality_enhancements(img)
                    if capture_cursor:
                        img = self._draw_cursor(img, monitor_dict)

                    self.signals.frame_captured.emit(img)
                    frame_count += 1
                    frame_count, fps_time = self._emit_fps(frame_count, fps_time)

                except Exception as e:
                    logger.error(f"mss capture error: {e}")
                    time.sleep(0.05)
                    continue

                elapsed    = time.time() - loop_start
                sleep_time = self.frame_time - elapsed
                if sleep_time > 0:
                    time.sleep(sleep_time)

    # ---- PIL / ImageGrab backend (reliable fallback, ~10-20 FPS) ----
    def _run_pil(self, bbox: Tuple, settings: 'CaptureSettings',
                 capture_cursor: bool):
        if not PIL_AVAILABLE:
            self.signals.capture_error.emit("No capture backend available.")
            return
        logger.info("Using PIL ImageGrab capture backend (slowest)")
        monitor_dict = {
            "left":   bbox[0], "top":    bbox[1],
            "width":  bbox[2]-bbox[0],
            "height": bbox[3]-bbox[1],
        }
        frame_count = 0
        fps_time    = time.time()

        while self.is_running:
            loop_start = time.time()

            with self._lock:
                capture_cursor = self.capture_cursor
                settings       = self.capture_settings

            try:
                img = self._capture_frame_pil(bbox)
                if img is None:
                    time.sleep(0.05)
                    continue

                img = self._apply_quality_enhancements(img)
                if capture_cursor:
                    img = self._draw_cursor(img, monitor_dict)

                self.signals.frame_captured.emit(img)
                frame_count += 1
                frame_count, fps_time = self._emit_fps(frame_count, fps_time)

            except Exception as e:
                import traceback
                logger.error(f"PIL capture error: {e}\n{traceback.format_exc()}")
                time.sleep(0.1)
                continue

            elapsed    = time.time() - loop_start
            sleep_time = self.frame_time - elapsed
            if sleep_time > 0:
                time.sleep(sleep_time)


# =============================================================================
# Display Selection Dialog
# =============================================================================

class DisplaySelectionDialog(QDialog):
    """Professional dialog for selecting display and quality settings."""
    
    def __init__(self, parent: Optional[QWidget] = None):
        super().__init__(parent)
        self.setWindowTitle("Select Display - PyDisplayWindow Pro")
        self.setMinimumWidth(550)
        self.setMinimumHeight(500)
        self.selected_display: Optional[DisplayInfo] = None
        self.settings = AppSettings()
        self._setup_ui()
        self._load_displays()
    
    def _setup_ui(self):
        """Initialize the professional user interface."""
        layout = QVBoxLayout(self)
        layout.setSpacing(15)
        layout.setContentsMargins(20, 20, 20, 20)
        
        # Title
        title = QLabel("🎬 PyDisplayWindow Pro - Capture Settings")
        title_font = QFont()
        title_font.setPointSize(16)
        title_font.setBold(True)
        title.setFont(title_font)
        title.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(title)
        
        # Subtitle
        subtitle = QLabel(
            "Professional screen capture with ultra-high quality and smooth performance"
        )
        subtitle.setAlignment(Qt.AlignmentFlag.AlignCenter)
        subtitle.setWordWrap(True)
        subtitle.setStyleSheet("color: #888; margin-bottom: 10px;")
        layout.addWidget(subtitle)
        
        # Tab widget for organized settings
        tab_widget = QTabWidget()
        
        # === Display Tab ===
        display_tab = QWidget()
        display_layout = QVBoxLayout(display_tab)
        
        # Display list group
        display_group = QGroupBox("Available Displays")
        display_layout_inner = QVBoxLayout(display_group)
        
        self.display_combo = QComboBox()
        self.display_combo.setMinimumHeight(40)
        display_layout_inner.addWidget(self.display_combo)
        
        # Display info label
        self.display_info_label = QLabel("Select a display to see details")
        self.display_info_label.setWordWrap(True)
        self.display_info_label.setStyleSheet(
            "color: #666; padding: 15px; background: #f5f5f5; border-radius: 5px;"
        )
        display_layout_inner.addWidget(self.display_info_label)
        
        display_layout.addWidget(display_group)
        
        # Refresh button
        refresh_btn = QPushButton("🔄 Refresh Display List")
        refresh_btn.clicked.connect(self._load_displays)
        display_layout.addWidget(refresh_btn)
        
        display_layout.addStretch()
        tab_widget.addTab(display_tab, "🖥 Display")
        
        # === Performance Tab ===
        perf_tab = QWidget()
        perf_layout = QVBoxLayout(perf_tab)
        
        # FPS Settings
        fps_group = QGroupBox("Frame Rate Settings")
        fps_layout = QGridLayout(fps_group)
        
        fps_layout.addWidget(QLabel("Target FPS:"), 0, 0)
        self.fps_spinbox = QSpinBox()
        self.fps_spinbox.setRange(15, 60)
        self.fps_spinbox.setValue(min(self.settings.target_fps, 60))
        self.fps_spinbox.setSuffix(" fps")
        self.fps_spinbox.setToolTip("Higher FPS = smoother but more CPU/GPU usage")
        fps_layout.addWidget(self.fps_spinbox, 0, 1)
        
        # FPS Presets
        fps_layout.addWidget(QLabel("FPS Preset:"), 1, 0)
        self.fps_preset_combo = QComboBox()
        self.fps_preset_combo.addItems([
            "🎬 Cinema (24 FPS)",
            "📺 Standard (30 FPS)",
            "🎮 Gaming (45 FPS)",
            "⚡ High (60 FPS)",
        ])
        self.fps_preset_combo.setCurrentIndex(3)  # Default 60
        self.fps_preset_combo.currentIndexChanged.connect(self._on_fps_preset_changed)
        fps_layout.addWidget(self.fps_preset_combo, 1, 1)
        
        # VSync
        self.vsync_checkbox = QCheckBox("Enable VSync (Recommended for smooth display)")
        self.vsync_checkbox.setChecked(self.settings.capture_settings.vsync_enabled)
        fps_layout.addWidget(self.vsync_checkbox, 2, 0, 1, 2)
        
        # Adaptive Sync
        self.adaptive_sync_checkbox = QCheckBox("Adaptive Sync (Auto-adjust to display)")
        self.adaptive_sync_checkbox.setChecked(self.settings.capture_settings.adaptive_sync)
        fps_layout.addWidget(self.adaptive_sync_checkbox, 3, 0, 1, 2)
        
        perf_layout.addWidget(fps_group)
        
        # Buffer Settings
        buffer_group = QGroupBox("Buffer Settings")
        buffer_layout = QGridLayout(buffer_group)
        
        buffer_layout.addWidget(QLabel("Buffer Size:"), 0, 0)
        self.buffer_spinbox = QSpinBox()
        self.buffer_spinbox.setRange(1, 5)
        self.buffer_spinbox.setValue(self.settings.capture_settings.buffer_size)
        self.buffer_spinbox.setSuffix(" frames")
        self.buffer_spinbox.setToolTip("Higher = smoother but more latency")
        buffer_layout.addWidget(self.buffer_spinbox, 0, 1)
        
        self.triple_buffer_checkbox = QCheckBox("Triple Buffering (Ultra-smooth)")
        self.triple_buffer_checkbox.setChecked(self.settings.capture_settings.enable_triple_buffering)
        buffer_layout.addWidget(self.triple_buffer_checkbox, 1, 0, 1, 2)
        
        perf_layout.addWidget(buffer_group)
        
        perf_layout.addStretch()
        tab_widget.addTab(perf_tab, "⚡ Performance")
        
        # === Quality Tab ===
        quality_tab = QWidget()
        quality_layout = QVBoxLayout(quality_tab)
        
        # Quality Presets
        quality_preset_group = QGroupBox("Quality Preset")
        quality_preset_layout = QVBoxLayout(quality_preset_group)
        
        self.quality_button_group = QButtonGroup(self)
        
        quality_options = [
            ("Performance", "Prioritize speed over quality", QualityPreset.PERFORMANCE),
            ("Balanced", "Good quality with reasonable performance", QualityPreset.BALANCED),
            ("High Quality", "Excellent visual quality (Recommended)", QualityPreset.HIGH_QUALITY),
            ("Ultra", "Maximum quality with enhancements", QualityPreset.ULTRA),
            ("Maximum", "Uncompressed, highest fidelity", QualityPreset.MAXIMUM)
        ]
        
        for i, (name, desc, preset) in enumerate(quality_options):
            radio = QRadioButton(f"{name} - {desc}")
            self.quality_button_group.addButton(radio, i)
            quality_preset_layout.addWidget(radio)
        
        # Select default
        self.quality_button_group.button(2).setChecked(True)
        
        quality_layout.addWidget(quality_preset_group)
        
        # Scaling Options
        scaling_group = QGroupBox("Scaling & Resolution")
        scaling_layout = QGridLayout(scaling_group)
        
        scaling_layout.addWidget(QLabel("Scale Factor:"), 0, 0)
        self.scale_slider = QSlider(Qt.Orientation.Horizontal)
        self.scale_slider.setRange(50, 100)
        self.scale_slider.setValue(int(self.settings.scale_factor * 100))
        self.scale_label = QLabel(f"{int(self.settings.scale_factor * 100)}%")
        scale_inner_layout = QHBoxLayout()
        scale_inner_layout.addWidget(self.scale_slider)
        scale_inner_layout.addWidget(self.scale_label)
        scaling_layout.addLayout(scale_inner_layout, 0, 1)
        
        self.lanczos_checkbox = QCheckBox("Lanczos Scaling (Sharper downscaling)")
        self.lanczos_checkbox.setChecked(self.settings.capture_settings.use_lanczos_scaling)
        scaling_layout.addWidget(self.lanczos_checkbox, 1, 0, 1, 2)
        
        quality_layout.addWidget(scaling_group)
        
        # Enhancement Options
        enhance_group = QGroupBox("Image Enhancements")
        enhance_layout = QVBoxLayout(enhance_group)
        
        self.sharpen_checkbox = QCheckBox("Sharpening Filter")
        self.sharpen_checkbox.setChecked(self.settings.capture_settings.enable_sharpening)
        enhance_layout.addWidget(self.sharpen_checkbox)
        
        self.color_enhance_checkbox = QCheckBox("Color Enhancement")
        self.color_enhance_checkbox.setChecked(self.settings.capture_settings.color_enhancement)
        enhance_layout.addWidget(self.color_enhance_checkbox)
        
        quality_layout.addWidget(enhance_group)
        
        quality_layout.addStretch()
        tab_widget.addTab(quality_tab, "✨ Quality")
        
        # === Advanced Tab ===
        advanced_tab = QWidget()
        advanced_layout = QVBoxLayout(advanced_tab)
        
        # Hardware Acceleration
        hw_group = QGroupBox("Hardware Acceleration")
        hw_layout = QVBoxLayout(hw_group)
        
        self.hw_accel_checkbox = QCheckBox("Enable Hardware Acceleration")
        self.hw_accel_checkbox.setChecked(self.settings.capture_settings.use_hardware_acceleration)
        self.hw_accel_checkbox.setToolTip("Use GPU for rendering when available")
        hw_layout.addWidget(self.hw_accel_checkbox)
        
        self.gpu_render_checkbox = QCheckBox("Prefer GPU Rendering")
        self.gpu_render_checkbox.setChecked(self.settings.capture_settings.prefer_gpu_rendering)
        hw_layout.addWidget(self.gpu_render_checkbox)
        
        advanced_layout.addWidget(hw_group)
        
        # Cursor Options
        cursor_group = QGroupBox("Cursor Capture")
        cursor_layout = QVBoxLayout(cursor_group)
        
        self.capture_cursor_checkbox = QCheckBox("🖱 Capture Mouse Cursor")
        self.capture_cursor_checkbox.setChecked(self.settings.capture_settings.capture_cursor)
        cursor_layout.addWidget(self.capture_cursor_checkbox)
        
        self.cursor_smooth_checkbox = QCheckBox("Cursor Smoothing")
        self.cursor_smooth_checkbox.setChecked(self.settings.capture_settings.cursor_smoothing)
        cursor_layout.addWidget(self.cursor_smooth_checkbox)
        
        advanced_layout.addWidget(cursor_group)
        
        # Adaptive Performance
        adaptive_group = QGroupBox("Adaptive Performance")
        adaptive_layout = QVBoxLayout(adaptive_group)
        
        self.dynamic_quality_checkbox = QCheckBox("Dynamic Quality Adjustment")
        self.dynamic_quality_checkbox.setChecked(self.settings.capture_settings.dynamic_quality_adjust)
        self.dynamic_quality_checkbox.setToolTip("Automatically reduce quality if performance drops")
        adaptive_layout.addWidget(self.dynamic_quality_checkbox)
        
        advanced_layout.addWidget(adaptive_group)
        
        # Presentation Mode
        self.presentation_mode_checkbox = QCheckBox(
            "🎬 Presentation Mode (Clean UI - No buttons/menus during capture)"
        )
        self.presentation_mode_checkbox.setChecked(self.settings.presentation_mode)
        self.presentation_mode_checkbox.setToolTip("Hide all UI elements during capture for clean streaming")
        advanced_layout.addWidget(self.presentation_mode_checkbox)
        
        advanced_layout.addStretch()
        tab_widget.addTab(advanced_tab, "⚙ Advanced")
        
        layout.addWidget(tab_widget)
        
        # Connect signals
        self.scale_slider.valueChanged.connect(
            lambda v: self.scale_label.setText(f"{v}%")
        )
        self.display_combo.currentIndexChanged.connect(self._on_display_changed)
        
        # Dialog buttons
        button_box = QDialogButtonBox(
            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
        )
        button_box.accepted.connect(self._on_accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)
    
    def _on_fps_preset_changed(self, index: int):
        """Update FPS based on preset selection."""
        fps_values = [24, 30, 45, 60]
        self.fps_spinbox.setValue(fps_values[index])
    
    def _on_display_changed(self):
        """Update display info when selection changes."""
        display = self.display_combo.currentData()
        if display:
            # Recommend FPS based on refresh rate
            recommended_fps = DisplayManager.get_recommended_fps(display)
            
            info_text = (
                f"<b>Display:</b> {display.name}<br>"
                f"<b>Resolution:</b> {display.width} x {display.height}<br>"
                f"<b>Refresh Rate:</b> {display.refresh_rate}Hz<br>"
                f"<b>Position:</b> ({display.x}, {display.y})<br>"
                f"<b>Primary:</b> {'Yes' if display.is_primary else 'No'}<br>"
                f"<b>Recommended FPS:</b> {recommended_fps}"
            )
            self.display_info_label.setText(info_text)
            
            # Auto-suggest FPS
            self.fps_spinbox.setValue(recommended_fps)
    
    def _load_displays(self):
        """Load and display available monitors."""
        self.display_combo.clear()
        displays = DisplayManager.get_available_displays()
        
        if not displays:
            self.display_combo.addItem("No displays detected")
            self.display_combo.setEnabled(False)
            return
        
        self.display_combo.setEnabled(True)
        for display in displays:
            self.display_combo.addItem(str(display), display)
        
        # Select primary display by default
        for i, display in enumerate(displays):
            if display.is_primary:
                self.display_combo.setCurrentIndex(i)
                break
        
        self._on_display_changed()
    
    def _on_accept(self):
        """Handle OK button click."""
        self.selected_display = self.display_combo.currentData()
        if self.selected_display:
            # Update settings
            self.settings.target_fps = self.fps_spinbox.value()
            self.settings.scale_factor = self.scale_slider.value() / 100.0
            self.settings.presentation_mode = self.presentation_mode_checkbox.isChecked()
            
            # Capture settings
            cs = self.settings.capture_settings
            cs.target_fps = self.fps_spinbox.value()
            cs.vsync_enabled = self.vsync_checkbox.isChecked()
            cs.adaptive_sync = self.adaptive_sync_checkbox.isChecked()
            cs.buffer_size = self.buffer_spinbox.value()
            cs.enable_triple_buffering = self.triple_buffer_checkbox.isChecked()
            cs.scale_factor = self.settings.scale_factor
            cs.use_lanczos_scaling = self.lanczos_checkbox.isChecked()
            cs.enable_sharpening = self.sharpen_checkbox.isChecked()
            cs.color_enhancement = self.color_enhance_checkbox.isChecked()
            cs.use_hardware_acceleration = self.hw_accel_checkbox.isChecked()
            cs.prefer_gpu_rendering = self.gpu_render_checkbox.isChecked()
            cs.capture_cursor = self.capture_cursor_checkbox.isChecked()
            cs.cursor_smoothing = self.cursor_smooth_checkbox.isChecked()
            cs.dynamic_quality_adjust = self.dynamic_quality_checkbox.isChecked()
            
            # Quality preset
            preset_index = self.quality_button_group.checkedId()
            presets = [
                QualityPreset.PERFORMANCE,
                QualityPreset.BALANCED, 
                QualityPreset.HIGH_QUALITY,
                QualityPreset.ULTRA,
                QualityPreset.MAXIMUM
            ]
            cs.quality_preset = presets[preset_index]
            
            self.accept()
        else:
            QMessageBox.warning(self, "No Display Selected", 
                              "Please select a display to capture.")
    
    def get_settings(self) -> Tuple[DisplayInfo, AppSettings]:
        """Return selected display and settings."""
        return self.selected_display, self.settings


# =============================================================================
# Main Application Window
# =============================================================================

class MainWindow(QMainWindow):
    """Main application window for PyDisplayWindow Pro."""
    
    def __init__(self):
        super().__init__()
        self.setWindowTitle("PyDisplayWindow Pro - Ultra Quality Capture")
        self.setMinimumSize(800, 600)
        self.resize(1280, 720)
        
        # State
        self.capture_worker: Optional[CaptureWorker] = None
        self.current_display: Optional[DisplayInfo] = None
        self.settings = AppSettings()
        self.current_frame: Optional[np.ndarray] = None
        self.current_fps: float = 0.0
        self.is_paused: bool = False
        self.current_quality_scale: float = 1.0
        # Display throttle: limit Qt rendering to 60 FPS regardless of capture FPS.
        # At 120+ FPS the Qt main thread gets overwhelmed by Lanczos resize.
        self._last_display_time: float = 0.0
        self._display_interval: float = 1.0 / 60.0  # 60 FPS max for display

        # Load config FIRST before UI setup
        self._load_config()
        
        # Setup
        self._setup_ui()
        self._setup_menu()
        
        # Apply always on top setting AFTER UI is created
        self._apply_always_on_top_setting()
        
        # Setup OpenGL if available
        self._setup_opengl()
    
    def _setup_opengl(self):
        """Setup OpenGL for hardware acceleration."""
        if self.settings.capture_settings.prefer_gpu_rendering:
            try:
                from PyQt6.QtOpenGLWidgets import QOpenGLWidget
                # OpenGL is available, will be used automatically
                logger.info("OpenGL support available for GPU rendering")
            except ImportError:
                logger.info("OpenGL not available, using standard rendering")
    
    def _setup_ui(self):
        """Initialize the main user interface."""
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)
        
        # Video display frame
        self.video_frame = QFrame()
        self.video_frame.setFrameStyle(QFrame.Shape.NoFrame)
        self.video_frame.setSizePolicy(
            QSizePolicy.Policy.Expanding, 
            QSizePolicy.Policy.Expanding
        )
        self.video_frame.setStyleSheet("background-color: #0a0a0a;")
        
        video_layout = QVBoxLayout(self.video_frame)
        video_layout.setContentsMargins(0, 0, 0, 0)
        
        # Image label for displaying frames with high quality scaling
        self.image_label = QLabel()
        self.image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.image_label.setSizePolicy(
            QSizePolicy.Policy.Expanding, 
            QSizePolicy.Policy.Expanding
        )
        self.image_label.setStyleSheet("background-color: #0a0a0a; color: white;")
        self.image_label.setText("Select a display to start capturing\n\nPress Start for professional quality capture")
        
        video_layout.addWidget(self.image_label)
        main_layout.addWidget(self.video_frame)
        
        # Control panel
        self.control_panel = self._create_control_panel()
        main_layout.addWidget(self.control_panel)
        
        # Status bar
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.status_bar.showMessage("Ready - Press Start to begin ultra-quality capture")
        
        # FPS label in status bar
        self.fps_label = QLabel("FPS: --")
        self.status_bar.addPermanentWidget(self.fps_label)
        
        # Quality indicator
        self.quality_label = QLabel("Quality: 100%")
        self.status_bar.addPermanentWidget(self.quality_label)
        
        # Display info label
        self.display_label = QLabel("Display: None")
        self.status_bar.addPermanentWidget(self.display_label)
        
        # Enable keyboard tracking for shortcuts
        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
    
    def _create_control_panel(self) -> QGroupBox:
        """Create the control panel widget."""
        panel = QGroupBox("Controls")
        panel.setMaximumHeight(90)
        
        layout = QHBoxLayout(panel)
        layout.setSpacing(15)
        
        # Start/Stop button
        self.start_btn = QPushButton("▶ Start Capture")
        self.start_btn.setMinimumWidth(140)
        self.start_btn.setStyleSheet("""
            QPushButton {
                background-color: #4CAF50;
                color: white;
                border: none;
                padding: 10px 20px;
                border-radius: 5px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background-color: #45a049;
            }
        """)
        self.start_btn.clicked.connect(self._toggle_capture)
        layout.addWidget(self.start_btn)
        
        # Pause button
        self.pause_btn = QPushButton("⏸ Pause")
        self.pause_btn.setEnabled(False)
        self.pause_btn.clicked.connect(self._toggle_pause)
        layout.addWidget(self.pause_btn)
        
        # Change display button
        change_display_btn = QPushButton("🖥 Change Display")
        change_display_btn.clicked.connect(self._show_display_selector)
        layout.addWidget(change_display_btn)
        
        layout.addStretch()
        
        # FPS display
        layout.addWidget(QLabel("Target FPS:"))
        self.fps_display = QLabel("60")
        self.fps_display.setStyleSheet("font-weight: bold; color: #4CAF50;")
        layout.addWidget(self.fps_display)
        
        # Quality indicator
        layout.addWidget(QLabel("| Quality:"))
        self.quality_display = QLabel("High")
        self.quality_display.setStyleSheet("font-weight: bold; color: #2196F3;")
        layout.addWidget(self.quality_display)
        
        # Always on top toggle
        self.top_checkbox = QCheckBox("Always on top")
        self.top_checkbox.setChecked(self.settings.always_on_top)
        self.top_checkbox.stateChanged.connect(self._on_always_on_top_changed)
        layout.addWidget(self.top_checkbox)
        
        return panel
    
    def _setup_menu(self):
        """Setup the menu bar."""
        menubar = self.menuBar()
        
        # File menu
        file_menu = menubar.addMenu("&File")
        
        select_display_action = QAction("&Select Display...", self)
        select_display_action.setShortcut(QKeySequence("Ctrl+D"))
        select_display_action.triggered.connect(self._show_display_selector)
        file_menu.addAction(select_display_action)
        
        file_menu.addSeparator()
        
        exit_action = QAction("E&xit", self)
        exit_action.setShortcut(QKeySequence("Ctrl+Q"))
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        # View menu
        view_menu = menubar.addMenu("&View")
        
        self.fullscreen_action = QAction("&Fullscreen", self)
        self.fullscreen_action.setShortcut(QKeySequence("F11"))
        self.fullscreen_action.setCheckable(True)
        self.fullscreen_action.triggered.connect(self._toggle_fullscreen)
        view_menu.addAction(self.fullscreen_action)
        
        # Help menu
        help_menu = menubar.addMenu("&Help")
        
        about_action = QAction("&About", self)
        about_action.triggered.connect(self._show_about)
        help_menu.addAction(about_action)
    
    def _show_display_selector(self):
        """Show the display selection dialog."""
        dialog = DisplaySelectionDialog(self)
        
        if dialog.exec() == QDialog.DialogCode.Accepted:
            display, settings = dialog.get_settings()
            self.current_display = display
            self.settings = settings
            
            # Update UI
            self.fps_display.setText(str(settings.target_fps))
            self.top_checkbox.setChecked(settings.always_on_top)
            self._on_always_on_top_changed()
            
            # Update quality display
            quality_names = {
                QualityPreset.PERFORMANCE: "Perf",
                QualityPreset.BALANCED: "Balanced",
                QualityPreset.HIGH_QUALITY: "High",
                QualityPreset.ULTRA: "Ultra",
                QualityPreset.MAXIMUM: "Max"
            }
            self.quality_display.setText(
                quality_names.get(settings.capture_settings.quality_preset, "High")
            )
            
            self.display_label.setText(f"Display: {display.name}")
            self.status_bar.showMessage(f"Selected: {display} | Ready to capture")
            
            # Restart capture if running
            if self.capture_worker and self.capture_worker.isRunning():
                self._stop_capture()
                self._start_capture()
            else:
                # Auto-start if not running
                self._start_capture()
    
    def _start_capture(self):
        """Start the screen capture worker and enter presentation mode."""
        if not self.current_display:
            self._show_display_selector()
            return
        
        if not PIL_AVAILABLE:
            QMessageBox.critical(self, "Error", 
                "PIL (Pillow) library is not installed. Please install it with: pip install Pillow opencv-python")
            return
        
        # Show test frame first to verify display pipeline works
        self.image_label.setText("🎬 Starting capture...")
        QApplication.processEvents()
        
        # Create and start capture worker with professional settings
        self._relocate_window_for_capture(self.current_display)
        self.capture_worker = CaptureWorker(
            self.current_display, 
            self.settings.capture_settings
        )
        self.capture_worker.signals.frame_captured.connect(self._on_frame_captured)
        self.capture_worker.signals.capture_error.connect(self._on_capture_error)
        self.capture_worker.signals.fps_updated.connect(self._on_fps_updated)
        self.capture_worker.signals.performance_warning.connect(self._on_performance_warning)
        self.capture_worker.signals.quality_adjusted.connect(self._on_quality_adjusted)
        self.capture_worker.signals.request_window_opacity.connect(self._set_window_opacity)
        self.capture_worker.start()
        
        # Update UI
        self.start_btn.setText("⏹ Stop Capture")
        self.start_btn.setStyleSheet("""
            QPushButton {
                background-color: #f44336;
                color: white;
                border: none;
                padding: 10px 20px;
                border-radius: 5px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background-color: #da190b;
            }
        """)
        self.pause_btn.setEnabled(True)
        
        # Show minimal hint
        self.status_bar.showMessage(
            f"🎬 Capture starting... | Target: {self.settings.target_fps} FPS | "
            f"OpenCV: {'✓' if CV2_AVAILABLE else '✗'}"
        )
        
        # Only enter presentation mode after first frame is captured
        QTimer.singleShot(1000, self._enter_presentation_mode_if_capturing)
    
    def _enter_presentation_mode_if_capturing(self):
        """Enter presentation mode only if capture is actually working."""
        if self.capture_worker and self.capture_worker.isRunning() and self.current_frame is not None:
            self._enter_presentation_mode()
        else:
            # Capture not working, keep UI visible for debugging
            self.status_bar.showMessage("⚠ Capture may not be working - check console for errors")
    
    def _enter_presentation_mode(self):
        """Hide all UI elements for clean presentation/streaming mode."""
        if self.settings.presentation_mode:
            # Hide control panel
            if hasattr(self, 'control_panel'):
                self.control_panel.hide()
            
            # Hide menu bar
            self.menuBar().hide()
            
            # Hide status bar (or keep minimal)
            if not self.settings.show_fps:
                self.status_bar.hide()
            else:
                self.status_bar.show()
            
            # Remove window title bar decorations for pure content
            self.setWindowTitle("PyDisplayWindow Pro - Streaming")
            
            # IMPORTANT: Only enable always on top if user has it enabled in settings
            # Do NOT force it on during presentation mode
            if self.settings.always_on_top:
                logger.info("Presentation mode: Always on top is enabled by user setting")
            else:
                logger.info("Presentation mode: Always on top is disabled by user setting")
    
    def _exit_presentation_mode(self):
        """Restore UI elements when stopping capture."""
        # Show control panel
        if hasattr(self, 'control_panel'):
            self.control_panel.show()
        
        # Show menu bar
        self.menuBar().show()
        
        # Show status bar
        self.status_bar.show()
        
        # Restore window title
        self.setWindowTitle("PyDisplayWindow Pro - Ultra Quality Capture")

    def _toggle_fullscreen(self, enabled: Optional[bool] = None):
        if enabled is None:
            enabled = not self.isFullScreen()

        if enabled:
            if not hasattr(self, "_normal_geometry"):
                self._normal_geometry = self.geometry()
            self.showFullScreen()
        else:
            self.showNormal()
            if hasattr(self, "_normal_geometry"):
                try:
                    self.setGeometry(self._normal_geometry)
                except Exception:
                    pass

        if hasattr(self, "fullscreen_action"):
            self.fullscreen_action.setChecked(bool(enabled))

    def _set_window_opacity(self, opacity: float):
        try:
            self.setWindowOpacity(max(0.05, min(float(opacity), 1.0)))
        except Exception:
            pass

    def _relocate_window_for_capture(self, display: DisplayInfo):
        try:
            if display is None:
                return

            win_center = self.frameGeometry().center()
            wx = int(win_center.x())
            wy = int(win_center.y())
            in_target = (
                display.x <= wx < (display.x + display.width)
                and display.y <= wy < (display.y + display.height)
            )
            if not in_target:
                return

            displays = DisplayManager.get_available_displays()
            alt = None
            for d in displays:
                if d.x == display.x and d.y == display.y and d.width == display.width and d.height == display.height:
                    continue
                alt = d
                break

            if alt is None:
                self.status_bar.showMessage(
                    "⚠ Capturing the monitor where this window is located may cause recursion. Move the window to another monitor for best quality."
                )
                return

            self.move(int(alt.x + 40), int(alt.y + 40))
            self.raise_()
            self.activateWindow()
        except Exception:
            pass
    
    def _stop_capture(self):
        """Stop the screen capture worker and exit presentation mode."""
        if self.capture_worker:
            self.capture_worker.stop()
            self.capture_worker = None

        self._set_window_opacity(1.0)
        
        # Exit presentation mode - restore UI
        self._exit_presentation_mode()
        
        # Update UI
        self.start_btn.setText("▶ Start Capture")
        self.start_btn.setStyleSheet("""
            QPushButton {
                background-color: #4CAF50;
                color: white;
                border: none;
                padding: 10px 20px;
                border-radius: 5px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background-color: #45a049;
            }
        """)
        self.pause_btn.setEnabled(False)
        self.image_label.setText("Capture stopped - Press Start to resume")
        self.fps_label.setText("FPS: --")
        self.quality_label.setText("Quality: 100%")
        self.status_bar.showMessage("Capture stopped")
    
    def _toggle_capture(self):
        """Toggle capture on/off."""
        if self.capture_worker and self.capture_worker.isRunning():
            self._stop_capture()
        else:
            self._start_capture()
    
    def _toggle_pause(self):
        """Toggle pause/resume."""
        self.is_paused = not self.is_paused
        if self.is_paused:
            self.pause_btn.setText("▶ Resume")
            self.status_bar.showMessage("⏸ Paused")
        else:
            self.pause_btn.setText("⏸ Pause")
            self.status_bar.showMessage("🎬 Capturing...")
    
    def _on_always_on_top_changed(self):
        """Handle always on top toggle - CRITICAL: This must actually work!"""
        on_top = self.top_checkbox.isChecked()
        
        # Update settings
        self.settings.always_on_top = on_top
        
        # Save immediately so it persists
        self._save_config()
        
        # Get current state
        was_minimized = self.isMinimized()
        was_maximized = self.isMaximized()
        was_fullscreen = self.isFullScreen()
        current_geometry = self.geometry()
        
        # CRITICAL: Must hide window first, then change flag, then show
        # This is the only reliable way to change WindowStaysOnTopHint on Windows
        self.hide()
        
        # Clear the flag first
        self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowStaysOnTopHint)
        
        # Set the flag if needed
        if on_top:
            self.setWindowFlags(self.windowFlags() | Qt.WindowType.WindowStaysOnTopHint)
        
        # Restore window state
        self.show()
        
        # Restore geometry and state
        if was_fullscreen:
            self.showFullScreen()
        elif was_maximized:
            self.showMaximized()
        elif was_minimized:
            self.showMinimized()
        else:
            self.setGeometry(current_geometry)
        
        # Update status with clear feedback
        status = "ENABLED [ON]" if on_top else "DISABLED [OFF]"
        self.status_bar.showMessage(f"Always on top: {status}", 3000)
        logger.info(f"Always on top changed to: {on_top}")
        
        # Test the setting
        QTimer.singleShot(100, lambda: self._verify_always_on_top(on_top))
    
    def _verify_always_on_top(self, expected: bool):
        """Verify that always on top is actually working."""
        actual = bool(self.windowFlags() & Qt.WindowType.WindowStaysOnTopHint)
        if actual == expected:
            logger.info(f"[OK] Always on top verified: {actual}")
        else:
            logger.error(f"[FAIL] Always on top FAILED! Expected: {expected}, Actual: {actual}")
            self.status_bar.showMessage(f"Warning: Always on top may not be working correctly", 5000)
    
    def _on_frame_captured(self, frame: np.ndarray):
        """
        Display a captured frame.
        • Throttled to 60 FPS on the Qt main thread regardless of capture FPS.
        • Uses INTER_AREA for downscaling (sharpest for text — no ringing).
        • Keeps full aspect ratio with letterboxing.
        • CONTINUES CAPTURING even when window is minimized!
        """
        if self.is_paused:
            return

        # CRITICAL: Store frame FIRST, even if minimized
        # This ensures other apps can access the frame data
        self.current_frame = frame
        
        # Check if window is minimized - if so, skip rendering but keep capturing
        if self.isMinimized():
            # Capture continues, just don't render to save CPU
            # Log occasionally to prove it's working
            if not hasattr(self, '_minimize_log_counter'):
                self._minimize_log_counter = 0
            self._minimize_log_counter += 1
            if self._minimize_log_counter % 60 == 0:  # Log every 60 frames
                logger.info(f"[OK] Still capturing while minimized (frame #{self._minimize_log_counter})")
            return
        else:
            # Reset counter when not minimized
            if hasattr(self, '_minimize_log_counter'):
                if self._minimize_log_counter > 0:
                    logger.info(f"Window restored - captured {self._minimize_log_counter} frames while minimized")
                self._minimize_log_counter = 0

        # Throttle display to 60 FPS max — prevents Qt main thread overload
        now = time.time()
        if now - self._last_display_time < self._display_interval:
            return
        self._last_display_time = now

        try:
            label_w = self.image_label.width()
            label_h = self.image_label.height()
            if label_w <= 0 or label_h <= 0:
                return

            src_h, src_w = frame.shape[:2]

            if CV2_AVAILABLE:
                # Letterbox scale
                scale  = min(label_w / src_w, label_h / src_h)
                dst_w  = max(1, int(src_w * scale))
                dst_h  = max(1, int(src_h * scale))
                # INTER_AREA = best for downscaling (sharp text, no Lanczos ringing)
                # INTER_LANCZOS4 only when upscaling
                interp = cv2.INTER_AREA if scale < 1.0 else cv2.INTER_LANCZOS4
                display_frame = cv2.resize(frame, (dst_w, dst_h),
                                           interpolation=interp)
            else:
                display_frame = frame

            if not display_frame.flags['C_CONTIGUOUS']:
                display_frame = np.ascontiguousarray(display_frame)

            h, w, ch = display_frame.shape
            q_image = QImage(
                display_frame.tobytes(), w, h, ch * w,
                QImage.Format.Format_RGB888
            )
            pixmap = QPixmap.fromImage(q_image)

            if not CV2_AVAILABLE:
                pixmap = pixmap.scaled(
                    label_w, label_h,
                    Qt.AspectRatioMode.KeepAspectRatio,
                    Qt.TransformationMode.SmoothTransformation
                )

            self.image_label.setPixmap(pixmap)

        except Exception as e:
            logger.error(f"Frame display error: {e}")
    

    def _on_fps_updated(self, fps: float):
        """Handle FPS update with color coding."""
        self.current_fps = fps
        
        # Color code based on performance
        target = self.settings.target_fps
        if fps >= target * 0.95:
            color = "#4CAF50"  # Green - excellent
        elif fps >= target * 0.8:
            color = "#FFC107"  # Yellow - good
        else:
            color = "#f44336"  # Red - poor
        
        self.fps_label.setText(f"FPS: <span style='color: {color}'>{fps:.1f}</span>")

    def _on_capture_error(self, error: str):
        self.status_bar.showMessage(f"❌ {error}")
        try:
            logger.error(error)
        except Exception:
            pass

        try:
            self._set_window_opacity(1.0)
        except Exception:
            pass

    def _on_performance_warning(self, warning: str):
        self.status_bar.showMessage(f"⚠ {warning}", 4000)
        try:
            logger.warning(warning)
        except Exception:
            pass
    
    def _on_quality_adjusted(self, scale: float):
        """Handle dynamic quality adjustment notification."""
        self.current_quality_scale = scale
        percent = int(scale * 100)
        self.quality_label.setText(f"Quality: {percent}%")
        
        if scale < 0.8:
            self.status_bar.showMessage(
                f"⚠ Performance optimization active: Quality at {percent}%", 
                3000
            )
    
    def _show_about(self):
        """Show about dialog."""
        QMessageBox.about(self, "About PyDisplayWindow Pro",
            "<h2>🎬 PyDisplayWindow Pro 2.0.0</h2>"
            "<p>A <b>professional</b> screen capture application with ultra-high quality "
            "rendering, smooth 60-144 FPS streaming, and hardware acceleration support.</p>"
            "<p><b>✨ Key Features:</b></p>"
            "<ul>"
            "<li>🖥 Multi-monitor support with refresh rate detection</li>"
            "<li>⚡ 60-144 FPS real-time capture</li>"
            "<li>🎯 Triple buffering for ultra-smooth playback</li>"
            "<li>✨ Lanczos scaling & image sharpening</li>"
            "<li>🎚 Dynamic quality adjustment</li>"
            "<li>🖱 High-quality cursor capture</li>"
            "<li>🎨 Color enhancement</li>"
            "<li>🚀 Hardware acceleration support</li>"
            "</ul>"
            "<p>Perfect for <b>Discord, TikTok, OBS,</b> and professional streaming.</p>"
            "<p><i>Built with PyQt6 + PIL + OpenCV + Windows API</i></p>"
        )
    
    def _load_config(self):
        """Load configuration from file."""
        config_path = Path.home() / ".pydisplaywindow" / "config.json"
        if config_path.exists():
            try:
                with open(config_path, 'r') as f:
                    data = json.load(f)
                    self.settings = AppSettings.from_dict(data)
                    logger.info(f"Config loaded - Always on top: {self.settings.always_on_top}")
            except Exception as e:
                logger.error(f"Error loading config: {e}")
    
    def _apply_always_on_top_setting(self):
        """Apply the always on top setting from config after UI is created."""
        try:
            # Update checkbox to match settings
            if hasattr(self, 'top_checkbox'):
                # Block signals to prevent triggering the change handler
                self.top_checkbox.blockSignals(True)
                self.top_checkbox.setChecked(self.settings.always_on_top)
                self.top_checkbox.blockSignals(False)
            
            # Apply the window flag - use the robust method
            self.hide()
            self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowStaysOnTopHint)
            if self.settings.always_on_top:
                self.setWindowFlags(self.windowFlags() | Qt.WindowType.WindowStaysOnTopHint)
            self.show()
            
            # Verify
            actual = bool(self.windowFlags() & Qt.WindowType.WindowStaysOnTopHint)
            logger.info("=" * 60)
            logger.info(f"INITIAL Always on top setting: {self.settings.always_on_top}")
            logger.info(f"Window flag actually set: {actual}")
            if actual == self.settings.always_on_top:
                logger.info("[OK] Always on top correctly applied at startup")
            else:
                logger.error("[FAIL] Always on top FAILED at startup!")
            logger.info("=" * 60)
            
        except Exception as e:
            logger.error(f"Error applying always on top: {e}")
    
    def _save_config(self):
        """Save configuration to file."""
        config_dir = Path.home() / ".pydisplaywindow"
        config_dir.mkdir(exist_ok=True)
        config_path = config_dir / "config.json"
        
        try:
            with open(config_path, 'w') as f:
                json.dump(self.settings.to_dict(), f, indent=2)
        except Exception as e:
            logger.error(f"Error saving config: {e}")
    
    def closeEvent(self, event: QCloseEvent):
        """Handle window close event."""
        self._stop_capture()
        self._save_config()
        event.accept()
    
    def changeEvent(self, event):
        """Handle window state changes (minimize, maximize, etc.)."""
        if event.type() == event.Type.WindowStateChange:
            if self.isMinimized():
                # Window minimized - capture continues but rendering pauses
                self.status_bar.showMessage("[Minimized] Capture continues in background")
                logger.info("=" * 60)
                logger.info("WINDOW MINIMIZED - Capture worker continues running!")
                logger.info("Frame capture continues, only Qt rendering is paused")
                logger.info("=" * 60)
                
                # Verify capture worker is still running
                if self.capture_worker and self.capture_worker.isRunning():
                    logger.info(f"[OK] Capture worker is RUNNING (is_running={self.capture_worker.is_running})")
                else:
                    logger.warning("[WARN] Capture worker is NOT running!")
                    
            elif self.windowState() == Qt.WindowState.WindowNoState or self.windowState() == Qt.WindowState.WindowMaximized:
                # Window restored or maximized - resume rendering
                if self.capture_worker and self.capture_worker.isRunning():
                    self.status_bar.showMessage("[Capturing...]")
                    logger.info("=" * 60)
                    logger.info("WINDOW RESTORED - Rendering resumed")
                    logger.info("=" * 60)
        
        super().changeEvent(event)
    
    def keyPressEvent(self, event):
        """Handle keyboard shortcuts for presentation mode."""
        if event.key() == Qt.Key.Key_Escape:
            # ESC stops capture and exits presentation mode
            if self.capture_worker and self.capture_worker.isRunning():
                self._stop_capture()
        elif event.key() == Qt.Key.Key_F11:
            # F11 toggles fullscreen
            self._toggle_fullscreen(not self.isFullScreen())
        elif event.key() == Qt.Key.Key_Space:
            # Space toggles pause
            if self.capture_worker and self.capture_worker.isRunning():
                self._toggle_pause()
        elif event.key() == Qt.Key.Key_F:
            # F toggles FPS display
            self.settings.show_fps = not self.settings.show_fps
        else:
            super().keyPressEvent(event)
    
    def resizeEvent(self, event: QResizeEvent):
        """Handle window resize."""
        super().resizeEvent(event)
        # Force redraw of current frame at new size
        if self.current_frame is not None and self.is_paused:
            self._on_frame_captured(self.current_frame)


# =============================================================================
# Application Entry Point
# =============================================================================

def main():
    """Application entry point with professional initialization."""
    try:
        # Enable high DPI support
        QApplication.setHighDpiScaleFactorRoundingPolicy(
            Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
        )
        
        # Configure OpenGL surface format for hardware acceleration
        surface_format = QSurfaceFormat()
        surface_format.setRenderableType(QSurfaceFormat.RenderableType.OpenGL)
        surface_format.setProfile(QSurfaceFormat.OpenGLContextProfile.CoreProfile)
        surface_format.setVersion(3, 3)
        QSurfaceFormat.setDefaultFormat(surface_format)
        
        app = QApplication(sys.argv)
        app.setApplicationName("PyDisplayWindow Pro")
        app.setApplicationVersion("2.0.0")
        app.setOrganizationName("PyDisplayWindow")
        
        # Set application style
        app.setStyle('Fusion')
        
        # Apply professional dark theme
        app.setStyleSheet("""
            QMainWindow {
                background-color: #1a1a1a;
            }
            QGroupBox {
                font-weight: bold;
                border: 1px solid #444;
                border-radius: 6px;
                margin-top: 12px;
                padding-top: 12px;
                background-color: #252525;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 12px;
                padding: 0 8px;
                color: #4CAF50;
            }
            QPushButton {
                padding: 8px 18px;
                border-radius: 4px;
                background-color: #333;
                color: white;
                border: 1px solid #555;
            }
            QPushButton:hover {
                background-color: #444;
                border: 1px solid #666;
            }
            QPushButton:pressed {
                background-color: #222;
            }
            QPushButton:disabled {
                background-color: #2a2a2a;
                color: #666;
                border: 1px solid #333;
            }
            QComboBox {
                padding: 6px;
                min-width: 100px;
                background-color: #333;
                color: white;
                border: 1px solid #555;
                border-radius: 4px;
            }
            QComboBox:hover {
                background-color: #3a3a3a;
            }
            QComboBox::drop-down {
                border: none;
                padding-right: 10px;
            }
            QComboBox QAbstractItemView {
                background-color: #333;
                color: white;
                selection-background-color: #4CAF50;
            }
            QStatusBar {
                background-color: #1a1a1a;
                color: #aaa;
                border-top: 1px solid #333;
            }
            QLabel {
                color: #eee;
            }
            QTabWidget::pane {
                border: 1px solid #444;
                background-color: #252525;
                border-radius: 4px;
            }
            QTabBar::tab {
                background-color: #333;
                color: #aaa;
                padding: 8px 16px;
                border-top-left-radius: 4px;
                border-top-right-radius: 4px;
                margin-right: 2px;
            }
            QTabBar::tab:selected {
                background-color: #4CAF50;
                color: white;
            }
            QTabBar::tab:hover:!selected {
                background-color: #444;
                color: white;
            }
            QSlider::groove:horizontal {
                border: 1px solid #444;
                height: 8px;
                background: #333;
                border-radius: 4px;
            }
            QSlider::sub-page:horizontal {
                background: #4CAF50;
                border-radius: 4px;
            }
            QSlider::handle:horizontal {
                background: #fff;
                border: 1px solid #555;
                width: 16px;
                height: 16px;
                border-radius: 8px;
                margin: -4px 0;
            }
            QSpinBox {
                background-color: #333;
                color: white;
                border: 1px solid #555;
                border-radius: 4px;
                padding: 5px;
            }
            QRadioButton {
                color: #eee;
                spacing: 8px;
            }
            QRadioButton::indicator {
                width: 16px;
                height: 16px;
            }
            QCheckBox {
                color: #eee;
                spacing: 8px;
            }
            QCheckBox::indicator {
                width: 16px;
                height: 16px;
            }
            QDialog {
                background-color: #1a1a1a;
            }
        """)
        
        window = MainWindow()
        
        # Setup signal handler for clean shutdown
        def signal_handler(signum, frame):
            logger.info("Received signal %s, shutting down gracefully...", signum)
            window.close()
        
        signal.signal(signal.SIGINT, signal_handler)
        signal.signal(signal.SIGTERM, signal_handler)
        
        window.show()
        
        # Auto-show display selector on first launch
        if not PIL_AVAILABLE:
            QMessageBox.warning(window, "Missing Dependency",
                "The PIL (Pillow) library is not installed.\n\n"
                "Please install it with: pip install Pillow opencv-python\n\n"
                "The application will run with limited functionality.")
        else:
            # Show display selector immediately
            QTimer.singleShot(100, window._show_display_selector)
        
        # Use a timer to allow Python to process signals
        timer = QTimer()
        timer.start(500)
        timer.timeout.connect(lambda: None)
        
        logger.info("[START] PyDisplayWindow Pro started successfully")
        logger.info("[READY] Ultra-high quality capture ready")
        sys.exit(app.exec())
        
    except Exception as e:
        logger.error("Fatal error: %s", e, exc_info=True)
        QMessageBox.critical(None, "Fatal Error",
            f"An unexpected error occurred:\n\n{str(e)}\n\n"
            "Please check the console for more details.")
        sys.exit(1)


if __name__ == "__main__":
    main()