import os
import shutil
import subprocess
from pathlib import Path
from typing import Optional

import requests
from PySide6.QtCore import Qt, QThread, Signal
from PySide6.QtGui import QIcon
from PySide6.QtWidgets import (
    QDialog,
    QFileDialog,
    QHBoxLayout,
    QLabel,
    QMessageBox,
    QProgressBar,
    QPushButton,
    QRadioButton,
    QVBoxLayout,
    QWidget,
)

from ..utils.ytsage_logger import logger
from ..utils.ytsage_constants import (
    APP_BIN_DIR,
    ICON_PATH,
    OS_FULL_NAME,
    OS_NAME,
    SUBPROCESS_CREATIONFLAGS,
    YTDLP_APP_BIN_PATH,
    YTDLP_DOWNLOAD_URL,
    YTDLP_SHA256_URL,
)
from .ytsage_ffmpeg import get_file_sha256
from ..utils.ytsage_localization import _

# YTDLP_URLS moved to src\utils\ytsage_constants.py
# get_ytdlp_install_dir() moved to src\utils\ytsage_constants.py
# get_ytdlp_executable_path() moved to src\utils\ytsage_constants.py
# get_os_type() moved to src\utils\ytsage_constants.py
# ensure_install_dir_exists() moved to src\utils\ytsage_constants.py


def verify_ytdlp_sha256(file_path: Path, download_url: str) -> bool:
    """
    Verify yt-dlp file SHA256 hash against official checksums.
    
    Args:
        file_path: Path to the downloaded yt-dlp file
        download_url: The URL used to download the file (to determine the filename)
        
    Returns:
        bool: True if verification successful, False otherwise
    """
    try:
        # Download the SHA2-256SUMS file
        logger.info(f"Downloading SHA256 checksums from: {YTDLP_SHA256_URL}")
        response = requests.get(YTDLP_SHA256_URL, timeout=10)
        response.raise_for_status()
        checksum_content = response.text
        
        # Extract filename from download URL (e.g., yt-dlp.exe, yt-dlp_macos, yt-dlp)
        filename = download_url.split("/")[-1]
        logger.info(f"Looking for checksum for file: {filename}")
        
        # Parse the checksum file to find the matching hash
        expected_hash = None
        for line in checksum_content.strip().split("\n"):
            if filename in line:
                # Format: "hash  filename"
                parts = line.strip().split()
                if len(parts) >= 2 and parts[1] == filename:
                    expected_hash = parts[0]
                    break
        
        if not expected_hash:
            logger.error(f"Could not find SHA256 hash for {filename} in checksums file")
            return False
        
        # Calculate actual hash of downloaded file
        logger.info("Calculating SHA256 hash of downloaded file...")
        actual_hash = get_file_sha256(file_path)
        
        # Compare hashes
        if actual_hash.lower() == expected_hash.lower():
            logger.info("✓ SHA256 verification successful!")
            logger.info(f"  Expected: {expected_hash}")
            logger.info(f"  Actual:   {actual_hash}")
            return True
        else:
            logger.error("✗ SHA256 verification failed!")
            logger.error(f"  Expected: {expected_hash}")
            logger.error(f"  Actual:   {actual_hash}")
            return False
            
    except requests.RequestException as e:
        logger.error(f"Failed to download SHA256 checksums: {e}")
        return False
    except Exception as e:
        logger.exception(f"Error during SHA256 verification: {e}")
        return False


class DownloadYtdlpThread(QThread):
    progress_signal = Signal(int)
    finished_signal = Signal(bool, str)

    def __init__(self):
        super().__init__()

    def run(self) -> None:
        try:
            # Extra logic moved to src\utils\ytsage_constants.py
            exe_path = YTDLP_APP_BIN_PATH

            # Download with progress reporting
            logger.info(f"Downloading yt-dlp from: {YTDLP_DOWNLOAD_URL}")
            response = requests.get(YTDLP_DOWNLOAD_URL, stream=True)
            response.raise_for_status()
            total_size = int(response.headers.get("content-length", 0))
            block_size = 1024  # 1 Kibibyte

            if total_size == 0:
                self.progress_signal.emit(100)

            with open(exe_path, "wb") as f:
                downloaded = 0
                for data in response.iter_content(block_size):
                    f.write(data)
                    downloaded += len(data)
                    if total_size > 0:
                        progress = int(downloaded / total_size * 100)
                        self.progress_signal.emit(progress)

            logger.info("Download complete, verifying SHA256 hash...")
            
            # Verify SHA256 hash
            if not verify_ytdlp_sha256(exe_path, YTDLP_DOWNLOAD_URL):
                # Hash verification failed - delete the downloaded file
                logger.error("SHA256 verification failed! Removing downloaded file.")
                if Path(exe_path).exists():
                    Path(exe_path).unlink()
                self.finished_signal.emit(
                    False, 
                    "SHA256 verification failed. The downloaded file may be corrupted or tampered with."
                )
                return

            # Make executable on macOS and Linux
            if OS_NAME != "Windows":
                os.chmod(exe_path, 0o755)

            logger.info("yt-dlp downloaded and verified successfully!")
            self.finished_signal.emit(True, str(exe_path))

        except Exception as e:
            logger.exception(f"Error downloading yt-dlp: {e}")
            self.finished_signal.emit(False, str(e))


class YtdlpSetupDialog(QDialog):
    setup_complete = Signal(str)  # Signal emitting the path to yt-dlp

    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle(_("ytdlp_setup.required_title"))
        self.setMinimumWidth(520)
        self.setMinimumHeight(350)
        self.resize(520, 380)

        # Set the window icon to match the main app
        if parent and parent.windowIcon():
            self.setWindowIcon(parent.windowIcon())
        else:
            # icon_path logic moved to src\utils\ytsage_constants.py
            icon_path = ICON_PATH
            if Path.exists(icon_path):
                self.setWindowIcon(QIcon(str(icon_path)))

        self.init_ui()

        # Apply dark theme styling to match app
        self.setStyleSheet(
            """
            QDialog {
                background-color: #15181b;
                color: #ffffff;
            }
            QLabel {
                color: #cccccc;
                line-height: 1.4;
            }
            QPushButton {
                padding: 10px 20px;
                background-color: #c90000;
                border: none;
                border-radius: 6px;
                color: white;
                font-weight: bold;
                font-size: 13px;
                min-width: 120px;
                min-height: 20px;
            }
            QPushButton:hover {
                background-color: #a50000;
            }
            QPushButton:pressed {
                background-color: #800000;
            }
            QPushButton:disabled {
                background-color: #666666;
                color: #999999;
            }
            QProgressBar {
                border: 2px solid #1d1e22;
                border-radius: 6px;
                text-align: center;
                color: white;
                background-color: #1d1e22;
                height: 25px;
                font-weight: bold;
            }
            QProgressBar::chunk {
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
                    stop: 0 #e60000, stop: 0.5 #ff3333, stop: 1 #c90000);
                border-radius: 4px;
                margin: 1px;
            }
            QRadioButton {
                color: #ffffff;
                spacing: 10px;
                padding: 8px;
                font-size: 13px;
            }
            QRadioButton::indicator {
                width: 18px;
                height: 18px;
                border-radius: 9px;
            }
            QRadioButton::indicator:unchecked {
                border: 2px solid #666666;
                background: #1d1e22;
            }
            QRadioButton::indicator:checked {
                border: 2px solid #c90000;
                background: #c90000;
            }
        """
        )

    def init_ui(self) -> None:
        layout = QVBoxLayout()
        layout.setSpacing(15)
        layout.setContentsMargins(25, 25, 25, 25)

        # Header title
        title_label = QLabel(_("ytdlp_setup.required_title"))
        title_label.setStyleSheet("font-size: 16px; font-weight: bold; color: #ffffff; padding: 5px 0;")
        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(title_label)

        # Information label with improved styling
        # os_name logic moved to src\utils\ytsage_constants.py

        info_label = QLabel(
            _("ytdlp_setup.description", os_name=OS_FULL_NAME)
        )
        info_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        info_label.setWordWrap(True)
        info_label.setStyleSheet("font-size: 13px; color: #cccccc; padding: 5px; line-height: 1.4;")
        layout.addWidget(info_label)

        # Radio buttons with minimal spacing
        option_widget = QWidget()
        option_layout = QVBoxLayout(option_widget)
        option_layout.setSpacing(8)
        option_layout.setContentsMargins(0, 0, 0, 0)

        self.auto_radio = QRadioButton(_("ytdlp_setup.option_auto"))
        self.auto_radio.setChecked(True)
        self.manual_radio = QRadioButton(_("ytdlp_setup.option_manual"))

        option_layout.addWidget(self.auto_radio)
        option_layout.addWidget(self.manual_radio)
        layout.addWidget(option_widget)

        # Progress bar with proper sizing
        self.progress_bar = QProgressBar()
        self.progress_bar.setVisible(False)
        self.progress_bar.setFixedHeight(20)  # Fixed height for consistency
        self.progress_bar.setStyleSheet(
            """
            QProgressBar {
                border: 1px solid #3d3d3d;
                border-radius: 8px;
                background-color: #1d1e22;
                text-align: center;
                color: #ffffff;
                font-size: 12px;
                font-weight: bold;
                height: 20px;
            }
            QProgressBar::chunk {
                background-color: #c90000;
                border-radius: 6px;
                margin: 1px;
            }
        """
        )
        layout.addWidget(self.progress_bar)

        # Status label with better spacing
        self.status_label = QLabel("")
        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.status_label.setStyleSheet("font-size: 12px; color: #cccccc; padding: 8px 0;")
        self.status_label.setWordWrap(True)
        layout.addWidget(self.status_label)

        # Add stretch to push buttons to bottom
        layout.addStretch()

        # Button layout with improved spacing
        button_layout = QHBoxLayout()
        button_layout.setSpacing(15)
        button_layout.setContentsMargins(0, 10, 0, 0)  # Add top margin for buttons

        self.setup_button = QPushButton(_("ytdlp_setup.setup_button"))
        self.setup_button.clicked.connect(self.setup_ytdlp)

        self.cancel_button = QPushButton(_("buttons.cancel"))
        self.cancel_button.clicked.connect(self.reject)

        button_layout.addWidget(self.setup_button)
        button_layout.addWidget(self.cancel_button)
        layout.addLayout(button_layout)

        self.setLayout(layout)

    def setup_ytdlp(self) -> None:
        if self.auto_radio.isChecked():
            self.download_ytdlp()
        else:
            self.select_ytdlp_path()

    def download_ytdlp(self) -> None:
        self.progress_bar.setVisible(True)
        self.progress_bar.setValue(0)
        self.status_label.setText(_("ytdlp_setup.downloading"))
        self.setup_button.setEnabled(False)
        self.cancel_button.setEnabled(False)

        self.download_thread = DownloadYtdlpThread()
        self.download_thread.progress_signal.connect(self.update_progress)
        self.download_thread.finished_signal.connect(self.download_finished)
        self.download_thread.start()

    def update_progress(self, value) -> None:
        self.progress_bar.setValue(value)

    def download_finished(self, success, result) -> None:
        self.setup_button.setEnabled(True)
        self.cancel_button.setEnabled(True)

        if success:
            self.status_label.setText(_("ytdlp_setup.success"))
            self.setup_complete.emit(result)
            self.accept()
        else:
            self.status_label.setText(_("ytdlp_setup.error", error=result))
            error_dialog = QMessageBox(self)
            error_dialog.setIcon(QMessageBox.Icon.Critical)
            error_dialog.setWindowTitle(_("ytdlp_setup.download_failed_title"))
            error_dialog.setText(_("ytdlp_setup.download_failed_message", error=result))
            # Set the window icon to match the main dialog
            error_dialog.setWindowIcon(self.windowIcon())
            error_dialog.setStyleSheet(
                """
                QMessageBox {
                    background-color: #15181b;
                    color: #ffffff;
                }
                QLabel {
                    color: #ffffff;
                }
                QPushButton {
                    padding: 8px 15px;
                    background-color: #c90000;
                    border: none;
                    border-radius: 4px;
                    color: white;
                    font-weight: bold;
                }
                QPushButton:hover {
                    background-color: #a50000;
                }
            """
            )
            error_dialog.exec()

    def select_ytdlp_path(self) -> None:
        if OS_NAME == "Windows":
            file_filter = _("ytdlp_setup.file_filter_windows")
        else:
            file_filter = _("ytdlp_setup.file_filter_all")

        # Apply style to QFileDialog
        file_dialog = QFileDialog(self)
        file_dialog.setStyleSheet(
            """
            QFileDialog {
                background-color: #15181b;
                color: #ffffff;
            }
            QLabel, QCheckBox, QListView, QTreeView, QComboBox, QLineEdit {
                color: #ffffff;
                background-color: #1b2021;
            }
            QPushButton {
                padding: 8px 15px;
                background-color: #c90000;
                border: none;
                border-radius: 4px;
                color: white;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #a50000;
            }
        """
        )

        file_path, _ = file_dialog.getOpenFileName(
            self, _("ytdlp_setup.select_executable_title"), "", file_filter
        )

        if file_path:
            logger.debug(f"User selected file: {file_path}")
            # Verify the selected file
            try:
                # Extra logic moved to src\utils\ytsage_constants.py
                # Try to run yt-dlp --version
                logger.debug(f"Verifying file with --version command")
                result = subprocess.run(
                    [file_path, "--version"], capture_output=True, text=True, check=False, creationflags=SUBPROCESS_CREATIONFLAGS
                )
                logger.debug(f"Version check result: {result.returncode}, Output: {result.stdout.strip()}")

                if result.returncode == 0:
                    # File is valid, copy it to our app's bin directory
                    try:
                        # Ensure the bin directory exists
                        logger.debug(f"Install directory: {APP_BIN_DIR}")

                        # Determine the target filename based on OS
                        target_path = YTDLP_APP_BIN_PATH
                        logger.debug(f"Target path: {target_path}")

                        # Copy the file
                        shutil.copy2(file_path, target_path)
                        logger.debug(f"File copied successfully")

                        # Set executable permissions on Unix systems
                        if OS_NAME != "Windows":
                            os.chmod(target_path, 0o755)
                            logger.debug(f"Permissions set on Unix system")

                        # Return the path of the copied file
                        self.status_label.setText(_("ytdlp_setup.copied_to", path=target_path))
                        logger.debug(f"Emitting setup_complete signal with path: {target_path}")
                        self.setup_complete.emit(target_path)
                        self.accept()
                    except Exception as copy_error:
                        logger.debug(f"Error copying file: {copy_error}", exc_info=True)
                        error_dialog = QMessageBox(self)
                        error_dialog.setIcon(QMessageBox.Icon.Critical)
                        error_dialog.setWindowTitle(_("ytdlp_setup.setup_error_title"))
                        error_dialog.setText(_("ytdlp_setup.copy_error", error=copy_error))
                        error_dialog.setStyleSheet(
                            """
                            QMessageBox {
                                background-color: #15181b;
                                color: #ffffff;
                            }
                            QLabel {
                                color: #ffffff;
                            }
                            QPushButton {
                                padding: 8px 15px;
                                background-color: #c90000;
                                border: none;
                                border-radius: 4px;
                                color: white;
                                font-weight: bold;
                            }
                            QPushButton:hover {
                                background-color: #a50000;
                            }
                        """
                        )
                        error_dialog.exec()
                else:
                    logger.debug(f"File verification failed with return code: {result.returncode}")
                    error_dialog = QMessageBox(self)
                    error_dialog.setIcon(QMessageBox.Icon.Warning)
                    error_dialog.setWindowTitle(_("ytdlp_setup.invalid_executable_title"))
                    error_dialog.setText(_("ytdlp_setup.invalid_executable_message"))
                    error_dialog.setStyleSheet(
                        """
                        QMessageBox {
                            background-color: #15181b;
                            color: #ffffff;
                        }
                        QLabel {
                            color: #ffffff;
                        }
                        QPushButton {
                            padding: 8px 15px;
                            background-color: #c90000;
                            border: none;
                            border-radius: 4px;
                            color: white;
                            font-weight: bold;
                        }
                        QPushButton:hover {
                            background-color: #a50000;
                        }
                    """
                    )
                    error_dialog.exec()
            except Exception as e:
                logger.debug(f"Exception during verification: {e}", exc_info=True)
                error_dialog = QMessageBox(self)
                error_dialog.setIcon(QMessageBox.Icon.Critical)
                error_dialog.setWindowTitle(_("main_ui.error_title"))
                error_dialog.setText(_("ytdlp_setup.verify_error", error=e))
                error_dialog.setStyleSheet(
                    """
                    QMessageBox {
                        background-color: #15181b;
                        color: #ffffff;
                    }
                    QLabel {
                        color: #ffffff;
                    }
                    QPushButton {
                        padding: 8px 15px;
                        background-color: #c90000;
                        border: none;
                        border-radius: 4px;
                        color: white;
                        font-weight: bold;
                    }
                    QPushButton:hover {
                        background-color: #a50000;
                    }
                """
                )
                error_dialog.exec()


def check_ytdlp_binary() -> Optional[Path]:
    """
    Check if yt-dlp binary exists in the app's bin directory ONLY.
    We now ignore system PATH and only use our managed binary.
    Returns:
        Path or None: Path to yt-dlp binary if found in app bin, None otherwise
    """
    exe_path = YTDLP_APP_BIN_PATH
    if exe_path.exists():
        # Make sure it's executable on Unix systems
        if OS_NAME != "Windows" and not os.access(exe_path, os.X_OK):
            try:
                os.chmod(exe_path, 0o755)
                logger.info(f"Fixed permissions on yt-dlp at {exe_path}")
            except Exception as e:
                logger.exception(f"Could not set executable permissions on {exe_path}: {e}")
        logger.info(f"Found yt-dlp in app bin directory: {exe_path}")
        return exe_path

    # Binary not found in app directory - return None to trigger setup
    logger.warning(f"yt-dlp binary not found in app bin directory: {exe_path}")
    return None


def check_ytdlp_installed() -> bool:
    """
    Check if yt-dlp is installed and accessible.
    Returns:
        bool: True if yt-dlp is found and working, False otherwise
    """
    try:
        ytdlp_path = check_ytdlp_binary()
        if ytdlp_path:
            # Try to run yt-dlp --version to verify it's working
            try:
                # Extra logic moved to src\utils\ytsage_constants.py
                result = subprocess.run(
                    [ytdlp_path, "--version"], capture_output=True, text=True, timeout=5, creationflags=SUBPROCESS_CREATIONFLAGS
                )
                return result.returncode == 0
            except Exception:
                return False
        return False
    except Exception:
        return False


def get_yt_dlp_path() -> Path:
    """
    Get the yt-dlp path, either from the app's bin directory or system PATH.
    This replaces the function in ytsage_utils.py.
    Returns:
        str: Path to yt-dlp binary
    """
    # First check if we have yt-dlp in our app's bin directory or system PATH
    ytdlp_path = check_ytdlp_binary()
    if ytdlp_path:
        logger.info(f"Using yt-dlp from: {ytdlp_path}")
        return ytdlp_path

    # If not found anywhere, fall back to the command name as a last resort
    logger.info("yt-dlp not found in app directory or PATH, falling back to command name")
    return "yt-dlp"  # type: ignore[return-value]


def setup_ytdlp(parent_widget=None):
    """
    Show the yt-dlp setup dialog and handle the result.
    Returns:
        str: Path to yt-dlp binary
    """
    logger.debug("Starting yt-dlp setup dialog")
    dialog = YtdlpSetupDialog(parent_widget)

    # Store the setup result from the signal
    setup_result = {"path": None}

    def on_setup_complete(path) -> None:
        logger.debug(f"Received setup_complete signal with path: {path}")
        setup_result["path"] = path

    # Connect to the setup_complete signal
    dialog.setup_complete.connect(on_setup_complete)

    # Show the dialog
    result = dialog.exec()
    logger.debug(f"Dialog result: {result} (Accepted={QDialog.DialogCode.Accepted})")

    if result == QDialog.DialogCode.Accepted:
        # First check if we received a path from the signal
        if setup_result["path"]:
            path_obj = Path(setup_result["path"]) if isinstance(setup_result["path"], str) else setup_result["path"]
            if path_obj.exists():
                logger.debug(f"Using path from signal: {setup_result['path']}")
                return str(setup_result["path"])

        # Get the expected path for verification as fallback
        expected_path = YTDLP_APP_BIN_PATH
        logger.debug(f"Expected yt-dlp path: {expected_path}")

        # Verify the path exists after dialog is accepted
        if expected_path.exists():
            logger.debug(f"yt-dlp successfully found at expected path: {expected_path}")
            return str(expected_path)
        else:
            logger.debug(f"Expected path does not exist, trying alternate detection")
            # Try to use the get_yt_dlp_path function to find yt-dlp elsewhere
            yt_dlp_path = get_yt_dlp_path()
            logger.debug(f"Alternate detection result: {yt_dlp_path}")
            if yt_dlp_path != "yt-dlp":
                path_obj = Path(yt_dlp_path) if isinstance(yt_dlp_path, str) else yt_dlp_path
                if path_obj.exists():
                    logger.debug(f"yt-dlp found at alternate location: {yt_dlp_path}")
                    return str(yt_dlp_path)

            # Something went wrong, show an error message
            logger.debug(f"Setup failed, showing error dialog")
            if parent_widget:
                error_dialog = QMessageBox(parent_widget)
                error_dialog.setIcon(QMessageBox.Icon.Warning)
                error_dialog.setWindowTitle(_("ytdlp_setup.setup_failed_title"))
                error_dialog.setText(_("ytdlp_setup.setup_failed_message"))
                # Set the window icon to match the parent
                error_dialog.setWindowIcon(parent_widget.windowIcon())
                error_dialog.setStyleSheet(
                    """
                    QMessageBox {
                        background-color: #15181b;
                        color: #ffffff;
                    }
                    QLabel {
                        color: #ffffff;
                    }
                    QPushButton {
                        padding: 8px 15px;
                        background-color: #c90000;
                        border: none;
                        border-radius: 4px;
                        color: white;
                        font-weight: bold;
                    }
                    QPushButton:hover {
                        background-color: #a50000;
                    }
                """
                )
                error_dialog.exec()
            logger.warning(f"yt-dlp setup failed, path does not exist: {expected_path}")
    else:
        logger.debug("User cancelled the setup dialog")

    # User cancelled or setup failed, return the fallback command
    logger.debug("Returning fallback command 'yt-dlp'")
    return "yt-dlp"


def check_ytdlp_deno_integration() -> bool:
    """
    Check if yt-dlp is integrated with Deno by running 'yt-dlp --verbose'.
    Returns:
        bool: True if Deno is detected in JS runtimes, False otherwise
    """
    try:
        ytdlp_path = get_yt_dlp_path()
        if not ytdlp_path or ytdlp_path == "yt-dlp":
            return False

        # Run yt-dlp --verbose to check JS runtimes
        # We use a dummy URL or just --verbose with no URL (which might error but should print debug info)
        # However, yt-dlp might not print debug info if no URL is provided and it errors out immediately with "usage".
        # But per user example: "yt-dlp.exe: error: You must provide at least one URL." comes AFTER debug info.
        
        result = subprocess.run(
            [str(ytdlp_path), "--verbose"],
            capture_output=True,
            text=True,
            timeout=10,
            creationflags=SUBPROCESS_CREATIONFLAGS
        )
        
        # Check stderr for "[debug] JS runtimes: deno"
        output = result.stderr
        if "[debug] JS runtimes:" in output and "deno" in output:
             # Find the line
            for line in output.splitlines():
                if "[debug] JS runtimes:" in line and "deno" in line:
                    logger.info(f"Deno integration detected: {line.strip()}")
                    return True
        
        return False
            
    except Exception as e:
        logger.warning(f"Failed to check yt-dlp Deno integration: {e}")
        return False