model = whisper.load_model("medium")
result = model.transcribe(
    audio_file,
    language="zh",
    word_timestamps=True
)

def whisper_to_ass(result, audio_file, output_dir):
    header = """[Script Info]
Title: Karaoke Lyrics
ScriptType: v4.00+
PlayResX: 1280
PlayResY: 720

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Default,Arial,48,&H0000FF00,&H00FFFFFF,&H00000000,&H64000000,-1,0,0,0,100,100,0,0,1,3,0,2,10,10,30,1

[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
"""

    events = []
    text_lines = []
    segments = result["segments"]

    for i, seg in enumerate(segments):
        if i == 0 or i == len(segments) - 1:
            # whisper有时会在开头或结尾添加「詞曲 李宗盛」，有则忽略
            text = seg.get("text", "")
            if "李宗盛" in text:
                continue
        words = seg.get("words", [])
        if not words:
            continue

        line_start = words[0]["start"]
        line_end = words[-1]["end"]

        ass_lyric = ""
        text = ""

        for w in words:
            dur_cs = int((w["end"] - w["start"]) * 100)
            ass_lyric += f"{{\\kf{dur_cs}}}{w['word']}"
            text += w["word"]

        events.append(
            f"Dialogue: 0,{format_ass_time(line_start)},{format_ass_time(line_end)},Default,,0,0,0,,{ass_lyric}"
        )
        text_lines.append(text)

    base_name = os.path.splitext(os.path.basename(audio_file))[0]

    ass_path = os.path.join(output_dir, "old_lyrics.ass")
    txt_path = os.path.join(output_dir, "lyrics_raw.txt")

    with open(ass_path, "w", encoding="utf-8") as f:
        f.write(header + "\n".join(events))

    with open(txt_path, "w", encoding="utf-8") as f:
        f.write("\n".join(text_lines))

    return ass_path, txt_path

    for i, seg in enumerate(segments):
        if i == 0 or i == len(segments) - 1:
            text = seg.get("text", "")
            if "李宗盛" in text:
                continue

from typing import Dict

# 简体
def simp_py_str() -> str:
    return '啊阿埃...'

# 繁体
def ft_py_str() -> str:
    return '啊阿埃...'

# 特殊/异体字
def qq_py_str() -> str:
    return '娿婀埃...'

# --- 优化构建阶段：建立映射字典 ---
def _build_maps():
    simp = simp_py_str()
    ft = ft_py_str()
    qq = qq_py_str()

    s2t_map: Dict[str, str] = {}
    t2s_map: Dict[str, str] = {}

    # 简 -> 繁
    for s, t in zip(simp, ft):
        s2t_map[s] = t
        t2s_map[t] = s

    # 异体字处理
    for q, t in zip(qq, ft):
        s2t_map[q] = t
        t2s_map[q] = simp[ft.index(t)] if t in ft else q

    return s2t_map, t2s_map

_S2T_MAP, _T2S_MAP = _build_maps()


# --- 转换函数 ---
def traditionalized(text: str) -> str:
    """简体 → 繁体"""
    if not text:
        return ''
    result = [_S2T_MAP.get(ch, ch) for ch in text]
    return ''.join(result)


def simplized(text: str) -> str:
    """繁体 → 简体"""
    if not text:
        return ''
    result = [_T2S_MAP.get(ch, ch) for ch in text]
    return ''.join(result)

class AssTime:
    def __init__(self, arg):
        """
        time_str: 字符串，格式为 "时:分:秒.百分秒"，例如 "0:00:12.41
        """
        if isinstance(arg, int):
            self.total_hundredths = arg
        else:
            hours, minutes, rest = arg.split(':')
            seconds, hundredths = rest.split('.')
            self.total_hundredths = (int(hours) * 3600 + int(minutes) * 60 + int(seconds)) * 100 + int(hundredths)

    def add(self, add_time):
        self.total_hundredths += add_time

    def __str__(self):
        total_seconds = self.total_hundredths // 100
        remaining_hundredths = self.total_hundredths % 100

        hours = total_seconds // 3600
        remaining_seconds = total_seconds % 3600
        minutes = remaining_seconds // 60
        seconds = remaining_seconds % 60

        return f"{hours}:{minutes:02d}:{seconds:02d}.{remaining_hundredths:02d}"
    
    def copy(self):
        return AssTime(self.total_hundredths)

    # 格式化旧歌词 [[word, dialogue_time_row, tag]]
    lyric_words = []
    # 存储每个dialogue的时间[start_time, end_time]
    dialogue_time_rows = []

    for i, line in enumerate(dialogue_lines):
        parts = line.strip().split(',', 9)
        dialogue_time_rows.append([AssTime(parts[1]), AssTime(parts[2])])
        lyric_part = parts[9].strip()
        j = 0
        lyric_len = len(lyric_part)
        current_lyric_word = [None, i, None]
        while j < lyric_len:
            c = lyric_part[j]
            j += 1
            if c == ' ':
                if ignore_space:
                    continue
                if current_lyric_word[2] is None:
                    lyric_words[-1][0] += ' '
                elif current_lyric_word[0] is None:
                    current_lyric_word[0] = ' '
                else:
                    current_lyric_word[0] += ' '
                continue
            if c == '{':
                t = j
                while j < lyric_len and lyric_part[j] != '}':
                    j += 1
                current_lyric_word[2] = lyric_part[t: j]
                j += 1
                continue
            current_lyric_word[0] = c if current_lyric_word[0] is None else current_lyric_word[0] + c
            lyric_words.append(current_lyric_word)
            current_lyric_word = [None, i, None]

    word_index = 0
    new_word_rows = []
    total_words = len(lyric_words)
    for line in txt_lines:
        row = []
        new_word_rows.append(row)
        for c in line:
            if word_index >= total_words:
                break
            if c == ' ':
                if lyric_words[word_index][0][0] != ' ' and lyric_words[word_index - 1][0][-1] != ' ':
                    lyric_words[word_index - 1][0] += ' '
                continue
            if lyric_words[word_index][0][0] == ' ':
                lyric_words[word_index][0] = ' ' + c
            elif lyric_words[word_index][0][-1] == ' ':
                lyric_words[word_index][0] = c + ' '
            else:
                lyric_words[word_index][0] = c
            row.append(lyric_words[word_index])
            word_index += 1

    # 生成新的 dialogue 行
    dialogue_example_line = dialogue_lines[0]
    example_parts = dialogue_example_line.strip().split(',', 9)

    new_dialogues = []

    word_index = 0
    for i, word_row in enumerate(new_word_rows):
        if not word_row:
            continue

        # 计算 start_time
        start_time_row_index = word_row[0][1]
        t = word_index - 1
        while t >= 0 and lyric_words[t][1] == start_time_row_index:
            t -= 1
        if t < word_index - 1:
            temp_start = dialogue_time_rows[lyric_words[t + 1][1]][0].copy()
            for p in range(t + 1, word_index):
                tag = lyric_words[p][2]
                if tag:
                    temp_start.add(int(re.search(r'\d+', tag).group()))
            start_time = temp_start
        else:
            start_time = dialogue_time_rows[start_time_row_index][0]
        
        # 计算 end_time (如果最后一个字恰好是该行最后一个字，则取该行end_time而非start_time加偏移量)
        word_index += len(word_row)
        end_time_row_index = word_row[-1][1]
        if word_index < total_words and lyric_words[word_index][1] > end_time_row_index:
            end_time = dialogue_time_rows[end_time_row_index][1]
        else:
            # 旧歌词的end_time会稍有偏移量，故采用start_time加偏移量的方式计算
            t = 2
            while t < len(word_row) and lyric_words[word_index - t][1] == end_time_row_index:
                t += 1
            temp_end = dialogue_time_rows[lyric_words[word_index - t][1]][0].copy()
            for p in range(word_index - t, word_index):
                tag = lyric_words[p][2]
                if tag:
                    temp_end.add(int(re.search(r'\d+', tag).group()))
            end_time = temp_end

        # 生成新的 lyric 部分
        new_lyric_part_io = StringIO()
        for w in word_row:
            if w[2]:
                new_lyric_part_io.write('{' + w[2] + '}')
            new_lyric_part_io.write(w[0])

        example_parts[1] = str(start_time)
        example_parts[2] = str(end_time)
        example_parts[9] = new_lyric_part_io.getvalue()

        new_dialogue_line = ','.join(example_parts) + '\n'
        new_dialogues.append(new_dialogue_line)

offset = match.b - match.a

from difflib import SequenceMatcher

def find_misalignment_intervals(ref, pred, min_match_len=3, offset_tolerance=5):
    """
    查找两个歌词字符串中的错位区间。

    参数：
        ref (str): 正确歌词
        pred (str): 识别歌词
        min_match_len (int): 最小匹配子串长度，过滤掉太短的偶然匹配
        offset_tolerance (int): 最大允许的匹配位置差，避免歌词重复误判

    返回：
        list[dict]: 错位区间列表，例如：
        [
            {"start_ref": 50, "end_ref": 120, "start_pred": 48, "end_pred": 118, "offset": -2},
            ...
        ]
    """
    matcher = SequenceMatcher(None, ref, pred)
    matches = matcher.get_matching_blocks()

    intervals = []
    prev_offset = 0

    for i, match in enumerate(matches):
        if match.size < min_match_len:
            continue

        offset = match.b - match.a

        # 跳过明显不对应的（比如副歌重复太远）
        if abs(offset) > offset_tolerance:
            continue

        if offset != prev_offset:
            last_match = matches[i - 1] if i > 0 else {"a": 0, "b": 0, "size": 0}
            inteval = {
                "start_ref": last_match.a + last_match.size,
                "start_pred": last_match.b + last_match.size,
                "end_ref": match.a,
                "end_pred": match.b,
                "offset": offset - prev_offset,
                "lyric_ref": ref[last_match.a + last_match.size: match.a],
                "lyric_pred": pred[last_match.b + last_match.size: match.b],
            }
            intervals.append(inteval)
            prev_offset = offset

    return intervals


if __name__ == "__main__":
    ref_lyric = "这是正确的歌词，用于测试错位检测功能。"
    pred_lyric = "这是错误的歌词，用于测试检测功能。"

    intervals = find_misalignment_intervals(ref_lyric, pred_lyric)
    for interval in intervals:
        print(interval)

def image_to_video(image_path, audio_path, output_path="output.mp4", volume=1.0):
    """
    生成视频：单张图片 + 背景音乐
    :param image_path: 图片路径 (jpg/png/jpeg)
    :param audio_path: 音频路径 (mp3)
    :param output_path: 输出视频路径 (默认 output.mp4)
    :param volume: 音量大小 (1.0为原音量，0.5为一半音量)
    """
    # 加载音频
    audio = AudioFileClip(audio_path).volumex(volume)
    duration = audio.duration  # 音频持续时间
    print(duration)

    # 创建图片视频片段（持续时间与音频相同）
    # clip = ImageClip(image_path, duration=duration)
    clip = ImageClip(image_path).resize(height=480, width=720).set_duration(duration)

    # 设置视频的音频
    video = clip.set_audio(audio)

    # 导出视频
    video.write_videofile(
        output_path,
        fps=24,          # 帧率
        # codec="libx264",
        # audio_codec="aac",
        # ffmpeg_params=[
        #     "-pix_fmt", "yuv420p",
        #     "-movflags", "+faststart"
        # ]
    )

    print(f"✅ 视频已生成: {output_path}")

def burn_ass(video_input, ass_path, output_path):
    # ffmpeg -i audio.mp4 -vf ass=lyrics.ass output.mp4
    # 下面的ass=参数不能用"\\"作为路径分隔符，必须使用"/"
    ass_path = ass_path.replace("\\", "/")
    subprocess.run([
        "ffmpeg",
        "-y",
        "-i", video_input,
        "-vf", f"ass={ass_path}",
        output_path
    ], check=True)