main.py

from __future__ import annotations

import json
import os
import re
import shutil
import struct
import sys
import traceback
import uuid
from pathlib import Path
from urllib.parse import quote, unquote, urlparse

if sys.platform.startswith("linux") and os.environ.get("WAYLAND_DISPLAY") and not os.environ.get("QT_QPA_PLATFORM"):
	os.environ["QT_QPA_PLATFORM"] = "xcb"

from dotenv import load_dotenv
from PyQt6 import QtCore, QtGui, QtWebSockets, QtWidgets
import requests
import vlc
import whisper

load_dotenv()
OS_API = "https://api.opensubtitles.com/api/v1"
OS_KEY = os.environ["OPENSUBTITLES_API_KEY"]
OS_USER = os.environ["OPENSUBTITLES_USERNAME"]
OS_PASS = os.environ["OPENSUBTITLES_PASSWORD"]
LANG_MAP = {
	"eng": "en",
	"tur": "tr",
	"fra": "fr",
	"deu": "de",
	"nld": "nl",
	"spa": "es",
	"ita": "it",
	"por": "pt",
	"zho": "zh",
	"jpn": "ja",
	"kor": "ko",
	"rus": "ru",
	"hin": "hi",
	"ara": "ar",
}
WHISPER_LANG_MAP = {
	"eng": "english",
	"tur": "turkish",
	"rus": "russian",
	"fra": "french",
	"spa": "spanish",
	"ita": "italian",
	"deu": "german",
	"nld": "dutch",
	"zho": "chinese",
	"jpn": "japanese",
	"hin": "hindi",
	"ara": "arabic",
	"por": "portuguese",
}

def is_linux():
	return sys.platform.startswith("linux")


def base_font_family():
	if sys.platform == "darwin":
		return "'SF Pro Text','Inter','Avenir Next','Helvetica Neue',sans-serif"
	if is_linux():
		return "'Noto Sans','Inter','Ubuntu','Cantarell','DejaVu Sans',sans-serif"
	return "'Segoe UI','Inter','Helvetica Neue',sans-serif"


def build_style():
	radius = 14 if is_linux() else 18
	video_radius = 16 if is_linux() else 22
	control_padding = "8px 12px" if is_linux() else "9px 14px"
	item_padding = "8px 10px" if is_linux() else "10px 12px"
	input_padding = "7px 9px" if is_linux() else "8px 10px"
	return (
		f"QWidget{{font-family:'Manrope','Avenir Next','Helvetica Neue',sans-serif;font-size:13px;color:#DCE6F8;"
		"selection-background-color:#0074FB;selection-color:#F7FAFF}"
		"QMainWindow{background:#09111F}"
		f"QFrame#sidebarCard,QFrame#playlistFrame,QFrame#syncFrame,QFrame#controlCard,QFrame#progressCard,QFrame#headerCard{{"
		f"background:#0F1A2E;border:1px solid #183152;border-radius:{radius}px}}"
		f"QFrame#videoFrame{{background:#050A12;border:1px solid #183152;border-radius:{video_radius}px}}"
		f"QPushButton{{background:#0074FB;color:#F8FBFF;border:none;border-radius:10px;padding:{control_padding};font-weight:700}}"
		"QPushButton:hover{background:#1982FC}"
		"QPushButton:pressed{background:#005FCC}"
		"QPushButton:disabled{background:#23344F;color:#7D92B0}"
		"QPushButton#secondaryButton{background:#16243A;color:#DCE6F8;border:1px solid #28476F}"
		"QPushButton#secondaryButton:hover{background:#1A3152}"
		"QPushButton#dangerButton{background:#3A1F1F;color:#FFE3E3;border:1px solid #7C3A3A}"
		"QPushButton#dangerButton:hover{background:#5A2B2B}"
		"QLabel{font-size:12px;color:#C8D5EA}"
		"QLabel#titleLabel{font-size:16px;font-weight:800;color:#F9FBFF}"
		"QLabel#sectionLabel{font-size:11px;font-weight:800;letter-spacing:0.08em;text-transform:uppercase;color:#8EA9CC}"
		"QLabel#mutedLabel{color:#8EA9CC}"
		"QLabel#statusLabel{color:#EFF5FF;font-weight:600}"
		"QLabel#badgeLabel{background:#14233A;color:#FBF700;border:1px solid #35598A;border-radius:999px;padding:4px 10px;font-weight:800}"
		"QSlider::groove:horizontal{height:8px;background:#223753;border-radius:4px}"
		"QSlider::handle:horizontal{background:#FBF700;width:16px;height:16px;margin:-5px 0;border-radius:8px}"
		"QSlider::sub-page:horizontal{background:#0074FB;border-radius:4px}"
		"QSlider::add-page:horizontal{background:#314966;border-radius:4px}"
		f"QListWidget{{background:#0A1322;border:1px solid #1B3557;border-radius:{max(radius - 4, 10)}px;outline:none;padding:6px}}"
		f"QListWidget::item{{padding:{item_padding};border-radius:10px;color:#DCE6F8}}"
		"QListWidget::item:selected{background:#0074FB;color:#F8FBFF}"
		"QListWidget::item:hover{background:#162640}"
		f"QLineEdit,QComboBox{{background:#0A1322;border:1px solid #2B466B;border-radius:10px;padding:{input_padding};color:#F8FBFF}}"
		"QLineEdit:focus,QComboBox:focus{border:1px solid #0074FB}"
		"QTabWidget::pane{border:none;background:transparent}"
		"QTabBar::tab{background:#0A1322;color:#8EA9CC;border:1px solid #203B60;padding:8px 12px;border-top-left-radius:10px;border-top-right-radius:10px;margin-right:6px}"
		"QTabBar::tab:selected{background:#16243A;color:#F8FBFF;border-color:#0074FB}"
		"QScrollBar:vertical{background:#0A1322;width:12px;margin:4px 0 4px 0;border-radius:6px}"
		"QScrollBar::handle:vertical{background:#28476F;min-height:28px;border-radius:6px}"
		"QScrollBar::handle:vertical:hover{background:#0074FB}"
		"QScrollBar::add-line:vertical,QScrollBar::sub-line:vertical{height:0px}"
	)


def build_video_style():
	video_radius = 16 if is_linux() else 22
	return (
		f"QFrame{{background:qlineargradient(x1:0,y1:0,x2:1,y2:1,stop:0 #040912,stop:0.72 #09111F,stop:1 #0F1A2E);"
		f"border:1px solid #183152;border-radius:{video_radius}px}}"
	)


STYLE = build_style()
VIDEO_STYLE = build_video_style()


def clean_title(stem):
	"""Extract movie/show title from release filename."""
	name = re.split(
		r"[\[\(]|\b(19|20)\d{2}\b|\b(720|1080|2160|480)[pPiI]\b|\bWEB|\bBlu[Rr]ay|\bBRRip|\bHDRip|\bWEBRip|\bHDTS|\bx26[45]|\bHEVC|\bAAC|\bH\.?264|\bH\.?265",
		stem,
	)[0]
	return re.sub(r"[._]", " ", name).strip()


def os_hash(path):
	"""OpenSubtitles hash: sum of first+last 64KB as uint64 words + filesize."""
	bs = 64 * 1024
	sz = path.stat().st_size
	if sz < bs * 2:
		return None
	h = sz
	with open(path, "rb") as f:
		for _ in range(bs // 8):
			h += struct.unpack("<Q", f.read(8))[0]
		f.seek(-bs, 2)
		for _ in range(bs // 8):
			h += struct.unpack("<Q", f.read(8))[0]
	return f"{h & 0xFFFFFFFFFFFFFFFF:016x}"


def fmt(ms):
	s = max(0, ms // 1000)
	return f"{s // 60}:{s % 60:02d}"


def srt_ts(sec):
	h, r = divmod(sec, 3600)
	m, s = divmod(r, 60)
	return f"{int(h):02d}:{int(m):02d}:{int(s):02d},{int((sec % 1) * 1000):03d}"


def media_signature(path: Path):
	try:
		size = path.stat().st_size
	except OSError:
		size = 0
	title = clean_title(path.stem).lower()
	return f"{title}|{size}"


def media_identity(path: Path):
	return {
		"name": path.name,
		"stem": clean_title(path.stem).lower(),
		"signature": media_signature(path),
	}


def chat_timestamp():
	return QtCore.QDateTime.currentDateTime().toString("HH:mm")


class SubtitleWorker(QtCore.QObject):
	finished = QtCore.pyqtSignal(str, object)
	errored = QtCore.pyqtSignal(str)
	progress = QtCore.pyqtSignal(str)

	def __init__(self, path: Path, lang: str = "eng"):
		super().__init__()
		self.path, self.lang = path, lang

	def _log(self, msg):
		print(f"[Sub] {msg}", flush=True)
		self.progress.emit(msg)

	@QtCore.pyqtSlot()
	def run(self):
		try:
			self.progress.emit("Searching OpenSubtitles...")
			result = self._try_opensubtitles()
			if not result:
				self.progress.emit("Providers failed, trying Whisper...")
				result = self._whisper()
			self.finished.emit(f"Subtitles: {result.name}", result)
		except Exception as e:
			traceback.print_exc()
			self.errored.emit(str(e))

	def _try_opensubtitles(self):
		hdr = {"Api-Key": OS_KEY, "User-Agent": "AutoSub v0.1"}
		lang2 = LANG_MAP.get(self.lang, self.lang[:2])
		try:
			data = []
			fhash = os_hash(self.path)
			if fhash:
				self._log(f"Hash search: {fhash} [{lang2}]")
				r = requests.get(
					f"{OS_API}/subtitles",
					headers=hdr,
					params={"moviehash": fhash, "languages": lang2},
					timeout=15,
				)
				if r.status_code == 200:
					data = r.json().get("data", [])
				if data:
					self._log(f"Hash matched {len(data)} subtitle(s)")
			if not data:
				title = clean_title(self.path.stem)
				self._log(f"Text search: '{title}' [{lang2}]")
				r = requests.get(
					f"{OS_API}/subtitles",
					headers=hdr,
					params={"query": title, "languages": lang2},
					timeout=15,
				)
				if r.status_code != 200:
					self._log(f"Search error: {r.status_code}")
					return None
				data = r.json().get("data", [])
			if not data:
				self._log("No results")
				return None
			self._log(f"Found {len(data)} subtitle(s)")
			fid = next(
				(
					f["file_id"]
					for e in data
					for f in e.get("attributes", {}).get("files", [])
					if "file_id" in f
				),
				None,
			)
			if not fid:
				return None
			self._log(f"Logging in as {OS_USER}...")
			lr = requests.post(
				f"{OS_API}/login",
				headers={**hdr, "Content-Type": "application/json"},
				json={"username": OS_USER, "password": OS_PASS},
				timeout=15,
			)
			tok = lr.json().get("token") if lr.status_code == 200 else None
			dl_h = {**hdr, "Content-Type": "application/json"}
			if tok:
				dl_h["Authorization"] = f"Bearer {tok}"
			dr = requests.post(
				f"{OS_API}/download",
				headers=dl_h,
				json={"file_id": fid},
				timeout=15,
			)
			if dr.status_code != 200:
				self._log(f"Download error: {dr.status_code} {dr.text[:200]}")
				if dr.status_code == 406:
					self.progress.emit(
						f"Quota exhausted, resets in {dr.json().get('reset_time', '?')}"
					)
				return None
			link = dr.json().get("link")
			if not link:
				return None
			self.progress.emit("Downloading subtitle file...")
			fr = requests.get(link, timeout=30)
			if fr.status_code != 200:
				return None
			out = self.path.with_suffix(f".{self.lang}.srt")
			out.write_bytes(fr.content)
			self._log(f"Saved: {out.name}")
			return out
		except Exception as e:
			self._log(f"OpenSubtitles error: {e}")
			return None

	def _whisper(self):
		if not shutil.which("ffmpeg"):
			raise RuntimeError("ffmpeg required for Whisper")
		self._log("Loading Whisper model...")
		model = whisper.load_model("large-v3")
		opts = {"fp16": False}
		if self.lang == "eng":
			# Whisper can translate arbitrary supported speech to English.
			self._log("Translating to English with Whisper...")
			opts["task"] = "translate"
		else:
			# For non-English requests Whisper fallback works as same-language transcription.
			# This is useful when the video's spoken language matches the selected subtitle language.
			lang_name = WHISPER_LANG_MAP.get(self.lang)
			if lang_name:
				self._log(f"Transcribing with Whisper [{lang_name}]...")
				opts["task"] = "transcribe"
				opts["language"] = lang_name
			else:
				self._log("Transcribing with Whisper...")
		result = model.transcribe(str(self.path), **opts)
		lines = [
			f"{i}\n{srt_ts(s['start'])} --> {srt_ts(s['end'])}\n{s.get('text', '').strip()}"
			for i, s in enumerate(result.get("segments", []), 1)
		]
		out = self.path.with_suffix(f".{self.lang}.srt")
		out.write_text("\n\n".join(lines) + "\n", encoding="utf-8")
		self._log(f"Whisper done: {out.name}")
		return out


class WatchSyncClient(QtCore.QObject):
	connectedChanged = QtCore.pyqtSignal(bool)
	statusChanged = QtCore.pyqtSignal(str)
	memberChanged = QtCore.pyqtSignal(list)
	eventReceived = QtCore.pyqtSignal(dict)

	def __init__(self, parent=None):
		super().__init__(parent)
		self._ws = QtWebSockets.QWebSocket("", QtWebSockets.QWebSocketProtocol.Version.VersionLatest, self)
		self._ws.connected.connect(self._on_ws_connected)
		self._ws.disconnected.connect(self._on_ws_disconnected)
		self._ws.textMessageReceived.connect(self._on_message)
		self._ws.errorOccurred.connect(self._on_error)
		self._ping_timer = QtCore.QTimer(self)
		self._ping_timer.setInterval(15_000)
		self._ping_timer.timeout.connect(self._send_ping)
		self.server_url = ""
		self.room_code = ""
		self.name = ""
		self.client_id = uuid.uuid4().hex
		self.connected = False

	def connect_room(self, server_url: str, room_code: str, name: str):
		self.server_url = server_url.rstrip("/")
		self.room_code = room_code.strip()
		self.name = name.strip() or "Guest"
		if not self.server_url or not self.room_code:
			self.statusChanged.emit("Server URL and room code are required")
			return
		# convert http(s) to ws(s)
		ws_url = self.server_url
		if ws_url.startswith("http://"):
			ws_url = "ws://" + ws_url[7:]
		elif ws_url.startswith("https://"):
			ws_url = "wss://" + ws_url[8:]
		elif not ws_url.startswith("ws"):
			ws_url = "ws://" + ws_url
		self.statusChanged.emit("Connecting...")
		self._ws.open(QtCore.QUrl(ws_url))

	def disconnect_room(self):
		self._ping_timer.stop()
		self._ws.close()
		self.connected = False
		self.connectedChanged.emit(False)
		self.memberChanged.emit([])
		self.statusChanged.emit("Disconnected")

	def send_event(self, event_type: str, payload: dict):
		if not self.connected:
			return
		self._send({"action": "event", "type": event_type, "payload": payload})

	def _send(self, obj: dict):
		self._ws.sendTextMessage(json.dumps(obj))

	def _send_ping(self):
		if self.connected:
			self._send({"action": "ping"})

	def _on_ws_connected(self):
		self._send({
			"action": "join",
			"client_id": self.client_id,
			"name": self.name,
			"room": self.room_code,
		})

	def _on_ws_disconnected(self):
		was_connected = self.connected
		self._ping_timer.stop()
		self.connected = False
		self.connectedChanged.emit(False)
		self.memberChanged.emit([])
		if was_connected:
			self.statusChanged.emit("Connection lost")

	def _on_error(self, error):
		self.statusChanged.emit(f"Connection error: {self._ws.errorString()}")

	def _on_message(self, raw: str):
		try:
			msg = json.loads(raw)
		except json.JSONDecodeError:
			return
		action = msg.get("action")
		if action == "joined":
			self.connected = True
			self._ping_timer.start()
			self.connectedChanged.emit(True)
			self.memberChanged.emit(msg.get("members", []))
			self.statusChanged.emit(f"Connected to {self.room_code}")
			state = msg.get("state")
			if state:
				self.eventReceived.emit(state)
		elif action == "event":
			if msg.get("client_id") != self.client_id:
				self.eventReceived.emit(msg)
		elif action == "members":
			self.memberChanged.emit(msg.get("members", []))


class VideoPlayer(QtWidgets.QMainWindow):
	def __init__(self):
		super().__init__()
		self.setWindowTitle("AutoSub")
		self.resize(1160 if is_linux() else 1180, 760 if is_linux() else 680)
		self.setAcceptDrops(True)
		self.setFocusPolicy(QtCore.Qt.FocusPolicy.StrongFocus)
		self._apply_platform_tweaks()
		self.setStyleSheet(STYLE)
		vlc_args = [
			"--quiet",
			"--no-video-title-show",
			"--intf=dummy",
		]
		if is_linux():
			vlc_args.extend(["--vout=xcb_xv", "--avcodec-hw=none"])
		self.instance = vlc.Instance(*vlc_args)
		self.player = self.instance.media_player_new()
		self.media = None
		self.playlist: list[Path] = []
		self.current_index = None
		self.is_fullscreen = False
		self.saved_geometry = None
		self._threads: dict = {}
		self._workers: dict = {}
		self._active: dict = {}
		self._q_items: dict = {}
		self._jobs: list = []
		self._jid = 0
		self._sync_applying = False
		self._resume_after_seek = False
		self._headline_text = "Drop a video to start"
		self._status_text = "Drop a video to start"
		self._sync_status_text = "Not connected"
		self._sync_members_text = "Members: -"
		self.sync = WatchSyncClient(self)
		self._build_ui()
		self.timer = QtCore.QTimer(self)
		self.timer.setInterval(200)
		self.timer.timeout.connect(self._tick)
		self.sync.statusChanged.connect(self._on_sync_status)
		self.sync.connectedChanged.connect(self._on_sync_connected)
		self.sync.memberChanged.connect(self._on_sync_members)
		self.sync.eventReceived.connect(self._apply_remote_event)

	def _apply_platform_tweaks(self):
		QtWidgets.QApplication.setStyle(QtWidgets.QStyleFactory.create("Fusion"))
		font = QtGui.QFont()
		font.setPointSize(10 if is_linux() else 11)
		QtWidgets.QApplication.setFont(font)
		if is_linux():
			self.setMinimumSize(980, 700)
		else:
			self.setMinimumSize(960, 620)

	def _build_ui(self):
		c = QtWidgets.QWidget()
		self._ml = QtWidgets.QHBoxLayout(c)
		self._default_outer_margins = 14 if is_linux() else 18
		self._default_outer_spacing = 12 if is_linux() else 14
		self._card_margins = 14 if is_linux() else 16
		self._card_spacing = 10 if is_linux() else 12
		self._compact_spacing = 10 if is_linux() else 12
		self._control_slider_width = 96 if is_linux() else 120
		self._queue_height = 84 if is_linux() else 100
		self._ml.setContentsMargins(
			self._default_outer_margins,
			self._default_outer_margins,
			self._default_outer_margins,
			self._default_outer_margins,
		)
		self._ml.setSpacing(self._default_outer_spacing)

		self._splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
		self._splitter.setChildrenCollapsible(False)
		self._splitter.setHandleWidth(10)
		self._ml.addWidget(self._splitter, stretch=1)

		self._sidebar = QtWidgets.QFrame()
		self._sidebar.setObjectName("sidebarCard")
		self._sidebar.setMinimumWidth(180)
		self._sidebar.setMaximumWidth(360)
		self._sidebar.setSizePolicy(QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Expanding)
		sidebar_layout = QtWidgets.QVBoxLayout(self._sidebar)
		sidebar_layout.setContentsMargins(self._card_margins, self._card_margins, self._card_margins, self._card_margins)
		sidebar_layout.setSpacing(self._card_spacing)
		sidebar_title = QtWidgets.QLabel("Now Showing")
		sidebar_title.setObjectName("titleLabel")
		sidebar_layout.addWidget(sidebar_title)
		sidebar_blurb = QtWidgets.QLabel("Keep the video front and center. Use tabs only when you need queue, sync, or chat.")
		sidebar_blurb.setObjectName("mutedLabel")
		sidebar_blurb.setWordWrap(True)
		sidebar_layout.addWidget(sidebar_blurb)
		self._side_tabs = QtWidgets.QTabWidget()
		self._side_tabs.setDocumentMode(True)
		self._side_tabs.setTabPosition(QtWidgets.QTabWidget.TabPosition.North)
		self._side_tabs.setUsesScrollButtons(True)
		self._side_tabs.setElideMode(QtCore.Qt.TextElideMode.ElideRight)
		sidebar_layout.addWidget(self._side_tabs, stretch=1)

		self._pf = QtWidgets.QFrame()
		self._pf.setObjectName("playlistFrame")
		self._pf.setFrameStyle(QtWidgets.QFrame.Shape.StyledPanel | QtWidgets.QFrame.Shadow.Raised)
		pl = QtWidgets.QVBoxLayout(self._pf)
		pl.setContentsMargins(self._card_margins, self._card_margins, self._card_margins, self._card_margins)
		pl.setSpacing(self._card_spacing)

		hdr_wrap = QtWidgets.QVBoxLayout()
		hdr_wrap.setSpacing(self._compact_spacing)
		hdr = QtWidgets.QHBoxLayout()
		playlist_title = QtWidgets.QLabel("Library")
		playlist_title.setObjectName("titleLabel")
		hdr.addWidget(playlist_title)
		hdr.addStretch()
		self._activity = QtWidgets.QLabel("")
		self._activity.setObjectName("badgeLabel")
		self._activity.hide()
		hdr.addWidget(self._activity)
		hdr_wrap.addLayout(hdr)
		actions = QtWidgets.QVBoxLayout()
		actions.setSpacing(self._compact_spacing)
		lang_label = QtWidgets.QLabel("Subtitle Language")
		lang_label.setObjectName("sectionLabel")
		actions.addWidget(lang_label)
		self.lang_combo = QtWidgets.QComboBox()
		self.lang_combo.addItem("English", "eng")
		self.lang_combo.addItem("Turkish", "tur")
		self.lang_combo.addItem("Russian", "rus")
		self.lang_combo.addItem("French", "fra")
		self.lang_combo.addItem("Spanish", "spa")
		self.lang_combo.addItem("Italian", "ita")
		self.lang_combo.addItem("German", "deu")
		self.lang_combo.addItem("Dutch", "nld")
		self.lang_combo.addItem("Chinese", "zho")
		self.lang_combo.addItem("Japanese", "jpn")
		self.lang_combo.addItem("Hindi", "hin")
		self.lang_combo.addItem("Arabic", "ara")
		self.lang_combo.addItem("Portuguese", "por")
		self.lang_combo.currentIndexChanged.connect(self._on_lang_changed)
		actions.addWidget(self.lang_combo)
		action_buttons = QtWidgets.QGridLayout()
		action_buttons.setHorizontalSpacing(self._compact_spacing)
		action_buttons.setVerticalSpacing(self._compact_spacing)
		self._sel_btn = QtWidgets.QPushButton("Select All")
		self._sel_btn.setObjectName("secondaryButton")
		self._sel_btn.clicked.connect(self._toggle_select)
		self._sel_btn.hide()
		self._sel_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		action_buttons.addWidget(self._sel_btn, 0, 0)
		self._download_btn = QtWidgets.QPushButton("Download Subs")
		self._download_btn.setObjectName("secondaryButton")
		self._download_btn.clicked.connect(self._download_subs)
		self._download_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		action_buttons.addWidget(self._download_btn, 0, 1)
		self._add_btn = QtWidgets.QPushButton("Add Videos")
		self._add_btn.clicked.connect(self._add_videos)
		self._add_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		action_buttons.addWidget(self._add_btn, 1, 0, 1, 2)
		action_buttons.setColumnStretch(0, 1)
		action_buttons.setColumnStretch(1, 1)
		actions.addLayout(action_buttons)
		hdr_wrap.addLayout(actions)
		pl.addLayout(hdr_wrap)

		self._plw = QtWidgets.QListWidget()
		self._plw.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.SingleSelection)
		self._plw.itemChanged.connect(self._refresh_selection_button)
		self._plw.itemDoubleClicked.connect(lambda it: self._play_index(self._plw.row(it)))
		pl.addWidget(self._plw, stretch=1)
		self._queue_label = QtWidgets.QLabel("Subtitle Queue")
		self._queue_label.setObjectName("sectionLabel")
		pl.addWidget(self._queue_label)
		self._qw = QtWidgets.QListWidget()
		self._qw.setMaximumHeight(self._queue_height)
		pl.addWidget(self._qw)
		self._library_scroll = QtWidgets.QScrollArea()
		self._library_scroll.setWidgetResizable(True)
		self._library_scroll.setFrameShape(QtWidgets.QFrame.Shape.NoFrame)
		self._library_scroll.setWidget(self._pf)
		self._side_tabs.addTab(self._library_scroll, "Library")

		self._sync_frame = QtWidgets.QFrame()
		self._sync_frame.setObjectName("syncFrame")
		sl = QtWidgets.QVBoxLayout(self._sync_frame)
		sl.setContentsMargins(self._card_margins, self._card_margins, self._card_margins, self._card_margins)
		sl.setSpacing(self._compact_spacing)
		sync_title = QtWidgets.QLabel("Watch Together")
		sync_title.setObjectName("titleLabel")
		sl.addWidget(sync_title)
		sync_body = QtWidgets.QLabel(
			"Sync playback across different networks. Both people still need the same local video file."
		)
		sync_body.setObjectName("mutedLabel")
		sync_body.setWordWrap(True)
		sl.addWidget(sync_body)
		self._server_in = QtWidgets.QLineEdit("ws://127.0.0.1:8765")
		self._room_in = QtWidgets.QLineEdit("date-night")
		self._name_in = QtWidgets.QLineEdit(os.environ.get("USER", "You"))
		self._server_in.setPlaceholderText("Sync server URL")
		self._room_in.setPlaceholderText("Room code")
		self._name_in.setPlaceholderText("Your name")
		for label, widget in [
			("Server", self._server_in),
			("Room", self._room_in),
			("Name", self._name_in),
		]:
			lab = QtWidgets.QLabel(label)
			lab.setObjectName("sectionLabel")
			sl.addWidget(lab)
			sl.addWidget(widget)
		btns = QtWidgets.QGridLayout()
		btns.setHorizontalSpacing(self._compact_spacing)
		btns.setVerticalSpacing(self._compact_spacing)
		self._connect_btn = QtWidgets.QPushButton("Connect")
		self._connect_btn.clicked.connect(self._connect_sync)
		self._connect_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		btns.addWidget(self._connect_btn, 0, 0)
		self._disconnect_btn = QtWidgets.QPushButton("Leave")
		self._disconnect_btn.setObjectName("dangerButton")
		self._disconnect_btn.clicked.connect(self.sync.disconnect_room)
		self._disconnect_btn.setEnabled(False)
		self._disconnect_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		btns.addWidget(self._disconnect_btn, 0, 1)
		btns.setColumnStretch(0, 1)
		btns.setColumnStretch(1, 1)
		sl.addLayout(btns)
		self._sync_status = QtWidgets.QLabel("Not connected")
		self._sync_status.setObjectName("statusLabel")
		self._sync_status.setWordWrap(True)
		self._sync_status.setMinimumWidth(0)
		self._sync_members = QtWidgets.QLabel("Members: -")
		self._sync_members.setObjectName("mutedLabel")
		self._sync_members.setWordWrap(True)
		self._sync_members.setMinimumWidth(0)
		sl.addWidget(self._sync_status)
		sl.addWidget(self._sync_members)
		self._chat_label = QtWidgets.QLabel("Room Chat")
		self._chat_label.setObjectName("sectionLabel")
		sl.addWidget(self._chat_label)
		self._chat_list = QtWidgets.QListWidget()
		self._chat_list.setMinimumHeight(120)
		sl.addWidget(self._chat_list)
		chat_hint = QtWidgets.QLabel("Type freely, including emoji.")
		chat_hint.setObjectName("mutedLabel")
		chat_hint.setWordWrap(True)
		sl.addWidget(chat_hint)
		chat_row = QtWidgets.QGridLayout()
		chat_row.setHorizontalSpacing(self._compact_spacing)
		chat_row.setVerticalSpacing(self._compact_spacing)
		self._chat_input = QtWidgets.QLineEdit()
		self._chat_input.setPlaceholderText("Write a message...")
		self._chat_input.returnPressed.connect(self._send_chat_message)
		chat_row.addWidget(self._chat_input, 0, 0)
		self._chat_send_btn = QtWidgets.QPushButton("Send")
		self._chat_send_btn.setObjectName("secondaryButton")
		self._chat_send_btn.clicked.connect(self._send_chat_message)
		self._chat_send_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Maximum, QtWidgets.QSizePolicy.Policy.Fixed)
		chat_row.addWidget(self._chat_send_btn, 0, 1)
		chat_row.setColumnStretch(0, 1)
		sl.addLayout(chat_row)
		sl.addStretch(1)
		self._together_scroll = QtWidgets.QScrollArea()
		self._together_scroll.setWidgetResizable(True)
		self._together_scroll.setFrameShape(QtWidgets.QFrame.Shape.NoFrame)
		self._together_scroll.setWidget(self._sync_frame)
		self._side_tabs.addTab(self._together_scroll, "Together")

		self._rl = QtWidgets.QVBoxLayout()
		self._rl.setSpacing(self._default_outer_spacing)
		self._stage = QtWidgets.QWidget()
		self._stage_layout = QtWidgets.QVBoxLayout(self._stage)
		self._stage_layout.setContentsMargins(0, 0, 0, 0)
		self._stage_layout.setSpacing(self._default_outer_spacing)
		self._header = QtWidgets.QFrame()
		self._header.setObjectName("headerCard")
		header_layout = QtWidgets.QHBoxLayout(self._header)
		header_layout.setContentsMargins(self._card_margins, 12, self._card_margins, 12)
		header_layout.setSpacing(self._compact_spacing)
		self._headline = QtWidgets.QLabel("Drop a video to start")
		self._headline.setObjectName("titleLabel")
		self._headline.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Preferred)
		self._headline.setMinimumWidth(0)
		header_layout.addWidget(self._headline, stretch=1)
		self._room_badge = QtWidgets.QLabel("Solo")
		self._room_badge.setObjectName("badgeLabel")
		self._room_badge.setSizePolicy(QtWidgets.QSizePolicy.Policy.Maximum, QtWidgets.QSizePolicy.Policy.Preferred)
		self._room_badge.setMinimumWidth(0)
		header_layout.addWidget(self._room_badge)
		self._stage_layout.addWidget(self._header)

		self._vf = QtWidgets.QFrame()
		self._vf.setObjectName("videoFrame")
		self._vf.setStyleSheet(VIDEO_STYLE)
		self._vf.setFrameStyle(QtWidgets.QFrame.Shape.StyledPanel | QtWidgets.QFrame.Shadow.Raised)
		vbox = QtWidgets.QVBoxLayout(self._vf)
		vbox.setContentsMargins(0, 0, 0, 0)
		vbox.setSpacing(0)
		self._video_surface = QtWidgets.QWidget()
		self._video_surface.setObjectName("videoSurface")
		self._video_surface.setStyleSheet("QWidget#videoSurface{background:black}")
		self._video_surface.setAttribute(QtCore.Qt.WidgetAttribute.WA_NativeWindow, True)
		self._video_surface.setAttribute(QtCore.Qt.WidgetAttribute.WA_OpaquePaintEvent, True)
		self._video_surface.setAttribute(QtCore.Qt.WidgetAttribute.WA_PaintOnScreen, True)
		if is_linux():
			self._video_surface.setAttribute(QtCore.Qt.WidgetAttribute.WA_DontCreateNativeAncestors, True)
		self._video_surface.setSizePolicy(
			QtWidgets.QSizePolicy.Policy.Expanding,
			QtWidgets.QSizePolicy.Policy.Expanding,
		)
		self._video_surface.setMinimumSize(320, 200)
		self._video_surface.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.PointingHandCursor))
		self._vf.setCursor(QtGui.QCursor(QtCore.Qt.CursorShape.PointingHandCursor))
		self._vf.installEventFilter(self)
		self._video_surface.installEventFilter(self)
		vbox.addWidget(self._video_surface, stretch=1)
		self._stage_layout.addWidget(self._vf, stretch=1)

		self._prog_w = QtWidgets.QFrame()
		self._prog_w.setObjectName("progressCard")
		pr = QtWidgets.QHBoxLayout()
		pr.setContentsMargins(self._card_margins, 12 if is_linux() else 12, self._card_margins, 12)
		pr.setSpacing(self._compact_spacing)
		self._elapsed = QtWidgets.QLabel("0:00")
		self._slider = QtWidgets.QSlider(QtCore.Qt.Orientation.Horizontal)
		self._slider.setRange(0, 1000)
		self._slider.sliderPressed.connect(self._begin_seek)
		self._slider.sliderReleased.connect(self._seek)
		self._total = QtWidgets.QLabel("0:00")
		pr.addWidget(self._elapsed)
		pr.addWidget(self._slider, stretch=1)
		pr.addWidget(self._total)
		self._prog_w.setLayout(pr)
		self._stage_layout.addWidget(self._prog_w)

		self._ctrl_w = QtWidgets.QFrame()
		self._ctrl_w.setObjectName("controlCard")
		control_wrap = QtWidgets.QVBoxLayout()
		control_wrap.setContentsMargins(self._card_margins, 12, self._card_margins, 12)
		control_wrap.setSpacing(10)
		top_controls = QtWidgets.QHBoxLayout()
		top_controls.setSpacing(self._compact_spacing)
		self._play_btn = QtWidgets.QPushButton("Play")
		self._play_btn.clicked.connect(self._toggle_play)
		self._play_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		top_controls.addWidget(self._play_btn)
		b = QtWidgets.QPushButton("Stop")
		b.setObjectName("secondaryButton")
		b.clicked.connect(self._stop)
		b.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		top_controls.addWidget(b)
		self._fs_btn = QtWidgets.QPushButton("Fullscreen")
		self._fs_btn.setObjectName("secondaryButton")
		self._fs_btn.clicked.connect(self._toggle_fs)
		self._fs_btn.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		top_controls.addWidget(self._fs_btn)
		control_wrap.addLayout(top_controls)
		audio_controls = QtWidgets.QGridLayout()
		audio_controls.setHorizontalSpacing(self._compact_spacing)
		audio_controls.setVerticalSpacing(8)
		self._audio_label = QtWidgets.QLabel("Audio")
		self._audio_label.setObjectName("sectionLabel")
		audio_controls.addWidget(self._audio_label, 0, 0)
		self._audio_combo = QtWidgets.QComboBox()
		self._audio_combo.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		self._audio_combo.currentIndexChanged.connect(self._on_audio_device_changed)
		audio_controls.addWidget(self._audio_combo, 0, 1)
		self._vol_label = QtWidgets.QLabel("Vol")
		self._vol_label.setObjectName("sectionLabel")
		audio_controls.addWidget(self._vol_label, 0, 2)
		vol = QtWidgets.QSlider(QtCore.Qt.Orientation.Horizontal)
		vol.setRange(0, 100)
		vol.setValue(80)
		vol.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
		vol.valueChanged.connect(self.player.audio_set_volume)
		self._vol_slider = vol
		audio_controls.addWidget(vol, 0, 3)
		audio_controls.setColumnStretch(1, 1)
		audio_controls.setColumnStretch(3, 1)
		control_wrap.addLayout(audio_controls)
		self._status = QtWidgets.QLabel("Drop a video to start")
		self._status.setObjectName("statusLabel")
		self._status.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Preferred)
		self._status.setMinimumWidth(0)
		self._status.setWordWrap(True)
		control_wrap.addWidget(self._status)
		self._ctrl_w.setLayout(control_wrap)
		self._stage_layout.addWidget(self._ctrl_w)

		self._splitter.addWidget(self._sidebar)
		self._splitter.addWidget(self._stage)
		self._splitter.setStretchFactor(0, 0)
		self._splitter.setStretchFactor(1, 1)
		self._splitter.setSizes([260, 1000])
		self.setCentralWidget(c)
		self._ctrl_w.hide()
		self._prog_w.hide()
		self._queue_label.hide()
		self._qw.hide()
		self._refresh_selection_button()
		self._set_chat_enabled(False)
		self._refresh_responsive_ui()

	def _elide(self, text, label):
		if not text:
			return ""
		width = max(40, label.width() - 6)
		return label.fontMetrics().elidedText(text, QtCore.Qt.TextElideMode.ElideRight, width)

	def _set_headline(self, text):
		self._headline_text = text
		self._headline.setText(self._elide(text, self._headline))

	def _set_status_message(self, text):
		self._status_text = text
		self._status.setText(self._elide(text, self._status))

	def _set_sync_status(self, text):
		self._sync_status_text = text
		self._sync_status.setText(self._elide(text, self._sync_status))

	def _set_sync_members(self, text):
		self._sync_members_text = text
		self._sync_members.setText(self._elide(text, self._sync_members))

	def _refresh_responsive_ui(self):
		narrow = self.width() < 1180
		very_narrow = self.width() < 980
		self._audio_label.setVisible(not very_narrow)
		self._vol_label.setVisible(not very_narrow)
		self._audio_combo.setMaximumWidth(110 if very_narrow else 140 if narrow else 180)
		self._vol_slider.setMaximumWidth(72 if very_narrow else 96 if narrow else self._control_slider_width)
		self._sidebar.setMaximumWidth(260 if very_narrow else 300 if narrow else 360)
		self._set_headline(self._headline_text)
		self._set_status_message(self._status_text)
		self._set_sync_status(self._sync_status_text)
		self._set_sync_members(self._sync_members_text)

	def _refresh_audio_devices(self):
		self._audio_combo.blockSignals(True)
		self._audio_combo.clear()
		devices = self.player.audio_output_device_enum()
		if devices:
			current = self.player.audio_output_device_get()
			selected_idx = 0
			d = devices
			idx = 0
			while d:
				name = d.contents.description.decode("utf-8", errors="replace") if d.contents.description else f"Device {idx}"
				dev_id = d.contents.device.decode("utf-8", errors="replace") if d.contents.device else ""
				self._audio_combo.addItem(name, dev_id)
				if current and dev_id == current:
					selected_idx = idx
				idx += 1
				if d.contents.next:
					d = d.contents.next
				else:
					break
			vlc.libvlc_audio_output_device_list_release(devices)
			self._audio_combo.setCurrentIndex(selected_idx)
		self._audio_combo.blockSignals(False)

	def _on_audio_device_changed(self, index):
		dev_id = self._audio_combo.itemData(index)
		if dev_id:
			self.player.audio_output_device_set(None, dev_id)

	def _connect_sync(self):
		self.sync.connect_room(
			self._server_in.text().strip(),
			self._room_in.text().strip(),
			self._name_in.text().strip(),
		)

	def _on_sync_status(self, message):
		self._set_sync_status(message)

	def _on_sync_connected(self, connected):
		self._connect_btn.setEnabled(not connected)
		self._disconnect_btn.setEnabled(connected)
		for w in (self._server_in, self._room_in, self._name_in):
			w.setEnabled(not connected)
		self._set_chat_enabled(connected)
		if connected:
			self._set_sync_status(f"Connected to {self._room_in.text().strip()}")
			self._room_badge.setText(f"Room: {self._room_in.text().strip()}")
			self._append_chat_message("System", "Chat is ready.")
		else:
			self._room_badge.setText("Solo")
			self._append_chat_message("System", "Disconnected from room.")

	def _on_sync_members(self, members):
		names = [m.get("name", "Guest") for m in members]
		self._set_sync_members(f"Members: {', '.join(names) if names else '-'}")

	def _set_chat_enabled(self, enabled):
		self._chat_input.setEnabled(enabled)
		self._chat_send_btn.setEnabled(enabled)

	def _append_chat_message(self, sender, text, stamp=None):
		if not text:
			return
		item = QtWidgets.QListWidgetItem(f"[{stamp or chat_timestamp()}] {sender}: {text}")
		self._chat_list.addItem(item)
		self._chat_list.scrollToBottom()

	def _send_chat_message(self):
		text = self._chat_input.text().strip()
		if not text or not self.sync.connected:
			return
		sender = self._name_in.text().strip() or "You"
		stamp = chat_timestamp()
		self._append_chat_message(sender, text, stamp)
		self.sync.send_event("chat_message", {"sender": sender, "text": text, "sent_at": stamp})
		self._chat_input.clear()

	def _add_videos(self):
		paths, _ = QtWidgets.QFileDialog.getOpenFileNames(
			self,
			"Add Videos",
			"",
			"Video (*.mp4 *.mkv *.avi *.mov *.wmv *.flv);;All (*)",
		)
		self._enqueue([Path(p) for p in paths])

	def _enqueue(self, paths):
		new = [p for p in paths if p.exists()]
		if not new:
			return
		for p in new:
			self.playlist.append(p)
			it = QtWidgets.QListWidgetItem(p.name)
			it.setData(QtCore.Qt.ItemDataRole.UserRole, str(p))
			it.setData(QtCore.Qt.ItemDataRole.UserRole + 2, media_signature(p))
			it.setFlags(it.flags() | QtCore.Qt.ItemFlag.ItemIsUserCheckable)
			it.setCheckState(QtCore.Qt.CheckState.Unchecked)
			self._plw.addItem(it)
		self._sel_btn.setVisible(self._plw.count() > 0)
		self._ctrl_w.show()
		self._prog_w.show()
		self._refresh_selection_button()
		if self.current_index is None and self.playlist:
			self.current_index = 0
			self._plw.setCurrentRow(0)
		self._set_status_message(f"Added {len(new)} video(s). Double-click or press Play to start.")
		self._set_headline(self.playlist[self.current_index].name if self.current_index is not None else "Ready to play")
		self._refresh_queue_visibility()

	def _play_index(self, idx, remote=False):
		if 0 <= idx < len(self.playlist):
			self.current_index = idx
			self._plw.setCurrentRow(idx)
			self._load(self.playlist[idx], remote=remote)

	def _toggle_select(self):
		n = self._plw.count()
		if not n:
			return
		on = all(self._plw.item(i).checkState() == QtCore.Qt.CheckState.Checked for i in range(n))
		st = QtCore.Qt.CheckState.Unchecked if on else QtCore.Qt.CheckState.Checked
		for i in range(n):
			self._plw.item(i).setCheckState(st)
		self._refresh_selection_button()

	def _refresh_selection_button(self):
		n = self._plw.count()
		if not n:
			self._sel_btn.hide()
			return
		checked = sum(
			1 for i in range(n) if self._plw.item(i).checkState() == QtCore.Qt.CheckState.Checked
		)
		self._sel_btn.show()
		self._sel_btn.setText("Clear Selection" if checked == n and n > 0 else "Select All")

	def _refresh_queue_visibility(self):
		has_queue = self._qw.count() > 0
		self._queue_label.setVisible(has_queue)
		self._qw.setVisible(has_queue)

	def _download_subs(self):
		lang = self.lang_combo.currentData() or "eng"
		paths = [
			Path(self._plw.item(i).data(QtCore.Qt.ItemDataRole.UserRole))
			for i in range(self._plw.count())
			if self._plw.item(i).checkState() == QtCore.Qt.CheckState.Checked
			and self._plw.item(i).data(QtCore.Qt.ItemDataRole.UserRole)
		]
		if not paths:
			self._set_status_message("Check videos first")
			return
		existing = {(Path(j["path"]).resolve(), j["lang"]) for j in self._jobs}
		existing |= {(p.resolve(), l) for p, l in self._active.values()}
		for p in paths:
			if not p.exists() or (p.resolve(), lang) in existing:
				continue
			self._jid += 1
			self._jobs.append({"id": self._jid, "path": p, "lang": lang})
			it = QtWidgets.QListWidgetItem(f"Queued [{lang}]: {p.name}")
			it.setData(QtCore.Qt.ItemDataRole.UserRole, self._jid)
			it.setData(QtCore.Qt.ItemDataRole.UserRole + 1, p.name)
			self._qw.addItem(it)
			self._q_items[self._jid] = it
		self._refresh_queue_visibility()
		self._pump()

	def _pump(self):
		while len(self._threads) < 2 and self._jobs:
			job = self._jobs.pop(0)
			jid, path, lang = job["id"], job["path"], job["lang"]
			w = SubtitleWorker(path, lang)
			t = QtCore.QThread(self)
			w.moveToThread(t)
			_j, _p = jid, path
			w.finished.connect(lambda msg, sp, j=_j, vp=_p: self._sub_done(msg, sp, j, vp))
			w.errored.connect(lambda msg, j=_j, vp=_p: self._sub_err(msg, j, vp))
			w.progress.connect(lambda msg, j=_j: self._sub_prog(msg, j))
			w.finished.connect(t.quit)
			w.errored.connect(t.quit)
			t.finished.connect(t.deleteLater)
			t.started.connect(w.run)
			self._threads[jid] = t
			self._workers[jid] = w
			self._active[jid] = (path, lang)
			self._update_q(jid, f"Searching [{lang}]")
			t.start()
		n = len(self._jobs) + len(self._threads)
		if n:
			self._activity.setText(f"Downloading... ({n})")
			self._activity.show()
		else:
			self._activity.hide()
		self._refresh_queue_visibility()

	def _get_video_wid(self):
		self._video_surface.show()
		self._video_surface.raise_()
		QtWidgets.QApplication.processEvents()
		return int(self._video_surface.winId())

	def _load(self, path, remote=False):
		self.player.stop()
		self.media = self.instance.media_new(str(path))
		self.player.set_media(self.media)
		wid = self._get_video_wid()
		try:
			if sys.platform == "darwin":
				self.player.set_nsobject(wid)
			elif sys.platform.startswith("win"):
				self.player.set_hwnd(wid)
			else:
				self.player.set_xwindow(wid)
		except Exception as e:
			self._set_status_message(f"Video output error: {e}")
			return
		self.player.play()
		QtCore.QTimer.singleShot(300, self._refresh_audio_devices)
		self._set_status_message(f"Loaded {path.name}")
		self._set_headline(path.name)
		self._slider.setValue(0)
		self._elapsed.setText("0:00")
		self._total.setText("0:00")
		self._play_btn.setText("Pause")
		self.timer.start()
		if not remote:
			self._broadcast("load", {"media": self._media_payload(path), "position_ms": 0, "playing": True})

	def _toggle_play(self):
		if self.player.is_playing():
			self.player.pause()
			self._play_btn.setText("Play")
			self._broadcast("pause", {"position_ms": self.player.get_time()})
		elif self.media:
			self.player.play()
			self._play_btn.setText("Pause")
			self.timer.start()
			self._broadcast("play", {"position_ms": self.player.get_time()})
		elif self.playlist:
			self._play_index(self.current_index or 0)

	def _stop(self, remote=False):
		self.player.stop()
		self._play_btn.setText("Play")
		self.timer.stop()
		self._slider.setValue(0)
		self._elapsed.setText("0:00")
		self._total.setText("0:00")
		if not remote:
			self._broadcast("stop", {"position_ms": 0})
		if self.media:
			self._set_status_message("Playback stopped")
			self._set_headline(Path(self.playlist[self.current_index]).name if self.current_index is not None else "Playback stopped")

	def _begin_seek(self):
		self._resume_after_seek = self.player.is_playing()
		if self._resume_after_seek:
			self.player.pause()

	def _seek(self):
		if not self.media:
			return
		pos = int(self._slider.value() / 1000.0 * max(1, self.player.get_length()))
		self.player.set_position(self._slider.value() / 1000.0)
		if self._resume_after_seek:
			self.player.play()
			self._play_btn.setText("Pause")
		else:
			self._play_btn.setText("Play")
		self._resume_after_seek = False
		self._broadcast("seek", {"position_ms": pos})

	def _on_lang_changed(self):
		if self.current_index is None or self.current_index >= len(self.playlist):
			return
		vid = self.playlist[self.current_index]
		lang = self.lang_combo.currentData() or "eng"
		srt = vid.with_suffix(f".{lang}.srt")
		if srt.exists():
			self.player.video_set_subtitle_file(str(srt))
			self._set_status_message(f"Loaded {lang} subtitles")
		else:
			self._set_status_message(f"No {lang} subtitle file found")

	def _tick(self):
		if not self.media:
			return
		ln = self.player.get_length()
		if ln > 0:
			self._slider.blockSignals(True)
			self._slider.setValue(int(self.player.get_time() / ln * 1000))
			self._slider.blockSignals(False)
			self._elapsed.setText(fmt(self.player.get_time()))
			self._total.setText(fmt(ln))
		if self.player.get_state() in (vlc.State.Ended, vlc.State.Stopped):
			if self.current_index is not None and self.current_index + 1 < len(self.playlist):
				self._play_index(self.current_index + 1)
			else:
				self._stop()

	def _sub_done(self, msg, sub_path, jid, video_path):
		lang = self._active.get(jid, ("", ""))[1]
		self._set_status_message(f"{msg} [{lang}]")
		self._update_q(jid, f"Done [{lang}]")
		if self.media:
			mrl = self.media.get_mrl()
			if isinstance(mrl, str):
				p = urlparse(mrl)
				cur = Path(unquote(p.path)) if p.scheme == "file" else Path(mrl)
				if cur.resolve() == video_path.resolve() and sub_path:
					self.player.video_set_subtitle_file(str(sub_path))
		self._cleanup(jid)

	def _sub_err(self, msg, jid, _):
		self._set_status_message(f"Error: {msg}")
		self._update_q(jid, "Failed")
		self._cleanup(jid)

	def _sub_prog(self, msg, jid):
		lang = self._active.get(jid, ("", ""))[1]
		self._set_status_message(f"{msg} [{lang}]")
		self._update_q(jid, f"{msg} [{lang}]")

	def _cleanup(self, jid):
		t = self._threads.pop(jid, None)
		if t and t.isRunning():
			t.quit()
		self._workers.pop(jid, None)
		self._active.pop(jid, None)
		it = self._q_items.pop(jid, None)
		if it:
			self._qw.takeItem(self._qw.row(it))
		self._refresh_queue_visibility()
		self._pump()

	def _update_q(self, jid, status):
		it = self._q_items.get(jid)
		if it:
			it.setText(f"{status}: {it.data(QtCore.Qt.ItemDataRole.UserRole + 1) or ''}")

	def _broadcast(self, event_type, payload):
		if self._sync_applying:
			return
		if event_type != "load" and self.current_index is not None and self.current_index < len(self.playlist):
			payload.setdefault("media", self._media_payload(self.playlist[self.current_index]))
		self.sync.send_event(event_type, payload)

	def _media_payload(self, path: Path):
		return media_identity(path)

	def _find_playlist_index(self, media: dict):
		signature = media.get("signature")
		stem = (media.get("stem") or "").strip().lower()
		name = (media.get("name") or "").strip().lower()
		for i in range(self._plw.count()):
			item = self._plw.item(i)
			path = Path(item.data(QtCore.Qt.ItemDataRole.UserRole))
			if signature and item.data(QtCore.Qt.ItemDataRole.UserRole + 2) == signature:
				return i
			if stem and clean_title(path.stem).lower() == stem:
				return i
			if name and path.name.lower() == name:
				return i
		return None

	def _apply_remote_event(self, event):
		payload = event.get("payload") or {}
		event_type = event.get("type")
		if not event_type:
			return
		if event.get("client_id") == self.sync.client_id:
			return
		if event_type == "chat_message":
			self._append_chat_message(
				payload.get("sender", "Guest"),
				payload.get("text", ""),
				payload.get("sent_at"),
			)
			return
		media = payload.get("media", {})
		idx = self._find_playlist_index(media) if media else None
		self._sync_applying = True
		try:
			if media and idx is None:
				self._set_status_message(f"Partner opened {media.get('name', 'a video')}. Add the same file locally to sync.")
				return
			pos_ms = int(payload.get("position_ms", 0))
			if event_type == "load" and idx is not None:
				self._play_index(idx, remote=True)
				self.player.set_time(pos_ms)
				if not payload.get("playing", True):
					self.player.pause()
					self._play_btn.setText("Play")
			elif event_type == "play" and idx is not None:
				if self.current_index != idx:
					self._play_index(idx, remote=True)
				self.player.set_time(pos_ms)
				if not self.player.is_playing():
					self.player.play()
				self._play_btn.setText("Pause")
			elif event_type == "pause" and idx is not None:
				if self.current_index != idx:
					self._play_index(idx, remote=True)
				self.player.set_time(pos_ms)
				if self.player.is_playing():
					self.player.pause()
				self._play_btn.setText("Play")
			elif event_type == "seek" and idx is not None:
				if self.current_index != idx:
					self._play_index(idx, remote=True)
				self.player.set_time(pos_ms)
			elif event_type == "stop":
				self._stop(remote=True)
			self._update_time_display()
			self._set_sync_status(f"Synced: {event_type}")
		finally:
			self._sync_applying = False

	def _update_time_display(self):
		ln = self.player.get_length()
		t = self.player.get_time()
		if ln > 0:
			self._slider.blockSignals(True)
			self._slider.setValue(int(t / ln * 1000))
			self._slider.blockSignals(False)
			self._elapsed.setText(fmt(t))
			self._total.setText(fmt(ln))

	def dragEnterEvent(self, e):
		e.acceptProposedAction() if e.mimeData().hasUrls() else e.ignore()

	def dropEvent(self, e):
		self._enqueue([Path(u.toLocalFile()) for u in e.mimeData().urls() if u.isLocalFile()])
		e.acceptProposedAction()

	def eventFilter(self, obj, ev):
		if obj in (self._vf, self._video_surface) and ev.type() == QtCore.QEvent.Type.MouseButtonPress:
			self._toggle_play()
			return True
		return super().eventFilter(obj, ev)

	def keyPressEvent(self, e):
		k = e.key()
		if k == QtCore.Qt.Key.Key_Space:
			e.accept()
			self._toggle_play()
		elif k == QtCore.Qt.Key.Key_Right:
			e.accept()
			self._seek_rel(5000)
		elif k == QtCore.Qt.Key.Key_Left:
			e.accept()
			self._seek_rel(-5000)
		elif k == QtCore.Qt.Key.Key_F:
			e.accept()
			self._toggle_fs()
		elif k == QtCore.Qt.Key.Key_Escape and self.is_fullscreen:
			e.accept()
			self._toggle_fs()
		else:
			super().keyPressEvent(e)

	def resizeEvent(self, e):
		super().resizeEvent(e)
		self._refresh_responsive_ui()

	def _seek_rel(self, ms):
		if self.media and self.player.get_length() > 0:
			target = max(0, min(self.player.get_length() - 500, self.player.get_time() + ms))
			self.player.set_time(target)
			self._broadcast("seek", {"position_ms": target})

	def _toggle_fs(self):
		if self.is_fullscreen:
			self.player.set_fullscreen(False)
			self._ml.setContentsMargins(
				self._default_outer_margins,
				self._default_outer_margins,
				self._default_outer_margins,
				self._default_outer_margins,
			)
			self._ml.setSpacing(self._default_outer_spacing)
			self._vf.setStyleSheet(VIDEO_STYLE)
			self._vf.setFrameStyle(QtWidgets.QFrame.Shape.StyledPanel | QtWidgets.QFrame.Shadow.Raised)
			for w in (self._sidebar, self._header, self._ctrl_w, self._prog_w):
				w.show()
			if self.saved_geometry:
				self.setGeometry(self.saved_geometry)
			self.showNormal()
			self._fs_btn.setText("Fullscreen")
		else:
			self.saved_geometry = self.geometry()
			self._ml.setContentsMargins(0, 0, 0, 0)
			self._ml.setSpacing(0)
			self._vf.setStyleSheet("QFrame{background:black;border:none}")
			self._vf.setFrameStyle(QtWidgets.QFrame.Shape.NoFrame)
			for w in (self._sidebar, self._header, self._ctrl_w, self._prog_w):
				w.hide()
			self.showFullScreen()
			if not is_linux():
				self.player.set_fullscreen(True)
			self._fs_btn.setText("Windowed")
		self.is_fullscreen = not self.is_fullscreen

	def closeEvent(self, e):
		self.sync.disconnect_room()
		for t in list(self._threads.values()):
			if t.isRunning():
				t.quit()
				t.wait(2000)
		e.accept()


if __name__ == "__main__":
	app = QtWidgets.QApplication(sys.argv)
	app.setApplicationName("AutoSub")
	w = VideoPlayer()
	w.show()
	sys.exit(app.exec())