class ClipTask(QRunnable):
    def __init__(self, video_path, sub, line_num, ...):
        super().__init__()
        # ... 初始化

    def run(self):
        # ... 構(gòu)建 ffmpeg 命令
        cmd = ["ffmpeg", "-ss", start_time, "-i", video_path, ...]
        try:
            # 這是耗時(shí)操作
            subprocess.run(cmd, check=True, capture_output=True)
            # 任務(wù)成功了
        except Exception as e:
            # 任務(wù)失敗了
            pass

# 必須繼承自 QObject 才能定義信號(hào)
class Signals(QObject):

    # 進(jìn)度更新信號(hào)，攜帶一個(gè)字符串參數(shù)
    progress = Signal(str)
    
    # 所有任務(wù)完成的信號(hào)，不帶參數(shù)
    finished = Signal()
    
    # 字幕加載完成的信號(hào)，攜帶解析后的數(shù)據(jù)和文件名
    subtitles_loaded = Signal(list, str)
    
    # 加載出錯(cuò)的信號(hào)
    load_error = Signal(str)

class MainWindow(QWidget):
    def __init__(self):
        # ...
        self.signals = Signals()
        # 將 progress 信號(hào)連接到 update_progress 槽函數(shù)
        self.signals.progress.connect(self.update_progress)
        self.signals.finished.connect(self.clipping_finished)
        # ...

# 在 start_clipping 中
for line_num in self.selected_lines:
    sub = self.subtitles[line_num - 1]
    # 將 signals 對(duì)象傳入任務(wù)
    task = ClipTask(..., self.signals)
    # 提交到線程池執(zhí)行
    self.thread_pool.start(task)

# 在 ClipTask.run 中
class ClipTask(QRunnable):
    def run(self):
        try:
            subprocess.run(...)
            # 任務(wù)成功，從工作線程發(fā)射 progress 信號(hào)
            self.signals.progress.emit(f"Completed clip {self.line_num}")
        except subprocess.CalledProcessError as e:
            # 任務(wù)失敗，同樣發(fā)射 progress 信號(hào)，但內(nèi)容是錯(cuò)誤信息
            self.signals.progress.emit(f"Failed clip {self.line_num}: {e}")

# 在 MainWindow 中定義的槽函數(shù)
def update_progress(self, message: str):
    if "Completed" in message:
        self.completed_clips += 1
    elif "Failed" in message:
        self.failed_clips.append(message)

    self.progress_label.setText(
        f"共: {self.total_clips}, 完成: {self.completed_clips}, 失敗: {len(self.failed_clips)}"
    )

    # 檢查是否所有任務(wù)都結(jié)束了
    if self.completed_clips + len(self.failed_clips) >= self.total_clips:
        self.signals.finished.emit()

# /// script
# requires-python = ">=3.10,<=3.12"
# dependencies = [
#   "pyside6",
#   "pysubs2"
# ]
# ///

# /// script
# requires-python = ">=3.10,<=3.12"
# dependencies = [
#   "pyside6",
#   "pysubs2"
# ]
# 
# [[tool.uv.index]]
# url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
# 	
# ///

import sys
import os,shutil,platform
from pathlib import Path
import subprocess
from PySide6.QtWidgets import (
    QApplication, QWidget, QVBoxLayout, QHBoxLayout, QPushButton,
    QLabel, QFileDialog, QListWidget, QListWidgetItem, QCheckBox,
    QComboBox
)
from PySide6.QtCore import Qt, QThreadPool, QRunnable, Signal, QObject, QUrl, Slot,QSize
from PySide6.QtGui import QDesktopServices
from datetime import timedelta
import pysubs2

# 全局輸出文件夾
ROOT_DIR=Path(os.getcwd()).as_posix()
output_folder = f"{ROOT_DIR}/output"


class Signals(QObject):
    progress = Signal(str)
    finished = Signal()
    subtitles_loaded = Signal(list, str)  # list of (i, text), subtitle_name
    load_error = Signal(str)

class ClipTask(QRunnable):
    def __init__(self, video_path, sub, line_num, subtitle_name, signals, mode):
        super().__init__()
        self.video_path = video_path
        self.sub = sub
        self.line_num = line_num
        self.subtitle_name = subtitle_name
        self.signals = signals
        self.mode = mode

    def run(self):
        try:
            start_time = self.sub.start / 1000.0 
            duration = (self.sub.end - self.sub.start) / 1000.0
            output_dir = f'{output_folder}/{self.subtitle_name}'
            os.makedirs(output_dir, exist_ok=True)

            if self.mode == 0:  # 默認(rèn)
                output_path = os.path.join(output_dir, f"{self.line_num}.mp4")
                cmd = [
                    "ffmpeg","-y", "-ss", str(start_time), "-t", str(duration),
                    "-i", self.video_path, "-c:v", "copy", "-c:a", "copy",
                    output_path
                ]
                subprocess.run(cmd, check=True, capture_output=True)
            elif self.mode == 1:  # 僅視頻
                output_path = os.path.join(output_dir, f"{self.line_num}.mp4")
                cmd = [
                    "ffmpeg","-y", "-ss", str(start_time), "-t", str(duration),
                    "-i", self.video_path, "-c:v", "copy", "-an",
                    output_path
                ]
                subprocess.run(cmd, check=True, capture_output=True)
            elif self.mode == 2:  # 僅音頻
                output_path = os.path.join(output_dir, f"{self.line_num}.wav")
                cmd = [
                    "ffmpeg", "-y","-ss", str(start_time), "-t", str(duration),
                    "-i", self.video_path, "-vn", "-c:a", "pcm_s16le",
                    output_path
                ]
                subprocess.run(cmd, check=True, capture_output=True)
            elif self.mode == 3:  # 分離
                # 無(wú)聲視頻
                video_path_out = os.path.join(output_dir, f"{self.line_num}.mp4")
                cmd_video = [
                    "ffmpeg","-y", "-ss", str(start_time), "-t", str(duration),
                    "-i", self.video_path, "-c:v", "copy", "-an",
                    video_path_out
                ]
                subprocess.run(cmd_video, check=True, capture_output=True)

                # 音頻
                audio_path_out = os.path.join(output_dir, f"{self.line_num}.wav")
                cmd_audio = [
                    "ffmpeg","-y", "-ss", str(start_time), "-t", str(duration),
                    "-i", self.video_path, "-vn", "-c:a", "pcm_s16le",
                    audio_path_out
                ]
                subprocess.run(cmd_audio, check=True, capture_output=True)
            # 注意：Completed 和 Failed 不可修改，UI線程據(jù)此判斷成功與失敗，丑陋但簡(jiǎn)單
            self.signals.progress.emit(f"Completed clip {self.line_num}")
        except subprocess.CalledProcessError as e:
            error_msg = e.stderr.decode() if e.stderr else str(e)
            self.signals.progress.emit(f"Failed clip {self.line_num}: {error_msg}")
        except Exception as e:
            self.signals.progress.emit(f"Failed clip {self.line_num}: {str(e)}")

class LoadSubtitlesTask(QRunnable):
    def __init__(self, subtitle_path, signals):
        super().__init__()
        self.subtitle_path = subtitle_path
        self.signals = signals

    
    def _format_time(self,ms):
        hours = ms // (1000 * 3600)
        minutes = (ms // (1000 * 60)) % 60
        seconds = (ms // 1000) % 60
        milliseconds = ms % 1000
        return f"{hours:02d}:{minutes:02d}:{seconds:02d},{milliseconds:03d}"

    def run(self):
        try:
            subtitles = pysubs2.load(self.subtitle_path)
            subtitle_name = os.path.splitext(os.path.basename(self.subtitle_path))[0]
            data = []
            for i, sub in enumerate(subtitles, 1):
                start = self._format_time(sub.start)
                end = self._format_time(sub.end)
                duration = (sub.end - sub.start) / 1000.0
                text = f"{start}->{end}({duration:.2f}s) {sub.text}"
                data.append((i, text))
            self.signals.subtitles_loaded.emit(data, subtitle_name)
        except Exception as e:
            self.signals.load_error.emit(str(e))

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("按字幕剪輯視頻")
        self.resize(1000, 600)
        self.setWindowFlags(self.windowFlags() | Qt.WindowMaximizeButtonHint | Qt.WindowMinimizeButtonHint)

        self.video_path = None
        self.subtitle_path = None
        self.subtitles = None
        self.subtitle_name = None
        self.selected_lines = []
        self.thread_pool = QThreadPool()
        self.is_clipping = False
        self.signals = Signals()
        self.signals.progress.connect(self.update_progress)
        self.signals.finished.connect(self.clipping_finished)
        self.signals.subtitles_loaded.connect(self.on_subtitles_loaded)
        self.signals.load_error.connect(self.on_load_error)
        self.total_clips = 0
        self.completed_clips = 0
        self.failed_clips = []
        self.open_button = None
        self.active_tasks = 0

        self.setup_ui()

    def setup_ui(self):
        layout = QVBoxLayout()

        # 文件選擇
        file_layout = QHBoxLayout()
        self.video_label = QLabel("未選視頻")
        video_btn = QPushButton("選擇視頻")
        video_btn.clicked.connect(self.select_video)
        video_btn.setMinimumSize(QSize(200, 35))
        video_btn.setCursor(Qt.PointingHandCursor)
        file_layout.addWidget(video_btn)
        file_layout.addWidget(self.video_label)

        self.subtitle_label = QLabel("未選字幕")
        subtitle_btn = QPushButton("選擇字幕")
        subtitle_btn.setMinimumSize(QSize(200, 35))
        subtitle_btn.clicked.connect(self.select_subtitle)
        subtitle_btn.setCursor(Qt.PointingHandCursor)
        file_layout.addWidget(subtitle_btn)
        file_layout.addWidget(self.subtitle_label)

        # 輸出模式下拉列表
        self.output_mode = QComboBox()
        self.output_mode.addItems([
            "默認(rèn)(mp4片段有聲)",
            "僅保留視頻(mp4片段無(wú)聲)",
            "僅保留音頻(wav音頻片段)",
            "聲畫分離(mp4片段無(wú)聲和wav音頻片段)"
        ])
        file_layout.addWidget(self.output_mode)
        file_layout.addStretch() 
        layout.addLayout(file_layout)



        # 批量選擇按鈕
        batch_layout = QHBoxLayout()
        select_all_btn = QPushButton("全選")
        select_all_btn.clicked.connect(self.select_all)
        select_all_btn.setCursor(Qt.PointingHandCursor)
        batch_layout.addWidget(select_all_btn)

        deselect_all_btn = QPushButton("全不選")
        deselect_all_btn.clicked.connect(self.deselect_all)
        deselect_all_btn.setCursor(Qt.PointingHandCursor)
        batch_layout.addWidget(deselect_all_btn)

        invert_btn = QPushButton("反選")
        invert_btn.clicked.connect(self.invert_selection)
        invert_btn.setCursor(Qt.PointingHandCursor)
        batch_layout.addWidget(invert_btn)
        batch_layout.addStretch()
        layout.addLayout(batch_layout)

        # 字幕列表
        self.subtitle_list = QListWidget()
        layout.addWidget(self.subtitle_list)

        # 底部按鈕
        btn_layout = QHBoxLayout()

        self.clip_btn = QPushButton("開(kāi)始剪輯")
        self.clip_btn.setCursor(Qt.PointingHandCursor)
        self.clip_btn.setMinimumSize(QSize(200, 35))
        self.clip_btn.clicked.connect(self.start_clipping)
        btn_layout.addWidget(self.clip_btn)

        self.clear_btn = QPushButton("清除已選")
        self.clear_btn.setCursor(Qt.PointingHandCursor)
        self.clear_btn.setMaximumWidth(150)
        self.clear_btn.clicked.connect(self.clear_all)
        btn_layout.addWidget(self.clear_btn)
        
        self.open_button = QPushButton("打開(kāi)輸出目錄")
        self.open_button.setMaximumWidth(200)
        self.open_button.setCursor(Qt.PointingHandCursor)
        self.open_button.clicked.connect(self.open_output_folder)
        self.open_button.hide()
        btn_layout.addWidget(self.open_button)
        

        layout.addLayout(btn_layout)


        self.progress_label = QLabel("")
        self.progress_label.setStyleSheet('color:#2196f3;font-size:14px')
        layout.addWidget(self.progress_label)

        self.setLayout(layout)

    def select_video(self):
        path, _ = QFileDialog.getOpenFileName(self, "選擇視頻", "", "Video Files (*.mp4 *.avi *.mkv)")
        if path:
            self.video_path = path
            self.video_label.setText(os.path.basename(path))

    def select_subtitle(self):
        global output_folder
        path, _ = QFileDialog.getOpenFileName(self, "選擇對(duì)應(yīng)字幕", "", "Subtitle Files (*.srt *.ass *.vtt)")
        if path:
            output_folder=Path(path).parent.as_posix()
            self.subtitle_path = path
            self.subtitle_label.setText(os.path.basename(path))
            self.subtitle_list.clear()
            self.progress_label.setText("正在渲染字幕...")
            task = LoadSubtitlesTask(self.subtitle_path, self.signals)
            self.thread_pool.start(task)

    @Slot(list, str)
    def on_subtitles_loaded(self, data, subtitle_name):
        self.subtitles = pysubs2.load(self.subtitle_path)  # Reload if needed
        self.subtitle_name = subtitle_name
        self.subtitle_list.clear()
        for i, text in data:
            item = QListWidgetItem()
            check = QCheckBox(f"{i}行: {text}")
            self.subtitle_list.addItem(item)
            self.subtitle_list.setItemWidget(item, check)
        self.progress_label.setText(f"字幕渲染完成.剪輯后輸出到:{output_folder}/{subtitle_name}")

    @Slot(str)
    def on_load_error(self, error):
        self.progress_label.setText(f"字幕渲染出錯(cuò): {error}")

    def select_all(self):
        for i in range(self.subtitle_list.count()):
            item = self.subtitle_list.item(i)
            check = self.subtitle_list.itemWidget(item)
            check.setChecked(True)

    def deselect_all(self):
        for i in range(self.subtitle_list.count()):
            item = self.subtitle_list.item(i)
            check = self.subtitle_list.itemWidget(item)
            check.setChecked(False)

    def invert_selection(self):
        for i in range(self.subtitle_list.count()):
            item = self.subtitle_list.item(i)
            check = self.subtitle_list.itemWidget(item)
            check.setChecked(not check.isChecked())

    def clear_all(self):
        self.video_path = None
        self.subtitle_path = None
        self.subtitles = None
        self.subtitle_name = None
        self.selected_lines = []
        self.video_label.setText("未選視頻")
        self.subtitle_label.setText("未選字幕")
        self.subtitle_list.clear()
        self.progress_label.setText("")
        self.clip_btn.setText("開(kāi)始剪輯")
        self.is_clipping = False
        self.total_clips = 0
        self.completed_clips = 0
        self.failed_clips = []
        self.output_mode.setCurrentIndex(0)
        self.active_tasks = 0
        self.open_button.hide()

    def start_clipping(self):
        if self.is_clipping:
            self.stop_clipping()
            return

        if not self.video_path or not self.subtitle_name:
            self.progress_label.setText("請(qǐng)選擇待剪輯視頻及對(duì)應(yīng)字幕文件.")
            return

        self.selected_lines = []
        for i in range(self.subtitle_list.count()):
            item = self.subtitle_list.item(i)
            check = self.subtitle_list.itemWidget(item)
            if check.isChecked():
                self.selected_lines.append(i + 1)  # 1-based

        if not self.selected_lines:
            self.progress_label.setText("至少請(qǐng)選中一行字幕.")
            return

        mode = self.output_mode.currentIndex()

        self.is_clipping = True
        self.clip_btn.setText("立即停止")
        self.total_clips = len(self.selected_lines)
        self.completed_clips = 0
        self.failed_clips = []
        self.open_button.show()
        self.active_tasks = self.total_clips
        self.progress_label.setText(f"共: {self.total_clips}, 完成: 0, 失敗: 0")

        for line_num in self.selected_lines:
            sub = self.subtitles[line_num - 1]
            task = ClipTask(self.video_path, sub, line_num, self.subtitle_name, self.signals, mode)
            self.thread_pool.start(task)


    def stop_clipping(self):
        self.thread_pool.clear()
        self.is_clipping = False
        self.clip_btn.setText("開(kāi)始剪輯")
        self.progress_label.setText("立即停止.")
        self.active_tasks = 0

    def update_progress(self, message):
        if "Completed" in message:
            self.completed_clips += 1
        elif "Failed" in message:
            self.failed_clips.append(message)
        self.active_tasks -= 1
        self.progress_label.setText(
            f"共: {self.total_clips}, 完成: {self.completed_clips}, "
            f"失敗: {len(self.failed_clips)}\n" + "\n".join(self.failed_clips)
        )
        if self.active_tasks <= 0 and self.is_clipping:
            self.signals.finished.emit()

    def clipping_finished(self):
        self.is_clipping = False
        self.clip_btn.setText("開(kāi)始剪輯")
        self.active_tasks = 0


    def open_output_folder(self):
        output_dir = f'{output_folder}/{self.subtitle_name}'
        QDesktopServices.openUrl(QUrl.fromLocalFile(output_dir))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())