#!/usr/bin/env python3
import os
import sys
import json
import subprocess
import tempfile
import urllib.request
import urllib.error
import time
import mimetypes
import urllib.parse
import re

def normalize_file_path(path_str: str) -> str:
    if not path_str:
        return ""
    path_str = path_str.strip().strip("'\"")
    if path_str.startswith("file://"):
        url = QUrl(path_str)
        if url.isLocalFile():
            path_str = url.toLocalFile()
        else:
            path_str = urllib.parse.unquote(path_str[7:])
    return os.path.abspath(path_str)
from PySide6.QtCore import Qt, QThread, QObject, Signal, QUrl, QFile, QIODevice
from PySide6.QtGui import QIcon, QAction, QPixmap, QPainter, QColor, QFont, QPen, QImage
from PySide6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QHttpMultiPart, QHttpPart, QNetworkReply, QLocalServer, QLocalSocket
from PySide6.QtWidgets import (
    QApplication, QSystemTrayIcon, QMenu, QDialog, QVBoxLayout, QHBoxLayout,
    QLabel, QLineEdit, QComboBox, QCheckBox, QPushButton, QGroupBox,
    QFormLayout, QMessageBox, QFileDialog
)

# Configuration paths
CONFIG_DIR = os.path.expanduser("~/.config/f0ckm-uploader")
CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")

DEFAULT_CONFIG = {
    "api_url": "",
    "api_key": "",
    "default_rating": "",
    "default_visibility": "0",
    "default_tags": "screenshot",
    "default_is_oc": False,
    "enable_notifications": True,
    "show_progress_dialog": True,
    "autostart": False,
    "icon_theme": "dark"
}

def load_config():
    if not os.path.exists(CONFIG_PATH):
        return DEFAULT_CONFIG.copy()
    try:
        with open(CONFIG_PATH, 'r') as f:
            data = json.load(f)
        config = DEFAULT_CONFIG.copy()
        config.update(data)
        return config
    except Exception:
        return DEFAULT_CONFIG.copy()

def get_env_config():
    config = DEFAULT_CONFIG.copy()
    script_dir = os.path.dirname(os.path.abspath(__file__))
    candidates = [
        os.path.join(script_dir, ".env"),
        "/home/kibi/Projects/f0ckm-uploader/.env",
        os.path.expanduser("~/.config/f0ckm-uploader/.env"),
        os.path.join(os.getcwd(), ".env")
    ]
    dotenv_path = None
    for path in candidates:
        if os.path.exists(path):
            dotenv_path = path
            break

    if dotenv_path:
        try:
            with open(dotenv_path, "r") as f:
                for line in f:
                    line = line.strip()
                    if line and not line.startswith("#") and "=" in line:
                        k, v = line.split("=", 1)
                        key = k.strip()
                        val = v.strip().strip("'\"")
                        if key == "F0CKM_URL" and val:
                            url = val if val.endswith("/api/v2/upload") else f"{val.rstrip('/')}/api/v2/upload"
                            config["api_url"] = url
                        elif key == "API_KEY" and val:
                            config["api_key"] = val
                        elif key == "RATING":
                            config["default_rating"] = val
                        elif key == "TAGS":
                            config["default_tags"] = val
                        elif key == "VISIBILITY":
                            config["default_visibility"] = val
                        elif key == "ICON_THEME":
                            config["icon_theme"] = val.lower()
        except Exception as e:
            print(f"Error reading .env from {dotenv_path}: {e}")

    # Override with GUI config.json (User GUI Settings have priority over .env)
    user_cfg = load_config()
    if os.path.exists(CONFIG_PATH):
        for k, v in user_cfg.items():
            config[k] = v

    return config

def save_config(config):
    try:
        os.makedirs(CONFIG_DIR, exist_ok=True)
        with open(CONFIG_PATH, 'w') as f:
            json.dump(config, f, indent=4)
        return True
    except Exception as e:
        print(f"Failed to save config: {e}")
        return False

def set_autostart(enabled):
    autostart_dir = os.path.expanduser("~/.config/autostart")
    autostart_path = os.path.join(autostart_dir, "kde-uploader-gui.desktop")
    
    if enabled:
        try:
            os.makedirs(autostart_dir, exist_ok=True)
            # Use the installed path ~/.local/bin/kde-uploader-gui if possible
            exec_path = os.path.expanduser("~/.local/bin/kde-uploader-gui")
            if not os.path.exists(exec_path):
                exec_path = os.path.abspath(sys.argv[0])
                
            content = f"""[Desktop Entry]
Type=Application
Name=f0ckm Uploader GUI
Comment=System tray GUI and settings for f0ckm Uploader
Exec={exec_path}
Icon=cloud-upload-symbolic
Terminal=false
Categories=Utility;Network;
X-GNOME-Autostart-enabled=true
"""
            with open(autostart_path, "w") as f:
                f.write(content)
            os.chmod(autostart_path, 0o755)
        except Exception as e:
            print(f"Failed to create autostart entry: {e}")
    else:
        if os.path.exists(autostart_path):
            try:
                os.remove(autostart_path)
            except Exception as e:
                print(f"Failed to remove autostart entry: {e}")

# ==========================================
# Connection Tester Worker
# ==========================================
class ConnectionTester(QObject):
    finished = Signal(bool, str) # Success, Message
    
    def __init__(self, url, api_key):
        super().__init__()
        self.url = url
        self.api_key = api_key
        
    def run(self):
        try:
            # Send an empty POST request to test authorization and connection
            req = urllib.request.Request(
                self.url,
                data=b"",
                headers={
                    "X-Api-Key": self.api_key,
                    "User-Agent": "f0ckm-Uploader-GUI/1.0"
                },
                method="POST"
            )
            try:
                with urllib.request.urlopen(req, timeout=5) as response:
                    self.finished.emit(True, "Connection successful! Server responded with HTTP 200.")
            except urllib.error.HTTPError as e:
                body = e.read().decode('utf-8', errors='ignore')
                if e.code == 401:
                    self.finished.emit(False, "Unauthorized: Invalid API Key.")
                elif e.code in (400, 422):
                    # Key is valid but payload is invalid (empty file parameter), which confirms authentication works
                    self.finished.emit(True, "Connection successful! (API key is valid)")
                else:
                    self.finished.emit(False, f"HTTP Error {e.code}: {body or e.reason}")
            except urllib.error.URLError as e:
                self.finished.emit(False, f"Connection failed: {e.reason}")
        except Exception as e:
            self.finished.emit(False, f"Error: {str(e)}")

def get_app_icon() -> QIcon:
    script_dir = os.path.dirname(os.path.abspath(__file__))
    candidates = [
        os.path.join(script_dir, "icon_app.svg"),
        os.path.join(script_dir, "icon_app.png"),
        "/home/kibi/Projects/f0ckm-uploader/icon_app.svg",
        os.path.expanduser("~/.local/bin/icon_app.svg"),
        os.path.expanduser("~/.local/share/icons/hicolor/scalable/apps/f0ckm-uploader.svg"),
        os.path.expanduser("~/.local/share/icons/hicolor/128x128/apps/f0ckm-uploader.png")
    ]
    for c in candidates:
        if os.path.exists(c):
            return QIcon(c)
    return QIcon.fromTheme("f0ckm-uploader")

# ==========================================
# Settings Dialog Window
# ==========================================
class SettingsDialog(QDialog):
    def __init__(self, parent=None, tray_app=None):
        super().__init__(parent)
        self.tray_app = tray_app
        self.setWindowTitle("f0ckm Uploader Settings")
        self.resize(520, 560)
        
        app_icon = get_app_icon()
        if not app_icon.isNull():
            self.setWindowIcon(app_icon)
        
        self.tester_thread = None
        self.tester = None
        
        self.init_ui()
        
    def init_ui(self):
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(20, 20, 20, 20)
        main_layout.setSpacing(15)
        
        # Header
        header_layout = QHBoxLayout()
        header_icon = QLabel()
        icon = QIcon.fromTheme("preferences-system", QIcon.fromTheme("network-server"))
        header_icon.setPixmap(icon.pixmap(32, 32))
        
        header_text_layout = QVBoxLayout()
        header_title = QLabel("f0ckm Uploader")
        header_title.setStyleSheet("font-size: 16px; font-weight: bold;")
        header_subtitle = QLabel("Configure connection settings and default options")
        header_subtitle.setStyleSheet("font-size: 11px; opacity: 0.7;")
        header_text_layout.addWidget(header_title)
        header_text_layout.addWidget(header_subtitle)
        
        header_layout.addWidget(header_icon)
        header_layout.addLayout(header_text_layout)
        header_layout.addStretch()
        main_layout.addLayout(header_layout)
        
        # Section 1: API Connection Settings
        grp_api = QGroupBox("API Connection")
        api_layout = QFormLayout(grp_api)
        api_layout.setContentsMargins(15, 20, 15, 15)
        api_layout.setSpacing(10)
        
        self.txt_url = QLineEdit()
        self.txt_url.setPlaceholderText("https://example.com/api/v2/upload")
        api_layout.addRow("API URL:", self.txt_url)
        
        key_layout = QHBoxLayout()
        self.txt_key = QLineEdit()
        self.txt_key.setEchoMode(QLineEdit.Password)
        self.txt_key.setPlaceholderText("your_api_key_here")
        key_layout.addWidget(self.txt_key)
        
        self.btn_toggle_key = QPushButton("Show")
        self.btn_toggle_key.setFixedWidth(60)
        self.btn_toggle_key.clicked.connect(self.toggle_key_visibility)
        key_layout.addWidget(self.btn_toggle_key)
        api_layout.addRow("API Key:", key_layout)
        
        test_layout = QHBoxLayout()
        test_layout.addStretch()
        self.btn_test = QPushButton("Test Connection")
        self.btn_test.setObjectName("test")
        self.btn_test.clicked.connect(self.on_test_connection)
        test_layout.addWidget(self.btn_test)
        api_layout.addRow("", test_layout)
        
        main_layout.addWidget(grp_api)
        
        # Section 2: Default Parameters
        grp_defaults = QGroupBox("Default Parameters")
        defaults_layout = QFormLayout(grp_defaults)
        defaults_layout.setContentsMargins(15, 20, 15, 15)
        defaults_layout.setSpacing(10)
        
        self.cb_rating = QComboBox()
        self.cb_rating.addItems(["(None / Default)", "SFW", "NSFW", "NSFL"])
        defaults_layout.addRow("Default Rating:", self.cb_rating)
        
        self.cb_visibility = QComboBox()
        self.cb_visibility.addItems(["Public", "Unlisted", "Private"])
        defaults_layout.addRow("Default Visibility:", self.cb_visibility)
        
        self.txt_tags = QLineEdit()
        self.txt_tags.setPlaceholderText("comma-separated tags (e.g., meme, anime)")
        defaults_layout.addRow("Default Tags:", self.txt_tags)
        
        self.chk_oc = QCheckBox("Mark upload as Original Content (is_oc=1)")
        defaults_layout.addRow("", self.chk_oc)
        
        main_layout.addWidget(grp_defaults)
        
        # Section 3: App Behavior
        grp_behavior = QGroupBox("App Behavior")
        behavior_layout = QVBoxLayout(grp_behavior)
        behavior_layout.setContentsMargins(15, 20, 15, 15)
        behavior_layout.setSpacing(10)
        
        self.chk_notifications = QCheckBox("Enable Desktop Notifications")
        self.chk_progress = QCheckBox("Show Live Progress Dialog")
        self.chk_autostart = QCheckBox("Start automatically on system login")
        
        behavior_layout.addWidget(self.chk_notifications)
        behavior_layout.addWidget(self.chk_progress)
        behavior_layout.addWidget(self.chk_autostart)
        
        # Icon Theme Selection
        theme_layout = QHBoxLayout()
        theme_label = QLabel("Tray Icon Theme:")
        self.cb_icon_theme = QComboBox()
        self.cb_icon_theme.addItems(["Dark (Black Sun)", "Light (White Sun)"])
        theme_layout.addWidget(theme_label)
        theme_layout.addWidget(self.cb_icon_theme)
        theme_layout.addStretch()
        behavior_layout.addLayout(theme_layout)
        
        main_layout.addWidget(grp_behavior)
        
        # Save / Cancel Buttons
        btn_layout = QHBoxLayout()
        btn_layout.addStretch()
        
        btn_cancel = QPushButton("Cancel")
        btn_cancel.clicked.connect(self.reject)
        
        self.btn_save = QPushButton("Save Settings")
        self.btn_save.setObjectName("primary")
        self.btn_save.clicked.connect(self.save_settings)
        
        btn_layout.addWidget(btn_cancel)
        btn_layout.addWidget(self.btn_save)
        main_layout.addLayout(btn_layout)
        
        self.load_current_settings()
        
    def toggle_key_visibility(self):
        if self.txt_key.echoMode() == QLineEdit.Password:
            self.txt_key.setEchoMode(QLineEdit.Normal)
            self.btn_toggle_key.setText("Hide")
        else:
            self.txt_key.setEchoMode(QLineEdit.Password)
            self.btn_toggle_key.setText("Show")
            
    def load_current_settings(self):
        config = load_config()
        self.txt_url.setText(config.get("api_url", ""))
        self.txt_key.setText(config.get("api_key", ""))
        
        rating = config.get("default_rating", "").lower()
        rating_map = {"": 0, "s": 1, "sfw": 1, "safe": 1, "q": 2, "nsfw": 2, "questionable": 2, "e": 3, "nsfl": 3, "explicit": 3}
        self.cb_rating.setCurrentIndex(rating_map.get(rating, 0))
        
        vis = str(config.get("default_visibility", "0")).lower()
        vis_map = {"0": 0, "public": 0, "1": 1, "unlisted": 1, "2": 2, "private": 2}
        self.cb_visibility.setCurrentIndex(vis_map.get(vis, 0))
        
        self.txt_tags.setText(config.get("default_tags", ""))
        self.chk_oc.setChecked(config.get("default_is_oc", False))
        self.chk_notifications.setChecked(config.get("enable_notifications", True))
        self.chk_progress.setChecked(config.get("show_progress_dialog", True))
        self.chk_autostart.setChecked(config.get("autostart", False))
        
        icon_theme = config.get("icon_theme", "dark").lower()
        self.cb_icon_theme.setCurrentIndex(1 if icon_theme == "light" else 0)
        
    def on_test_connection(self):
        self.btn_test.setEnabled(False)
        self.btn_test.setText("Testing...")
        
        url = self.txt_url.text().strip()
        key = self.txt_key.text().strip()
        
        self.tester_thread = QThread()
        self.tester = ConnectionTester(url, key)
        self.tester.moveToThread(self.tester_thread)
        
        self.tester_thread.started.connect(self.tester.run)
        self.tester.finished.connect(self.on_test_finished)
        self.tester.finished.connect(self.tester_thread.quit)
        self.tester.finished.connect(self.tester.deleteLater)
        self.tester_thread.finished.connect(self.tester_thread.deleteLater)
        
        self.tester_thread.start()
        
    def on_test_finished(self, success, message):
        self.btn_test.setEnabled(True)
        self.btn_test.setText("Test Connection")
        
        if success:
            QMessageBox.information(self, "Connection Test Success", message)
        else:
            QMessageBox.warning(self, "Connection Test Failed", message)
            
    def save_settings(self):
        config = {
            "api_url": self.txt_url.text().strip(),
            "api_key": self.txt_key.text().strip(),
            "default_rating": ["", "s", "q", "e"][self.cb_rating.currentIndex()],
            "default_visibility": ["0", "1", "2"][self.cb_visibility.currentIndex()],
            "default_tags": self.txt_tags.text().strip(),
            "default_is_oc": self.chk_oc.isChecked(),
            "enable_notifications": self.chk_notifications.isChecked(),
            "show_progress_dialog": self.chk_progress.isChecked(),
            "autostart": self.chk_autostart.isChecked(),
            "icon_theme": "light" if self.cb_icon_theme.currentIndex() == 1 else "dark"
        }
        
        if save_config(config):
            set_autostart(config["autostart"])
            if self.tray_app and hasattr(self.tray_app, "load_tray_icon"):
                self.tray_app.load_tray_icon()
            self.accept()
        else:
            QMessageBox.critical(self, "Error", "Failed to save configuration file.")

# ==========================================
# Dynamic Tray Digit Icon Painter
# ==========================================
def create_digit_icon(percent: int) -> QIcon:
    size = 64
    pixmap = QPixmap(size, size)
    pixmap.fill(Qt.GlobalColor.transparent)

    painter = QPainter(pixmap)
    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
    painter.setRenderHint(QPainter.RenderHint.TextAntialiasing)

    # Sharp-edged solid black badge
    painter.setBrush(QColor(0, 0, 0, 255))
    painter.setPen(QPen(QColor(0, 0, 0), 2))
    painter.drawRect(2, 2, size - 4, size - 4)

    # Crisp white digits (0 - 99)
    val_str = str(min(99, max(0, percent)))
    font_size = 32 if len(val_str) == 1 else 26
    font = QFont("Sans-Serif", font_size, QFont.Weight.Bold)
    painter.setFont(font)
    painter.setPen(QColor(255, 255, 255))
    
    painter.drawText(pixmap.rect(), Qt.AlignmentFlag.AlignCenter, val_str)
    painter.end()

    return QIcon(pixmap)

# ==========================================
# Thumbnail Generator Helper
# ==========================================
def generate_thumbnail(file_path: str) -> str:
    if not file_path or not os.path.exists(file_path):
        return ""
        
    thumb_path = os.path.join(tempfile.gettempdir(), f"f0ckm_thumb_{int(time.time())}.png")
    ext = os.path.splitext(file_path)[1].lower()
    
    # 1. Video files -> Extract thumbnail frame using ffmpeg
    video_exts = {".mp4", ".webm", ".mkv", ".avi", ".mov", ".flv", ".m4v", ".wmv"}
    if ext in video_exts:
        try:
            res = subprocess.run(
                ["ffmpeg", "-y", "-ss", "00:00:01", "-i", file_path, "-vframes", "1",
                 "-vf", "scale=160:80:force_original_aspect_ratio=increase,crop=160:80", thumb_path],
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5
            )
            if res.returncode == 0 and os.path.exists(thumb_path) and os.path.getsize(thumb_path) > 0:
                return thumb_path
        except Exception:
            pass

    # 2. Image files -> Native fast PySide6 scaling
    image_exts = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".avif"}
    if ext in image_exts:
        try:
            img = QImage(file_path)
            if not img.isNull():
                scaled = img.scaled(160, 80, Qt.AspectRatioMode.KeepAspectRatioByExpanding, Qt.TransformationMode.SmoothTransformation)
                x = max(0, (scaled.width() - 160) // 2)
                y = max(0, (scaled.height() - 80) // 2)
                cropped = scaled.copy(x, y, 160, 80)
                if cropped.save(thumb_path, "PNG"):
                    return thumb_path
        except Exception:
            pass

    # 3. Non-image / Non-video -> Create sleek placeholder badge
    try:
        pixmap = QPixmap(160, 80)
        pixmap.fill(QColor(24, 24, 30))
        painter = QPainter(pixmap)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        
        painter.setPen(QPen(QColor(60, 60, 75), 2))
        painter.drawRect(1, 1, 158, 78)
        
        display_ext = ext.replace(".", "").upper()[:5] or "FILE"
        painter.setFont(QFont("Sans-Serif", 16, QFont.Weight.Bold))
        painter.setPen(QColor(220, 220, 240))
        painter.drawText(pixmap.rect(), Qt.AlignmentFlag.AlignCenter, display_ext)
        painter.end()
        
        if pixmap.save(thumb_path, "PNG"):
            return thumb_path
    except Exception:
        pass

    return ""

# ==========================================
# System Tray Application Manager
# ==========================================
class SystemTrayApp(QObject):
    def __init__(self):
        super().__init__()
        self.tray = QSystemTrayIcon()
        
        self.load_tray_icon()
        self.tray.setToolTip("f0ckm Uploader (Click to capture & upload)")
        
        self.network_manager = QNetworkAccessManager(self)
        self.current_reply = None
        
        self.menu = QMenu()
        
        # Header entry
        title_action = QAction("f0ckm Uploader", self.menu)
        title_action.setEnabled(False)
        self.menu.addAction(title_action)
        self.menu.addSeparator()
        
        # Actions
        capture_action = QAction("Capture Region & Upload", self.menu)
        capture_action.triggered.connect(self.on_capture_and_upload)
        self.menu.addAction(capture_action)
        
        upload_action = QAction("Upload File...", self.menu)
        upload_action.triggered.connect(self.on_upload_file)
        self.menu.addAction(upload_action)
        
        clipboard_action = QAction("Upload from Clipboard", self.menu)
        clipboard_action.triggered.connect(self.on_upload_clipboard)
        self.menu.addAction(clipboard_action)
        
        settings_action = QAction("Settings...", self.menu)
        settings_action.triggered.connect(self.on_open_settings)
        self.menu.addAction(settings_action)
        
        self.menu.addSeparator()
        
        quit_action = QAction("Quit", self.menu)
        quit_action.triggered.connect(QApplication.quit)
        self.menu.addAction(quit_action)
        
        self.tray.setContextMenu(self.menu)
        self.tray.activated.connect(self.on_tray_activated)
        
        self.settings_dialog = None
        
    def show(self):
        self.tray.show()
        
    def on_tray_activated(self, reason):
        if reason == QSystemTrayIcon.Trigger:
            # Single click on tray icon starts Spectacle capture & upload
            self.on_capture_and_upload()
        elif reason == QSystemTrayIcon.DoubleClick:
            self.on_open_settings()
            
    def load_tray_icon(self):
        config = get_env_config()
        theme = config.get("icon_theme", "dark").lower()
        filename = "icon_light.svg" if theme == "light" else "icon.svg"
        
        script_dir = os.path.dirname(os.path.abspath(__file__))
        candidates = [
            os.path.join(script_dir, filename),
            f"/home/kibi/Projects/f0ckm-uploader/{filename}",
            os.path.expanduser(f"~/.local/bin/{filename}")
        ]
        icon_path = None
        for c in candidates:
            if os.path.exists(c):
                icon_path = c
                break

        if icon_path:
            self.default_icon = QIcon(icon_path)
        else:
            self.default_icon = QIcon.fromTheme("cloud-upload-symbolic", QIcon.fromTheme("network-server"))
            
        self.tray.setIcon(self.default_icon)

    def on_open_settings(self):
        if not self.settings_dialog:
            self.settings_dialog = SettingsDialog(tray_app=self)
        self.settings_dialog.show()
        self.settings_dialog.raise_()
        self.settings_dialog.activateWindow()

    def on_capture_and_upload(self):
        screenshot_dir = os.path.expanduser("~/Pictures/Screenshots")
        os.makedirs(screenshot_dir, exist_ok=True)
        save_path = os.path.join(screenshot_dir, f"screenshot_{time.strftime('%Y%m%d_%H%M%S')}.png")
        
        try:
            res = subprocess.run(["spectacle", "-r", "-b", "-n", "-o", save_path])
            if os.path.exists(save_path) and os.path.getsize(save_path) > 0:
                self.upload_file_direct(save_path)
        except Exception as e:
            self.show_message("Upload Error", f"Failed to capture screenshot: {e}", QSystemTrayIcon.Critical)

    def upload_file_direct(self, file_path):
        file_path = normalize_file_path(file_path)
        if not file_path or not os.path.exists(file_path):
            self.show_message("Upload Error", f"File not found: {file_path}", QSystemTrayIcon.Critical)
            return

        config = get_env_config()
        api_url = config.get("api_url", "")
        api_key = config.get("api_key", "")
        rating = config.get("default_rating", "")
        tags = config.get("default_tags", "")
        if tags:
            # Format tags as clean comma-separated string ("tag1, tag2") for f0ckm API tagsRaw.split(',') compatibility
            tag_list = [t.strip() for t in re.split(r'[,]+', tags) if t.strip()]
            tags = ", ".join(tag_list)
            
        visibility = str(config.get("default_visibility", "0"))
        is_oc = "1" if config.get("default_is_oc", False) else "0"

        self.tray.setIcon(create_digit_icon(0))
        self.tray.setToolTip("Uploading: 0%")

        request = QNetworkRequest(QUrl(api_url))
        if api_key:
            request.setRawHeader(b"X-Api-Key", api_key.encode("utf-8"))

        multi_part = QHttpMultiPart(QHttpMultiPart.FormDataType)

        file_part = QHttpPart()
        filename = os.path.basename(file_path)
        file_part.setHeader(QNetworkRequest.ContentDispositionHeader, f'form-data; name="file"; filename="{filename}"')
        
        mime_type, _ = mimetypes.guess_type(file_path)
        if not mime_type:
            mime_type = "image/png" if file_path.lower().endswith(".png") else "application/octet-stream"
        file_part.setHeader(QNetworkRequest.ContentTypeHeader, mime_type)

        qfile = QFile(file_path)
        if not qfile.open(QIODevice.ReadOnly):
            self.tray.setIcon(self.default_icon)
            self.show_message("Upload Error", f"Cannot open file: {file_path}", QSystemTrayIcon.Critical)
            return

        file_part.setBodyDevice(qfile)
        qfile.setParent(multi_part)
        multi_part.append(file_part)

        for name, val in [("rating", rating), ("tags", tags), ("visibility", visibility), ("is_oc", is_oc)]:
            if val != "":
                p = QHttpPart()
                p.setHeader(QNetworkRequest.ContentDispositionHeader, f'form-data; name="{name}"')
                p.setBody(str(val).encode("utf-8"))
                multi_part.append(p)

        reply = self.network_manager.post(request, multi_part)
        multi_part.setParent(reply)
        reply.qfile = qfile
        reply.multi_part = multi_part
        self.current_reply = reply

        reply.uploadProgress.connect(self.on_upload_progress)
        reply.finished.connect(lambda: self.on_upload_finished(reply, file_path))

    def on_upload_progress(self, bytes_sent, bytes_total):
        if bytes_total > 0:
            pct = min(100, max(0, int((bytes_sent / bytes_total) * 100)))
            self.tray.setIcon(create_digit_icon(pct))
            self.tray.setToolTip(f"Uploading: {pct}%")

    def on_upload_finished(self, reply, file_path):
        self.tray.setIcon(self.default_icon)
        self.tray.setToolTip("f0ckm Uploader (Click to capture & upload)")

        try:
            err_body = reply.readAll().data().decode("utf-8", errors="ignore")

            if reply.error() == QNetworkReply.NoError:
                try:
                    res = json.loads(err_body)
                    if res.get("success") and res.get("url"):
                        item_url = res.get("url")
                        QApplication.clipboard().setText(item_url)
                        self.show_success_notification(file_path, item_url)
                    else:
                        msg = res.get("msg", "Upload failed")
                        self.show_message("Upload Failed", msg, QSystemTrayIcon.Critical)
                except Exception as e:
                    self.show_message("Upload Error", f"Error parsing response: {e}", QSystemTrayIcon.Critical)
            else:
                server_msg = err_body if err_body else reply.errorString()
                self.show_message("Upload Failed", f"Server Response: {server_msg}", QSystemTrayIcon.Critical)
        except Exception as e:
            self.show_message("Upload Error", f"Unexpected error: {e}", QSystemTrayIcon.Critical)
        finally:
            reply.deleteLater()
            self.current_reply = None

    def show_success_notification(self, file_path, item_url):
        config = get_env_config()
        if not config.get("enable_notifications", True):
            return

        thumb_path = generate_thumbnail(file_path)
        if thumb_path and os.path.exists(thumb_path):
            body_text = f'<div><a href="{item_url}"><img src="file://{thumb_path}" height="80" style="height:80px; max-width:100%; object-fit:cover;" /></a></div><br/><br/><a href="{item_url}">{item_url}</a>'
        else:
            body_text = f'Upload Successful: <a href="{item_url}">{item_url}</a>'

        try:
            subprocess.run(["notify-send", "-a", "f0ckm", "Upload Successful", body_text], check=False)
        except Exception as e:
            print(f"Notification error: {e}")

    def on_upload_file(self):
        file_path, _ = QFileDialog.getOpenFileName(
            None, "Select File to Upload", "", "All Files (*)"
        )
        if file_path:
            self.upload_file_direct(file_path)
            
    def on_upload_clipboard(self):
        clipboard = QApplication.clipboard()
        mime_data = clipboard.mimeData()
        
        if mime_data.hasImage():
            image = clipboard.image()
            temp_dir = tempfile.gettempdir()
            temp_path = os.path.join(temp_dir, f"f0ckm_clipboard_{int(time.time())}.png")
            if image.save(temp_path, "PNG"):
                self.upload_file_direct(temp_path)
            else:
                self.show_message("Upload Error", "Failed to save clipboard image to temporary file.", QSystemTrayIcon.Critical)
        elif mime_data.hasUrls():
            urls = mime_data.urls()
            uploaded_any = False
            for url in urls:
                if url.isLocalFile():
                    path = url.toLocalFile()
                    if os.path.exists(path):
                        self.upload_file_direct(path)
                        uploaded_any = True
            if not uploaded_any:
                self.show_message("Upload Error", "No valid local files in clipboard.", QSystemTrayIcon.Warning)
        elif mime_data.hasText():
            text = mime_data.text().strip()
            lines = [l.strip() for l in text.split('\n') if l.strip()]
            uploaded_any = False
            for line in lines:
                if line.startswith("file://"):
                    line = line[7:]
                if os.path.exists(line):
                    self.upload_file_direct(line)
                    uploaded_any = True
            if not uploaded_any:
                self.show_message("Upload Error", "Clipboard text is not a valid local file path.", QSystemTrayIcon.Warning)
        else:
            self.show_message("Upload Error", "Clipboard does not contain an image or file paths.", QSystemTrayIcon.Warning)
            
    def show_message(self, title, message, icon=QSystemTrayIcon.Information):
        self.tray.showMessage(title, message, icon, 5000)

# ==========================================
# Application Entry Point & IPC
# ==========================================
class SingleInstanceApp:
    def __init__(self, name):
        self.name = name
        self.server = QLocalServer()
        
    def start(self, callback_on_message):
        if not self.server.listen(self.name):
            socket = QLocalSocket()
            socket.connectToServer(self.name)
            if socket.waitForConnected(500):
                msg = "show"
                if len(sys.argv) > 1:
                    arg = sys.argv[1]
                    if arg in ("--spectacle", "-s"):
                        msg = "spectacle"
                    elif arg.startswith("--upload="):
                        msg = f"upload:{arg[9:]}"
                    elif arg.startswith("--upload"):
                        if len(sys.argv) > 2:
                            msg = f"upload:{sys.argv[2]}"
                    else:
                        norm = normalize_file_path(arg)
                        if os.path.exists(norm):
                            msg = f"upload:{norm}"
                socket.write(msg.encode("utf-8"))
                socket.waitForBytesWritten(500)
                socket.disconnectFromServer()
                return False
            else:
                QLocalServer.removeServer(self.name)
                if not self.server.listen(self.name):
                    return False
            
        self.server.newConnection.connect(lambda: self._handle_connection(callback_on_message))
        return True
        
    def _handle_connection(self, callback):
        socket = self.server.nextPendingConnection()
        if socket:
            socket.readyRead.connect(lambda: self._read_message(socket, callback))
            
    def _read_message(self, socket, callback):
        data = socket.readAll().data().decode("utf-8").strip()
        callback(data)
        socket.disconnectFromServer()

def main():
    app = QApplication(sys.argv)
    app.setApplicationName("f0ckm Uploader")
    app.setDesktopFileName("kde-uploader-gui")
    app.setQuitOnLastWindowClosed(False)
    
    app_icon = get_app_icon()
    if not app_icon.isNull():
        app.setWindowIcon(app_icon)
    
    instance_name = "f0ckm-uploader-gui-lock"
    single_instance = SingleInstanceApp(instance_name)
    
    tray_app = None
    
    def on_activate(msg_str):
        nonlocal tray_app
        if tray_app:
            if msg_str == "spectacle":
                tray_app.on_capture_and_upload()
            elif msg_str.startswith("upload:"):
                file_path = normalize_file_path(msg_str[7:])
                if os.path.exists(file_path):
                    tray_app.upload_file_direct(file_path)
                else:
                    tray_app.show_message("Upload Error", f"File not found: {file_path}", QSystemTrayIcon.Critical)
            else:
                tray_app.on_open_settings()
            
    if not single_instance.start(on_activate):
        sys.exit(0)
        
    if not os.path.exists(CONFIG_PATH):
        save_config(DEFAULT_CONFIG)
        
    tray_app = SystemTrayApp()
    tray_app.show()
    
    # Check if started with action argument
    if len(sys.argv) > 1:
        arg = sys.argv[1]
        if arg in ("--spectacle", "-s"):
            tray_app.on_capture_and_upload()
        elif arg.startswith("--upload="):
            file_path = normalize_file_path(arg[9:])
            tray_app.upload_file_direct(file_path)
        elif arg.startswith("--upload"):
            if len(sys.argv) > 2:
                file_path = normalize_file_path(sys.argv[2])
                tray_app.upload_file_direct(file_path)
        else:
            norm = normalize_file_path(arg)
            if os.path.exists(norm):
                tray_app.upload_file_direct(norm)
    
    sys.exit(app.exec())

if __name__ == "__main__":
    main()