import pyaudio
import websockets

from PyQt6.QtWidgets import (QApplication, QMainWindow, QPushButton, QTextEdit,
QVBoxLayout, QHBoxLayout, QWidget, QLabel, QDialog,
QFormLayout, QFontComboBox, QSpinBox, QColorDialog,
QFileDialog, QMenu, QSlider, QInputDialog, QSizeGrip,
QComboBox)
from PyQt6.QtCore import QThread, pyqtSignal, QTimer, Qt
from PyQt6.QtGui import QTextCursor, QFont, QColor

# ----------------- 配置参数 -----------------
ARK_API_KEY = os.environ.get("ARK_API_KEY", "032121df-fd92-4088-8d7f-8cf375b0a96d")
ENDPOINT_ID = "ep-20250225111541-dcznw" # 替换为你的实际 Endpoint ID
URL = f"wss://ark-beta.cn-beijing.volces.com/api/v3/realtime?service=clasi&model={ENDPOINT_ID}"
HEADERS = [("Authorization", f"Bearer {ARK_API_KEY}")]

# ----------------- 音频参数 -----------------
RATE = 16000 # 采样率（Hz）
CHANNELS = 1 # 单声道
SAMPLE_WIDTH = 2 # 16位（2 字节）
CHUNK_SIZE = int(RATE * 0.1) # 100ms 音频数据

def hex_to_rgb(hex_color):
"""将 #RRGGBB 格式转为 (R, G, B) 元组"""
hex_color = hex_color.lstrip('#')
return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))

###############################################################################
# 对文字设置对话框：用于设置字幕的字体、字号和颜色
###############################################################################
class TextSettingsDialog(QDialog):
def __init__(self, parent=None, mode="rt", current_settings=None):
super().__init__(parent)
self.setWindowTitle("字幕设置")
self.mode = mode
if current_settings is None:
if mode == "rt":
current_settings = {"font_family": "Arial", "font_size": 16, "color": "#0000FF"}
else:
current_settings = {"font_family": "Arial", "font_size": 18, "color": "#000000"}
self.current_settings = current_settings

self.font_combo = QFontComboBox(self)
self.font_combo.setCurrentFont(QFont(current_settings["font_family"]))

self.size_spin = QSpinBox(self)
self.size_spin.setRange(8, 72)
self.size_spin.setValue(current_settings["font_size"])

self.color_button = QPushButton("选择颜色", self)
self.color = QColor(current_settings["color"])
self.color_button.setStyleSheet(f"background-color: {self.color.name()};")
self.color_button.clicked.connect(self.choose_color)

form_layout = QFormLayout()
form_layout.addRow("字体：", self.font_combo)
form_layout.addRow("字号：", self.size_spin)
form_layout.addRow("颜色：", self.color_button)

self.ok_button = QPushButton("确定", self)
self.cancel_button = QPushButton("取消", self)
self.ok_button.clicked.connect(self.accept)
self.cancel_button.clicked.connect(self.reject)
button_layout = QHBoxLayout()
button_layout.addStretch()
button_layout.addWidget(self.ok_button)
button_layout.addWidget(self.cancel_button)

main_layout = QVBoxLayout()
main_layout.addLayout(form_layout)
main_layout.addLayout(button_layout)
self.setLayout(main_layout)

def choose_color(self):
color = QColorDialog.getColor(initial=self.color, parent=self, title="选择颜色")
if color.isValid():
self.color = color
self.color_button.setStyleSheet(f"background-color: {self.color.name()};")

def get_settings(self):
return {
"font_family": self.font_combo.currentFont().family(),
"font_size": self.size_spin.value(),
"color": self.color.name()
}

###############################################################################
# 背景设置对话框：用于选择字幕背景颜色及透明度（以百分比表示）
###############################################################################
class BackgroundSettingsDialog(QDialog):
def __init__(self, parent=None, current_color="#000000", current_transparency=80):
"""
current_transparency: 0~100，0%表示完全不透明，100%表示完全透明
"""
super().__init__(parent)
self.setWindowTitle("背景设置")
self.current_color = QColor(current_color)
self.current_transparency = current_transparency

self.color_button = QPushButton("选择背景颜色", self)
self.color_button.setStyleSheet(f"background-color: {self.current_color.name()};")
self.color_button.clicked.connect(self.choose_color)

self.transparency_slider = QSlider(Qt.Orientation.Horizontal, self)
self.transparency_slider.setRange(0, 100)
self.transparency_slider.setValue(self.current_transparency)
self.transparency_label = QLabel(f"透明度: {self.current_transparency}%", self)
self.transparency_slider.valueChanged.connect(
lambda value: self.transparency_label.setText(f"透明度: {value}%")
)

form_layout = QFormLayout()
form_layout.addRow("背景颜色:", self.color_button)
form_layout.addRow("背景透明度 (%):", self.transparency_slider)
form_layout.addRow("", self.transparency_label)

self.ok_button = QPushButton("确定", self)
self.cancel_button = QPushButton("取消", self)
self.ok_button.clicked.connect(self.accept)
self.cancel_button.clicked.connect(self.reject)
button_layout = QHBoxLayout()
button_layout.addWidget(self.ok_button)
button_layout.addWidget(self.cancel_button)

main_layout = QVBoxLayout()
main_layout.addLayout(form_layout)
main_layout.addLayout(button_layout)
self.setLayout(main_layout)

def choose_color(self):
color = QColorDialog.getColor(initial=self.current_color, parent=self, title="选择背景颜色")
if color.isValid():
self.current_color = color
self.color_button.setStyleSheet(f"background-color: {self.current_color.name()};")

def get_settings(self):
return {
"bg_color": self.current_color.name(),
"bg_transparency": self.transparency_slider.value() # 0~100
}

###############################################################################
# 线程：音频录制（使用 RMS 计算音量，增加静音检测）
###############################################################################
class AudioRecorder(threading.Thread):
def __init__(self, audio_queue, update_volume_cb=None):
super().__init__()
self.audio_queue = audio_queue
self.update_volume_cb = update_volume_cb
self.pyaudio_instance = pyaudio.PyAudio()
self.stream = None
self.running = False
self.last_active_time = time.time()
self.volume_threshold = 300

def run(self):
self.stream = self.pyaudio_instance.open(
format=pyaudio.paInt16,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK_SIZE
)
self.running = True
while self.running:
try:
data = self.stream.read(CHUNK_SIZE, exception_on_overflow=False)
try:
self.audio_queue.put_nowait(data)
except queue.Full:
try:
self.audio_queue.get_nowait()
self.audio_queue.put_nowait(data)
except Exception:
pass
samples = [int.from_bytes(data[i:i+2], byteorder='little', signed=True)
for i in range(0, len(data), 2)]
if samples:
rms = math.sqrt(sum(s * s for s in samples) / len(samples))
if rms > self.volume_threshold:
self.last_active_time = time.time()
if self.update_volume_cb:
self.update_volume_cb(min(rms / 32768.0, 1.0))
except Exception as e:
print("AudioRecorder error:", e)
self.stream.stop_stream()
self.stream.close()
self.pyaudio_instance.terminate()

def stop(self):
self.running = False

###############################################################################
# 线程：WebSocket 发送与接收（处理音频数据发送和转录返回）
###############################################################################
class WebSocketThread(QThread):
subtitle_signal_orig = pyqtSignal(str)
subtitle_signal_trans = pyqtSignal(str)

def __init__(self, audio_queue, translation_direction="en2zh"):
super().__init__()
self.audio_queue = audio_queue
self.translation_direction = translation_direction
self.running = True

def run(self):
asyncio.run(self.websocket_main())

async def websocket_main(self):
try:
async with websockets.connect(URL, additional_headers=dict(HEADERS)) as ws:
print("WebSocket connection established.")

if self.translation_direction == "en2zh":
source_language = "en"
target_language = "zh"
else:
source_language = "zh"
target_language = "en"

session_update_msg = {
"type": "session.update",
"session": {
"input_audio_format": "pcm16",
"modalities": ["text"],
"input_audio_translation": {
"source_language": source_language,
"target_language": target_language,
"add_vocab": {"hot_word_list": [], "glossary_list": []}
}
}
}
print("Sending session.update message:")
print(json.dumps(session_update_msg, indent=2))
await ws.send(json.dumps(session_update_msg))

print("Waiting for session.* event from server...")
session_ready = False
try:
response = await asyncio.wait_for(ws.recv(), timeout=3.0)
print("Received raw message:", response)
event = json.loads(response)
event_type = event.get("type")
print("Parsed event type:", event_type)
if event_type in ("session.created", "session.updated"):
print("Session is ready, now proceed with audio commits.")
session_ready = True
else:
session_ready = True
except asyncio.TimeoutError:
print("Did not receive session.* event within 3 seconds. Proceeding anyway.")
session_ready = True

if session_ready:
send_task = asyncio.create_task(self.send_audio(ws))
recv_task = asyncio.create_task(self.receive_messages(ws))
ping_task = asyncio.create_task(self.ping_loop(ws))
await asyncio.gather(send_task, recv_task, ping_task)

except Exception as e:
print("WebSocket connection error:", e)

async def send_audio(self, ws):
loop = asyncio.get_running_loop()
while self.running:
try:
data = await loop.run_in_executor(None, self.audio_queue.get, 0.10)
if not data:
print("Warning: Received empty audio data.")
continue
encoded_data = base64.b64encode(data).decode('utf-8')
commit_msg = {"type": "input_audio.commit", "audio": encoded_data}
await ws.send(json.dumps(commit_msg))
except queue.Empty:
print("Queue is empty, retrying...")
await asyncio.sleep(0.10)
except websockets.exceptions.ConnectionClosedError as e:
print("WebSocket connection closed during send:", e)
self.running = False
break
except Exception as e:
print("Unexpected error during send:", e)
self.running = False
break
try:
await ws.send(json.dumps({"type": "input_audio.done"}))
except Exception:
pass

async def receive_messages(self, ws):
while self.running:
try:
message = await ws.recv()
print("Received raw message:", message)
event = json.loads(message)
print("Parsed event:", event)
if event.get("type") == "response.input_audio_transcription.delta":
transcription = event.get("delta", "")
# 收到服务端发回的“实时原文字幕”增量时，通过信号发给主线程
self.subtitle_signal_orig.emit(transcription)
elif event.get("type") == "response.input_audio_translation.delta":
translation = event.get("delta", "")
# 收到服务端发回的“实时译文字幕”增量时，通过信号发给主线程
self.subtitle_signal_trans.emit(translation)
except websockets.exceptions.ConnectionClosedError as e:
print("WebSocket connection closed during receive:", e)
break
except Exception as e:
print("WebSocket receive error:", e)
break

async def ping_loop(self, ws):
try:
while self.running:
await asyncio.sleep(30)
if self.running:
pong_waiter = await ws.ping()
print("Sent ping to server.")
try:
await asyncio.wait_for(pong_waiter, timeout=5)
print("Received pong from server.")
except asyncio.TimeoutError:
print("Did not receive pong in time, connection may be lost.")
except websockets.exceptions.ConnectionClosed:
print("ping_loop: WebSocket connection closed.")
except Exception as e:
print("ping_loop: Unexpected error:", e)

def stop(self):
self.running = False

###############################################################################
# 历史字幕窗口：显示已定型的字幕记录（滚动、字号较大）
###############################################################################
class HistoryWindow(QMainWindow):
"""
历史字幕窗口：
1. 用于显示所有“已定型”的字幕文本（即当一个段落确定结束后追加到这里）。
2. 提供单独的样式设置，如字体、大小、颜色，并与实时字幕独立。
3. 支持右键菜单进行历史字幕的样式设置，或者导出为TXT文件。
"""
def __init__(self):
super().__init__()
self.setWindowTitle("历史字幕")
self.setGeometry(850, 100, 600, 600)
# 默认历史字幕样式
self.current_history_font = "Arial"
self.current_history_font_size = 18
self.current_history_color = "#000000"

self.history_text = QTextEdit(self)
self.history_text.setReadOnly(True)
self.update_style({
"font_family": self.current_history_font,
"font_size": self.current_history_font_size,
"color": self.current_history_color
})

self.history_text.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.history_text.customContextMenuRequested.connect(self.show_history_context_menu)

layout = QVBoxLayout()
layout.addWidget(self.history_text)
container = QWidget()
container.setLayout(layout)
self.setCentralWidget(container)

def append_history(self, segment):
"""
将一段完成的字幕（原文 + 译文）追加到历史记录中。
每个新的段落会在历史文本中另起一行。
"""
current = self.history_text.toPlainText()
new_text = current + "\n\n" + segment if current else segment
self.history_text.setPlainText(new_text)
cursor = self.history_text.textCursor()
cursor.movePosition(QTextCursor.MoveOperation.End)
self.history_text.setTextCursor(cursor)

def update_style(self, settings):
"""
更新历史字幕的整体样式（字体、字号、颜色）。
"""
style = f"font-family: {settings['font_family']}; font-size: {settings['font_size']}px; color: {settings['color']};"
self.history_text.setStyleSheet(style)
self.current_history_font = settings["font_family"]
self.current_history_font_size = settings["font_size"]
self.current_history_color = settings["color"]

def show_history_context_menu(self, pos):
menu = QMenu(self.history_text)
settings_action = menu.addAction("设置历史字幕")
save_action = menu.addAction("保存为 TXT")
settings_action.triggered.connect(self.open_history_settings)
save_action.triggered.connect(self.save_history_as_txt)
menu.exec(self.history_text.mapToGlobal(pos))

def open_history_settings(self):
dialog = TextSettingsDialog(self, mode="history", current_settings={
"font_family": self.current_history_font,
"font_size": self.current_history_font_size,
"color": self.current_history_color
})
if dialog.exec() == QDialog.DialogCode.Accepted:
settings = dialog.get_settings()
self.update_style(settings)

def save_history_as_txt(self):
filename, _ = QFileDialog.getSaveFileName(self, "保存历史字幕", "", "Text Files (*.txt);;All Files (*)")
if filename:
with open(filename, "w", encoding="utf-8") as f:
f.write(self.history_text.toPlainText())

###############################################################################
# 字幕叠加窗口：用于在视频上叠加显示实时字幕
# 1. 每次收到 WebSocketThread 的增量字幕，会实时更新（原文 + 译文）。
# 2. 实时字幕背景的透明度以百分比设置（0%为不透明，100%为完全透明）。
# 3. 支持窗口拖动和交互式拖动缩放（使用 QSizeGrip 可改变宽度和高度）。
# 4. 右键菜单中增加“设置实时字幕”和“设置背景”选项。
###############################################################################
class SubtitleOverlayWindow(QMainWindow):
"""
实时字幕窗口：
1. 用于显示从服务端传回的原文和译文的“实时”增量字幕。
2. 当段落结束后，ControlPanelWindow 会将该段落“定型”并写入 HistoryWindow，
同时实时字幕会重新开始接收下一段的内容（即清空并从头显示）。
"""
def __init__(self):
super().__init__()
# 设置窗口为无边框、置顶、工具窗口
self.setWindowFlags(Qt.WindowType.FramelessWindowHint |
Qt.WindowType.WindowStaysOnTopHint |
Qt.WindowType.Tool)
# 允许窗口背景透明
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
# 初始背景为黑色且完全不透明（默认不透明，可通过背景设置调整透明度）
self.setGeometry(100, 100, 800, 200)

# 初始最大宽度取窗口宽度
self.max_width = self.width()

# 两个标签用于显示原文与译文（居中，多行显示）
self.orig_label = QLabel("", self)
self.orig_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.orig_label.setWordWrap(True)
self.orig_label.setMaximumWidth(self.max_width)
self.trans_label = QLabel("", self)
self.trans_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.trans_label.setWordWrap(True)
self.trans_label.setMaximumWidth(self.max_width)

layout = QVBoxLayout()
layout.addWidget(self.orig_label)
layout.addWidget(self.trans_label)
# 增加 QSizeGrip 用于交互式拖动缩放
self.size_grip = QSizeGrip(self)
layout.addWidget(self.size_grip, 0, Qt.AlignmentFlag.AlignRight)

container = QWidget(self)
container.setLayout(layout)
self.setCentralWidget(container)

# 默认实时字幕样式及背景设置
self.rt_font_family = "Arial"
self.rt_font_size = 24
self.rt_color = "#FFFFFF"
self.bg_color = "#000000" # 黑色背景
self.bg_transparency = 80 # 透明度百分比（默认80%，即有效透明度 = (100 - 80)/100 = 0.2）
self.update_style()

# 用于拖动窗口的偏移量
self.offset = None

def update_style(self):
rgb = hex_to_rgb(self.bg_color)
effective_alpha = (100 - self.bg_transparency) / 100.0
bg_style = f"background-color: rgba({rgb[0]}, {rgb[1]}, {rgb[2]}, {effective_alpha});"
text_style = f"font-family: {self.rt_font_family}; font-size: {self.rt_font_size}px; color: {self.rt_color};"
style = text_style + bg_style
self.orig_label.setStyleSheet(style)
self.trans_label.setStyleSheet(style)

def setSubtitles(self, orig, trans):
"""
实时更新字幕窗口中的原文和译文文本。
这里的orig和trans是当前尚未“定型”的段落增量。
"""
self.orig_label.setText(orig)
self.trans_label.setText(trans)

# 实现窗口拖动
def mousePressEvent(self, event):
if event.button() == Qt.MouseButton.LeftButton:
self.offset = event.pos()

def mouseMoveEvent(self, event):
if event.buttons() & Qt.MouseButton.LeftButton and self.offset is not None:
self.move(self.pos() + event.pos() - self.offset)

def mouseReleaseEvent(self, event):
self.offset = None

# 右键菜单：设置实时字幕样式和背景设置
def contextMenuEvent(self, event):
menu = QMenu(self)
set_font_action = menu.addAction("设置实时字幕")
set_bg_action = menu.addAction("设置背景")
action = menu.exec(event.globalPos())
if action == set_font_action:
self.open_rt_settings()
elif action == set_bg_action:
self.open_bg_settings()

def open_rt_settings(self):
dialog = TextSettingsDialog(self, mode="rt", current_settings={
"font_family": self.rt_font_family,
"font_size": self.rt_font_size,
"color": self.rt_color
})
if dialog.exec() == QDialog.DialogCode.Accepted:
settings = dialog.get_settings()
self.rt_font_family = settings["font_family"]
self.rt_font_size = settings["font_size"]
self.rt_color = settings["color"]
self.update_style()

def open_bg_settings(self):
dialog = BackgroundSettingsDialog(self, current_color=self.bg_color,
current_transparency=self.bg_transparency)
if dialog.exec() == QDialog.DialogCode.Accepted:
settings = dialog.get_settings()
self.bg_color = settings["bg_color"]
self.bg_transparency = settings["bg_transparency"]
self.update_style()

def resizeEvent(self, event):
self.max_width = self.width()
self.orig_label.setMaximumWidth(self.max_width)
self.trans_label.setMaximumWidth(self.max_width)
super().resizeEvent(event)

###############################################################################
# 控制面板窗口：用于控制录音、转写、翻译，并将字幕同步更新到叠加窗口与历史窗口
# 另外增加退出按钮，退出时关闭程序
###############################################################################
class ControlPanelWindow(QMainWindow):
"""
控制面板窗口：
1. 负责启动和停止录音（AudioRecorder）以及WebSocket通信（WebSocketThread）。
2. 收到实时原文/译文增量后，调用SubtitleOverlayWindow.setSubtitles()进行实时显示。
3. 通过一个定时器（段落间隔）来判断何时“定型”一个段落并写入 HistoryWindow 中。
- 在定时器超时（如2秒无新增量）时，将当前的原文+译文拼接后append到HistoryWindow中。
- 同时标记下一段落开始，清空实时字幕等。
"""
def __init__(self, subtitle_overlay, history_window):
super().__init__()
self.setWindowTitle("控制面板")
self.setGeometry(900, 100, 300, 280) # 稍微调整高度以容纳新控件
self.subtitle_overlay = subtitle_overlay
self.history_window = history_window

self.translation_direction = "en2zh" # 默认英译中
# current_orig_segment 和 current_trans_segment 用于累加“实时增量”字幕
self.current_orig_segment = ""
self.current_trans_segment = ""
# 当一次“定型”完成后，这两个变量会被清空，准备接收下一段内容
self.orig_finalized = False
self.trans_finalized = False

self.audio_queue = queue.Queue(maxsize=10)
self.audio_recorder = None
self.ws_thread = None

# 定时器用于确定段落结束，初始设置2秒（也可以通过段落间隔下拉框来改变）
self.segment_timer = QTimer(self)
self.segment_timer.timeout.connect(self.finalize_segment)
self.segment_timer.setInterval(2000)

# 控制按钮
self.start_button = QPushButton("开始", self)
self.pause_button = QPushButton("暂停", self)
self.pause_button.setEnabled(False)
self.toggle_button = QPushButton("EN → ZH", self)
self.exit_button = QPushButton("退出", self)

self.start_button.clicked.connect(self.start_recording)
self.pause_button.clicked.connect(self.pause_recording)
self.toggle_button.clicked.connect(self.toggle_translation_direction)
self.exit_button.clicked.connect(self.exit_program)

# 新增：段落间隔设置选项（1秒、2秒、3秒）
interval_layout = QHBoxLayout()
interval_label = QLabel("段落间隔:")
self.interval_combo = QComboBox(self)
self.interval_combo.addItems(["1秒", "2秒", "3秒"])
self.interval_combo.setCurrentIndex(1) # 默认选中2秒
self.interval_combo.currentIndexChanged.connect(self.change_timer_interval)
interval_layout.addWidget(interval_label)
interval_layout.addWidget(self.interval_combo)

layout = QVBoxLayout()
layout.addWidget(self.start_button)
layout.addWidget(self.pause_button)
layout.addWidget(self.toggle_button)
layout.addLayout(interval_layout)
layout.addWidget(self.exit_button)

container = QWidget()
container.setLayout(layout)
self.setCentralWidget(container)

def change_timer_interval(self):
# 根据下拉菜单选择的索引（0对应1秒，1对应2秒，2对应3秒）设置定时器间隔
seconds = self.interval_combo.currentIndex() + 1
self.segment_timer.setInterval(seconds * 1000)
print(f"段落间隔已设置为 {seconds} 秒")

def toggle_translation_direction(self):
# 切换翻译方向
self.translation_direction = "zh2en" if self.translation_direction == "en2zh" else "en2zh"
self.toggle_button.setText("EN → ZH" if self.translation_direction == "en2zh" else "ZH → EN")
# 重新启动录音和WebSocket线程以应用新的翻译方向
if self.audio_recorder or self.ws_thread:
self.pause_recording()
self.start_recording()

def exit_program(self):
QApplication.quit()

def start_recording(self):
# 启动录音线程和WebSocket线程
if not self.audio_recorder:
self.audio_recorder = AudioRecorder(self.audio_queue)
self.audio_recorder.start()
if not self.ws_thread:
self.ws_thread = WebSocketThread(self.audio_queue, translation_direction=self.translation_direction)
# 连接信号，以便实时接收增量字幕并更新UI
self.ws_thread.subtitle_signal_orig.connect(self.update_subtitle_orig)
self.ws_thread.subtitle_signal_trans.connect(self.update_subtitle_trans)
self.ws_thread.start()
self.start_button.setEnabled(False)
self.pause_button.setEnabled(True)

def pause_recording(self):
# 停止录音和WebSocket，并将当前段落做一次定型
self.finalize_segment()
if self.audio_recorder:
self.audio_recorder.stop()
self.audio_recorder = None
if self.ws_thread:
self.ws_thread.stop()
self.ws_thread = None
self.start_button.setEnabled(True)
self.pause_button.setEnabled(False)

def update_subtitle_orig(self, text):
"""
当收到实时原文增量时，进行拼接。
如果在前一次finalize_segment()中标记为已定型，则说明这次是新的段落，先清空再拼接。
然后通过SubtitleOverlayWindow.setSubtitles()来实时显示。
"""
if self.orig_finalized:
self.current_orig_segment = ""
self.orig_finalized = False
self.current_orig_segment += text
self.subtitle_overlay.setSubtitles(self.current_orig_segment, self.current_trans_segment)
# 每次收到增量后，重新启动段落定时器
self.segment_timer.start()

def update_subtitle_trans(self, text):
"""
当收到实时译文增量时，进行拼接。
如果在前一次finalize_segment()中标记为已定型，则说明这次是新的段落，先清空再拼接。
然后通过SubtitleOverlayWindow.setSubtitles()来实时显示。
"""
if self.trans_finalized:
self.current_trans_segment = ""
self.trans_finalized = False
self.current_trans_segment += text
self.subtitle_overlay.setSubtitles(self.current_orig_segment, self.current_trans_segment)
# 每次收到增量后，重新启动段落定时器
self.segment_timer.start()

def finalize_segment(self):
"""
段落定型：
1. 将当前的原文和译文拼接为一段完整字幕并追加到历史窗口中。
2. 标记 orig_finalized 和 trans_finalized = True，表示下一次收到新增量时要清空重来。
3. 停止当前的定时器，等待下次增量时重新开始计时。
"""
if self.current_orig_segment or self.current_trans_segment:
segment = f"{self.current_orig_segment}\n{self.current_trans_segment}"
# 将当前段落写入历史字幕
self.history_window.append_history(segment)
# 标记为已定型，下次更新时会清空
self.orig_finalized = True
self.trans_finalized = True
self.segment_timer.stop()

def main():
app = QApplication(sys.argv)
history_window = HistoryWindow()
history_window.show()
subtitle_overlay = SubtitleOverlayWindow()
subtitle_overlay.show()
control_panel = ControlPanelWindow(subtitle_overlay, history_window)
control_panel.show()
sys.exit(app.exec())

# 2) 把新的增量拼接进 current_orig_segment
self.current_orig_segment += text

# 3) 更新实时字幕
self.subtitle_overlay.setSubtitles(self.current_orig_segment, self.current_trans_segment)

# 4) 重启段落定时器（旧逻辑）
self.segment_timer.start()

# -------------------------
# 5) 新增：检查句末标点
# 设定一个可能的“句末标点”集合，可以根据语言适当扩展
sentence_endings = {'.', '?', '!', '。', '？', '！'}

# --- 新增：检测 text 是否以句号/感叹号/问号开头 ---
# 设定我们关心的标点符号
punctuation_chars = {'.', '!', '?'}
# 也可兼顾中文标点，如 punctuation_chars = {'.', '!', '?', '。', '！', '？'}

# 去除前后的空格
trimmed_text = text.lstrip() # 先只去左边空格，保留右边以免破坏中英翻译的空格
if (trimmed_text and trimmed_text[0] in punctuation_chars
and self.current_orig_segment
and self.current_orig_segment[-1].isalnum() # 上一个增量结尾是字母或数字
):
# 比如本次增量是 ". Thank you very much"
# 那么把 '.' 从开头拿走，合并进当前段落的末尾
punctuation = trimmed_text[0]
# 更新 current_orig_segment，把 punctuation 拼到结尾
self.current_orig_segment = self.current_orig_segment.rstrip() + punctuation
# 同时把 punctuation 从增量的开头去掉
trimmed_text = trimmed_text[1:].lstrip()

# 现在拼接剩余部分到 current_orig_segment
self.current_orig_segment += trimmed_text

# 更新实时字幕
self.subtitle_overlay.setSubtitles(self.current_orig_segment, self.current_trans_segment)