merged_code.txt

// ===============================
// FILE: ./AudioSync/AppleMusic/IDFetcher.swift
// ===============================
import AppKit
import Foundation

// MARK: - 1. JSON 解析模型
/// 用于解析 iTunes Search API 响应的结构体。我们只需要 Artist ID。
struct ArtistSearchResult: Decodable {
    let results: [Artist]

    struct Artist: Decodable {
        let artistId: Int
        let artistName: String
        // 允许获取其他信息，如商店代码，但我们只聚焦于 ID
    }
}
struct SongSearchResult: Decodable {
    let results: [SongSearchResult.Song]

    struct Song: Decodable {
        let artistId: Int
        let trackId: Int
        let artistName: String
        let trackName: String
        let collectionName: String
        let artworkUrl: String

        enum CodingKeys: String, CodingKey {
            case artistId, trackId, artistName, trackName, collectionName
            case artworkUrl = "artworkUrl100"
        }
    }
}
// MARK: - 2. 导航辅助枚举
public enum IDFetchError: Error, LocalizedError {
    case networkError(Error)
    case dataParsingError
    case NotFound
    case invalidURL

    public var errorDescription: String? {
        switch self {
        case .networkError(let error):
            return "网络请求失败: \(error.localizedDescription)"
        case .dataParsingError:
            return "数据解析失败，JSON结构可能已更改。"
        case .NotFound:
            return "未找到匹配的艺术家或歌曲。"
        case .invalidURL:
            return "URL 构造失败。"
        }
    }
}
// MARK: - 3. ID 获取器
public enum IDFetcher {
    private static let itunesSongCacheActor = ItunesSongCache()
    private static func safeCacheKey(
        for name: String,
        artist: String,
        countryCode: String
    ) -> String {
        let rawKey =
            "\(name.lowercased())_\(artist.lowercased())_\(countryCode.lowercased())"
        if let data = rawKey.data(using: .utf8) {
            return data.base64EncodedString()
        }
        return rawKey
    }
    public static func fetchArtistID(
        name: String,
        artist: String,
        countryCode: String = "cn"
    ) async throws -> Int {
        let song = try await fetchSong(by: name, by: artist)
        return song.artistId
    }

    public static func fetchTrackID(
        name: String,
        artist: String,
        countryCode: String = "cn"
    ) async throws -> Int {
        let song = try await fetchSong(by: name, by: artist)
        return song.trackId
    }

    public static func fetchArtworkData(
        name: String,
        artist: String,
        countryCode: String = "cn"
    ) async throws -> NSImage {
        let song = try await fetchSong(by: name, by: artist)
        // 1. 构造 URL
        guard let url = URL(string: song.artworkUrl) else {
            throw IDFetchError.invalidURL
        }

        // 2. 下载图片数据
        let (data, _) = try await URLSession.shared.data(from: url)

        // ✅ 优化点：不要直接返回原始大图
        guard let originalImage = NSImage(data: data) else {
            throw IDFetchError.dataParsingError
        }

        // 定义一个合适的最大尺寸，例如 600px
        let targetSize = NSSize(width: 200, height: 200)

        // 如果原图比目标尺寸小，直接返回；否则进行缩放
        if originalImage.size.width <= targetSize.width {
            return originalImage
        } else {
            return originalImage.resized(to: targetSize) ?? originalImage
        }
    }
    private static func fetchSong(
        by name: String,
        by artist: String,
        countryCode: String = "cn"
    ) async throws -> SongSearchResult.Song {

        let cacheKey = safeCacheKey(
            for: name,
            artist: artist,
            countryCode: countryCode
        )
        // 1. 先检查缓存
        if let cachedSong = await itunesSongCacheActor.get(for: cacheKey) {
            Log.backend.debug("命中缓存:\(name) - \(artist)")
            return cachedSong
        }

        // 2. 再检查是否有正在进行的任务
        if let ongoingTask = await itunesSongCacheActor.task(for: cacheKey) {
            return try await ongoingTask.value
        }
        // 3. 如果没有，就创建一个新任务
        let task = Task<SongSearchResult.Song, Error> {
            defer {
                Task { await itunesSongCacheActor.removeTask(for: cacheKey) }
            }

            let song = try await fetchSongFromNetwork(
                name: name,
                artist: artist,
                countryCode: countryCode
            )

            await itunesSongCacheActor.set(song, for: cacheKey)
            return song
        }

        // 4. 保存任务到 actor
        await itunesSongCacheActor.setTask(task, for: cacheKey)

        // 5. 等待任务完成
        return try await task.value
    }
    private static func fetchSongFromNetwork(
        name: String,
        artist: String,
        countryCode: String = "cn"
    ) async throws -> SongSearchResult.Song {
        // 1. URL 构造
        let baseURL = "https://itunes.apple.com/search"

        // 对名字进行 URL 编码，以处理空格和特殊字符
        let term = "\(name) \(artist)"
        guard
            let encodedTerm = term.addingPercentEncoding(
                withAllowedCharacters: .urlQueryAllowed
            )
        else {
            throw IDFetchError.invalidURL
        }

        // 设置搜索参数: term=艺术家名字, entity=allArtist, media=music, limit=1
        let urlString =
            "\(baseURL)?term=\(encodedTerm)&entity=musicTrack&media=music&limit=1&country=\(countryCode)"

        guard let url = URL(string: urlString) else {
            throw IDFetchError.invalidURL
        }

        Log.backend.debug("正在查询 iTunes Search API: \(url.absoluteString)")

        // 2. 网络请求
        let (data, _) = try await withCheckedThrowingContinuation {
            (continuation: CheckedContinuation<(Data, URLResponse), Error>) in
            // 使用 URLSession 发起请求
            let task = URLSession.shared.dataTask(with: url) {
                data,
                response,
                error in
                if let error = error {
                    continuation.resume(
                        throwing: IDFetchError.networkError(error)
                    )
                    return
                }
                guard let data = data else {
                    continuation.resume(throwing: IDFetchError.dataParsingError)
                    return
                }
                continuation.resume(returning: (data, response!))
            }
            task.resume()
        }

        // 3. JSON 解析
        do {
            let decoder = JSONDecoder()
            let songResult = try decoder.decode(
                SongSearchResult.self,
                from: data
            )

            guard let firstSong = songResult.results.first else {
                throw IDFetchError.NotFound
            }
            return firstSong

        } catch {
            // 可能是 JSON 解码错误或艺术家未找到
            if error is IDFetchError {
                throw error
            }
            throw IDFetchError.dataParsingError
        }
    }
}
extension NSImage {
    func resized(to newSize: NSSize) -> NSImage? {
        let newImage = NSImage(size: newSize)
        newImage.lockFocus()

        let sourceRect = NSRect(origin: .zero, size: self.size)
        let destRect = NSRect(origin: .zero, size: newSize)

        self.draw(
            in: destRect,
            from: sourceRect,
            operation: .copy,
            fraction: 1.0
        )

        newImage.unlockFocus()
        return newImage
    }
}


// ===============================
// FILE: ./AudioSync/AppleMusic/MusicNavigator.swift
// ===============================
import AppKit  // 用于 NSWorkspace
import Foundation

/// 封装了与 Apple Music App 交互的导航功能。
public enum MusicNavigator {

    /// 错误类型
    public enum NavigationError: Error {
        case appleScriptError(String)
        case invalidURL
    }
    /**
     使用 URL Scheme 直接打开一位艺术家的 Apple Music 主页。
    
     - Parameter artistID: 艺术家的数字 ID。
     - Throws: 如果 URL 构造失败，则抛出 `NavigationError.invalidURL`。
     - Returns: Bool - `NSWorkspace` 的 `open` 函数的返回值。
     */
    public static func openArtistPage(
        by artistID: String,
        storefrontCode: String = "cn"
    ) throws -> Bool {

        // 构建 Universal Link (HTTPS)
        // 使用占位符 'artist-name'，因为 OS 主要是看 ID
        // '?app=music' 是一个很好的提示，确保系统调用 Music App
        let urlString =
            "https://music.apple.com/\(storefrontCode)/artist/\(artistID)?app=music"

        guard let url = URL(string: urlString) else {
            Log.backend.error("错误: 无法构造 URL: \(urlString)")
            throw NavigationError.invalidURL
        }

        print("正在尝试打开 Universal Link: \(url.absoluteString)")

        // NSWorkspace 负责将这个 HTTPS 链接识别为 Universal Link，并打开 Music.app
        return NSWorkspace.shared.open(url)
    }
}


// ===============================
// FILE: ./AudioSync/AudioSyncApp.swift
// ===============================
//
//  AudioSyncApp.swift
//  AudioSync
//
//  Created by solo on 4/29/25.
//

import AppKit
import CoreAudio
import Foundation
import SwiftData
import SwiftUI

@main
struct AudioSyncApp: App {
    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    @ObservedObject var viewModel = ViewModel.shared
    @AppStorage("isKaraokeVisible") var isKaraokeVisible: Bool = false
    @AppStorage("isShowLoginView") var isShowLoginView: Bool = false
    @AppStorage("isAudioSwitch") var isAudioSwitch: Bool = true
    @State var isFullScreenVisible: Bool = false
    @State var karaoKeWindow: NSWindow? = nil
    @State var selectorWindow: NSWindow? = nil
    @State var similarArtistWindow: NSWindow? = nil
    @Environment(\.openWindow) var openWindow
    @ObservedObject var audioManager = AudioFormatManager.shared
    init() {
        appDelegate.modelContainer = sharedModelContainer
    }
    var sharedModelContainer: ModelContainer = {
        let schema = Schema([
            Song.self

        ])
        let modelConfiguration = ModelConfiguration(
            schema: schema,
            isStoredInMemoryOnly: false
        )
        do {
            return try ModelContainer(
                for: schema,
                configurations: [modelConfiguration]
            )
        } catch {
            fatalError("Could not create ModelContainer: \(error)")
        }
    }()

    private func CreateKaraoke() {
        if isKaraokeVisible && !isFullScreenVisible
            && viewModel.isViewLyricsShow
        {
            if karaoKeWindow == nil {
                let contentView = NSHostingView(
                    rootView: KaraokeView().environmentObject(viewModel)
                )
                karaoKeWindow = NSWindow(
                    contentRect: NSRect(x: 0, y: 100, width: 800, height: 100),
                    styleMask: [.borderless],
                    backing: .buffered,
                    defer: false
                )

                karaoKeWindow?.contentView = contentView
                karaoKeWindow?.isOpaque = false
                karaoKeWindow?.backgroundColor = .clear
                karaoKeWindow?.level = .floating

                if let screenFrame = NSScreen.main?.visibleFrame {
                    let windowHeight: CGFloat = 100
                    let windowY = screenFrame.minY
                    let windowX = (screenFrame.width - 800) / 2
                    karaoKeWindow?.setFrame(
                        NSRect(
                            x: windowX,
                            y: windowY,
                            width: 800,
                            height: windowHeight
                        ),
                        display: false
                    )
                }

                karaoKeWindow?.isMovableByWindowBackground = true
            }
            karaoKeWindow?.orderFrontRegardless()
        } else {
            karaoKeWindow?.orderOut(nil)
        }
    }

    private func showSimilarArtistWindow() {
        viewModel.refreshSimilarArtist = true
        if similarArtistWindow == nil {
            let contentView = NSHostingView(
                rootView: SimilarArtistView()
                    .environmentObject(viewModel)
            )

            let window = NSWindow(
                contentRect: NSRect(x: 0, y: 0, width: 250, height: 400),
                styleMask: [.titled, .closable],
                backing: .buffered,
                defer: false
            )
            // window.title = "相似歌手"
            window.center()
            window.contentView = contentView
            window.level = .floating  // 🔹关键：浮动在其他应用前
            //window.isMovableByWindowBackground = true
            window.isReleasedWhenClosed = false
            window.makeKeyAndOrderFront(nil)
            NSApp.activate(ignoringOtherApps: true)  // 保证出现在最前

            similarArtistWindow = window
        } else {
            similarArtistWindow?.makeKeyAndOrderFront(nil)
            NSApp.activate(ignoringOtherApps: true)
        }
    }
    private func createLyricsManualView(needNanualSelection: Bool) {
        if needNanualSelection {
            if selectorWindow == nil {
                let contentView = NSHostingView(
                    rootView: LyricsSelectorView().environmentObject(
                        viewModel
                    )
                )
                selectorWindow = NSWindow(
                    contentRect: NSRect(x: 0, y: 450, width: 450, height: 450),
                    styleMask: [.borderless],  // 无边框
                    backing: .buffered,
                    defer: false
                )
                selectorWindow?.contentView = contentView
                selectorWindow?.isOpaque = false
                selectorWindow?.backgroundColor = .clear
                selectorWindow?.level = .floating  // 后续会修改为前置显示
                // 精确让窗口贴近屏幕底部
                if let screenFrame = NSScreen.main?.visibleFrame {
                    let windowHeight: CGFloat = 450
                    let windowY = screenFrame.minY + 25
                    let windowX = (screenFrame.width - 450) / 2
                    selectorWindow?.setFrame(
                        NSRect(
                            x: windowX,
                            y: windowY,
                            width: 450,
                            height: windowHeight
                        ),
                        display: false
                    )
                }
                selectorWindow?.isMovableByWindowBackground = true
            }
            // 确保显示窗口
            selectorWindow?.makeKeyAndOrderFront(nil)

            // 确保激活应用并将窗口置顶
            NSApp.activate(ignoringOtherApps: true)
        } else {
            selectorWindow?.orderOut(nil)
        }
    }
    var body: some Scene {
        MenuBarExtra(
            content: {
                Toggle(
                    String(
                        format: "%d Bit  %.1f kHz",
                        audioManager.bitDepth ?? 0,
                        Double(audioManager.sampleRate ?? 0) / 1000.0
                    ),
                    isOn: $isAudioSwitch
                )
                Divider()
                Toggle("显示歌词", isOn: $isKaraokeVisible)
                //.keyboardShortcut("s")
                Divider()
                Toggle("全屏歌词", isOn: $isFullScreenVisible)
                //.keyboardShortcut("f")

                //                Divider()
                //
                //                Button("相似歌曲", action: appDelegate.similarSongTapped)

                Divider()
                Button("相似歌手") {
                    showSimilarArtistWindow()
                }

                Divider()
                Button("删除本地缓存", action: appDelegate.delCurrentSongObject)
                //.keyboardShortcut("d")
                Divider()
                Button("剪贴板读取原始歌曲名", action: appDelegate.manualNamefetch)

                Divider()
                Button("退出") {
                    NSApplication.shared.terminate(nil)
                }
                .keyboardShortcut("q")
            },
            label: {
                Group {
                    Image(systemName: "headphones.circle")
                }
                .onAppear {
                    viewModel.isViewLyricsShow =
                        isKaraokeVisible || isFullScreenVisible
                    CreateKaraoke()
                    viewModel.enableAudioSync = isAudioSwitch
                }
                .onReceive(viewModel.$needNanualSelection) { newValue in
                    createLyricsManualView(needNanualSelection: newValue)
                }
            }
        )
        .onChange(
            of: isFullScreenVisible,
            {
                Log.ui.info(
                    "isFullScreenVisible change: \(isFullScreenVisible)"
                )
                viewModel.isViewLyricsShow =
                    isKaraokeVisible || isFullScreenVisible
                if isFullScreenVisible {
                    openWindow(id: "fullScreen")
                    NSApplication.shared.activate()
                }
                // 全屏时去掉卡拉OK显示
                CreateKaraoke()
            }
        )
        .onChange(
            of: isKaraokeVisible,
            {
                Log.ui.info("isKaraokeVisible change: \(isKaraokeVisible)")
                viewModel.isViewLyricsShow =
                    isKaraokeVisible || isFullScreenVisible
                CreateKaraoke()
            }
        )
        .onChange(of: isAudioSwitch) {
            viewModel.enableAudioSync = isAudioSwitch
        }
        .onChange(
            of: viewModel.isLyricsPlaying,
            {
                CreateKaraoke()
            }
        )
        WindowGroup("fullScreenLyrics", id: "fullScreen") {
            FullScreenView(isPresented: $isFullScreenVisible).environmentObject(
                viewModel
            )
            .onWindowDidAppear { window in
                window.collectionBehavior = .fullScreenPrimary

                // 阻止 ESC
                NSEvent.addLocalMonitorForEvents(matching: .keyDown) {
                    event in
                    if event.keyCode == 53 { return nil }  // Esc
                    return event
                }

                // 设置退出全屏时关闭窗口
                let delegate = FullScreenWindowDelegate()
                delegate.onExitFullScreen = {
                    isFullScreenVisible = false
                    window.close()
                }
                window.delegate = delegate

                // 将 delegate 附着到 window 上，避免释放
                objc_setAssociatedObject(
                    window,
                    "FullScreenDelegateKey",
                    delegate,
                    .OBJC_ASSOCIATION_RETAIN_NONATOMIC
                )

                // 切换到全屏
                if !window.styleMask.contains(.fullScreen) {
                    window.toggleFullScreen(nil)
                }
            }
            .onDisappear {
                isFullScreenVisible = false
            }
        }
    }
}
extension View {
    func onWindowDidAppear(_ perform: @escaping (NSWindow) -> Void) -> some View
    {
        background(WindowFinder(onWindow: perform))
    }
}
struct WindowFinder: NSViewRepresentable {
    let onWindow: (NSWindow) -> Void

    func makeNSView(context: Context) -> NSView {
        let nsView = NSView()
        DispatchQueue.main.async {
            if let window = nsView.window {
                onWindow(window)
            }
        }
        return nsView
    }

    func updateNSView(_ nsView: NSView, context: Context) {}
}

// NSWindowDelegate 实现，处理退出全屏
class FullScreenWindowDelegate: NSObject, NSWindowDelegate {
    var onExitFullScreen: (() -> Void)?

    func windowDidExitFullScreen(_ notification: Notification) {
        // 延迟关闭，等系统完成退出动画
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
            self.onExitFullScreen?()
        }
    }
}


// ===============================
// FILE: ./AudioSync/LyricsParser/Extensions.swift
// ===============================
//
//  Extensions.swift
//  SpotlightLyrics
//
//  Created by Scott Rong on 2017/7/28.
//  Copyright © 2017 Scott Rong. All rights reserved.
//

import Foundation

extension CharacterSet {
    public static let quotes = CharacterSet(charactersIn: "\"'")
}

extension String {
    public func emptyToNil() -> String? {
        return self == "" ? nil : self
    }
    
    public func blankToNil() -> String? {
        return self.trimmingCharacters(in: .whitespacesAndNewlines) == "" ? nil : self
    }
}


// ===============================
// FILE: ./AudioSync/LyricsParser/LyricsHeader.swift
// ===============================
//
//  LyricsHeader.swift
//  SpotlightLyrics
//
//  Created by Scott Rong on 2017/7/28.
//  Copyright © 2017 Scott Rong. All rights reserved.
//

import Foundation

public struct LyricsHeader {
    // ti
    public var title: String?
    // ar
    public var author: String?
    // al
    public var album: String?
    // by
    public var by: String?
    // offset
    public var offset: TimeInterval = 0
    // re
    public var editor: String?
    // ve
    public var version: String?
}


// ===============================
// FILE: ./AudioSync/LyricsParser/LyricsParser.swift
// ===============================
//
//  LyricsParser.swift
//  SpotlightLyrics
//
//  Created by Scott Rong on 2017/4/2.
//  Copyright © 2017 Scott Rong. All rights reserved.
//

import Foundation
import Regex

public enum LyricsFormat: Sendable {
    case netEase  // 原始 LRC 格式
    case qq  // QQ 歌词格式
}

public class LyricsParser {

    let lyricsLineRegex = Regex(
        #"^(\[[+-]?\d+:\d+(?:\.\d+)?\])+(?!\[)([^【\n\r]*)(?:【(.*)】)?"#,
        options: .anchorsMatchLines)

    public var header: LyricsHeader
    public private(set) var lyrics: [LyricLine] = []

    // MARK: Initializers

    public init(lyrics: String, format: LyricsFormat) {
        header = LyricsHeader()
        switch format {
        case .netEase:
            commonInit(lyrics: lyrics)
        case .qq:
            QQLyricInit(lyrics)
        }
    }

    private func commonInit(lyrics: String) {
        header = LyricsHeader()
        parse(lyrics: lyrics)
    }

    // MARK: Privates

    private func parse(lyrics: String) {
        let lines =
            lyrics
            .replacingOccurrences(of: "\\n", with: "\n")
            .trimmingCharacters(in: .quotes)
            .trimmingCharacters(in: .newlines)
            .components(separatedBy: .newlines)

        for line in lines {
            parseLine(line: line)
        }

        // sort by time
        self.lyrics.sort { $0.startTimeMS < $1.startTimeMS }
    }

    private func parseLine(line: String) {
        guard let line = line.blankToNil() else {
            return
        }

        //        if let title = parseHeader(prefix: "ti", line: line) {
        //            header.title = title
        //            return
        //        }
        //        if let author = parseHeader(prefix: "ar", line: line) {
        //            header.author = author
        //            return
        //        }
        //        if let album = parseHeader(prefix: "al", line: line) {
        //            header.album = album
        //            return
        //        }
        //        if let by = parseHeader(prefix: "by", line: line) {
        //            header.by = by
        //            return
        //        }
        if let offset = parseHeader(prefix: "offset", line: line) {
            header.offset = TimeInterval(offset) ?? 0
            return
        }
        if !line.hasSuffix("]") {
            lyrics += parseLyric(line: line)
        }
        //        if let editor = parseHeader(prefix: "re", line: line) {
        //            header.editor = editor
        //            return
        //        }
        //        if let version = parseHeader(prefix: "ve", line: line) {
        //            header.version = version
        //            return
        //        }

    }

    private func parseHeader(prefix: String, line: String) -> String? {
        if line.hasPrefix("[" + prefix + ":") && line.hasSuffix("]") {
            let startIndex = line.index(
                line.startIndex, offsetBy: prefix.count + 2)
            let endIndex = line.index(line.endIndex, offsetBy: -1)
            return String(line[startIndex..<endIndex])
        } else {
            return nil
        }
    }

    private func parseLyric(line: String) -> [LyricLine] {
        var cLine = line
        var items: [LyricLine] = []
        while cLine.hasPrefix("[") {
            guard let closureIndex = cLine.range(of: "]")?.lowerBound else {
                break
            }

            let startIndex = cLine.index(cLine.startIndex, offsetBy: 1)
            let endIndex = cLine.index(closureIndex, offsetBy: -1)
            let amidString = String(cLine[startIndex..<endIndex])

            let amidStrings = amidString.components(separatedBy: ":")
            var hour: TimeInterval = 0
            var minute: TimeInterval = 0
            var second: TimeInterval = 0
            if amidStrings.count >= 1 {
                second = TimeInterval(amidStrings[amidStrings.count - 1]) ?? 0
            }
            if amidStrings.count >= 2 {
                minute = TimeInterval(amidStrings[amidStrings.count - 2]) ?? 0
            }
            if amidStrings.count >= 3 {
                hour = TimeInterval(amidStrings[amidStrings.count - 3]) ?? 0
            }
            cLine.removeSubrange(
                cLine.startIndex..<cLine.index(closureIndex, offsetBy: 1))
            cLine = cLine.trimmingCharacters(in: .whitespaces)
            // Create a LyricLine with the calculated start time and the remaining line as the words
            let lyricLine = LyricLine(
                startTime: 1000
                    * (hour * 3600 + minute * 60 + second + header.offset),
                words: cLine)
            items.append(lyricLine)
        }

        return items
    }

    func mergeLyrics(translation: LyricsParser, threshold: TimeInterval = 0.02)
        -> [LyricLine]
    {
        var merged: [LyricLine] = []
        var i = 0
        var j = 0

        let originalLines = self.lyrics
        let translationLines = translation.lyrics

        while i < originalLines.count && j < translationLines.count {
            let originalLine = originalLines[i]
            let translationLine = translationLines[j]
            let timeDiff = abs(
                originalLine.startTimeMS - translationLine.startTimeMS)

            if timeDiff < threshold {
                // 时间戳匹配，合并翻译
                var mergedLine = originalLine
                mergedLine.attachments[.translation()] = .plainText(
                    translationLine.words)
                merged.append(mergedLine)
                i += 1
                j += 1
            } else if originalLine.startTimeMS < translationLine.startTimeMS {
                // 原始歌词时间戳较早，添加原始歌词行
                merged.append(originalLine)
                i += 1
            } else {
                // 翻译歌词时间戳较早，跳过翻译行
                j += 1
            }
        }

        // 添加剩余的原始歌词行
        while i < originalLines.count {
            merged.append(originalLines[i])
            i += 1
        }

        return merged
    }

    private func QQLyricInit(_ description: String) {
        let lines = lyricsLineRegex.matches(in: description).flatMap { match in
            let timeTagStr = match[1]!.string
            let timeTags = resolveTimeTag(timeTagStr)

            let lyricsContentStr = match[2]!.string
            var line = LyricLine(startTime: 0, words: lyricsContentStr)

            if let translationStr = match[3]?.string, !translationStr.isEmpty {
                line.attachments[.translation()] = .plainText(translationStr)
            }

            return timeTags.map { timeTag in
                var l = line
                l.startTimeMS = timeTag * 1000
                return l
            }
        }.sorted {
            $0.startTimeMS < $1.startTimeMS
        }
        self.lyrics = lines
    }

    private func resolveTimeTag(_ str: String) -> [TimeInterval] {
        let timeTagRegex = Regex(#"\[([-+]?\d+):(\d+(?:\.\d+)?)\]"#)
        let matchs = timeTagRegex.matches(in: str)
        return matchs.map { match in
            let min = Double(match[1]!.content)!
            let sec = Double(match[2]!.content)!
            return min * 60 + sec
        }
    }
}


// ===============================
// FILE: ./AudioSync/model/Artist.swift
// ===============================
import AppKit
import Foundation
import SwiftData

struct Artist: Identifiable, Sendable, Encodable {
    var id: String
    var mbid: String
    var name: String
    var url: String
    var image: Data?

    init(name: String, url: String = "", mbid: String = "") {
        self.id = "artist:\(name)+\(url)"
        self.name = name
        self.url = url
        self.mbid = mbid
    }

}
struct ArtistFromLastFMResponse: Decodable, Encodable {
    let similarartists: Similarartists?

    struct Similarartists: Decodable, Encodable {
        let artist: [ArtistEntity]?

        struct ArtistEntity: Decodable, Encodable {
            let name: String
            let mbid: String?
            let url: String
        }
    }
}

struct SimilarSong: Identifiable, Sendable, Encodable {
    var id: String
    var name: String
    var mbid: String
    var artist: String
    init(name: String, mbid: String, artist: String = "") {
        self.id = "song:\(name)-\(artist)"
        self.name = name
        self.mbid = mbid
        self.artist = artist
    }

}
struct SongFromLastFMResponse: Decodable, Encodable {
    let similartracks: SongFromLastFMResponse.SimilarTrack?

    struct SimilarTrack: Decodable, Encodable {
        let track: [SimilarTrack.TrackEntity]
        struct TrackEntity: Decodable, Encodable {
            let name: String
            let mbid: String?
            let artist: TrackEntity.Artist
            struct Artist: Decodable, Encodable {
                let name: String
            }
        }
    }
}


// ===============================
// FILE: ./AudioSync/model/Caches.swift
// ===============================
import Foundation

actor CoverCache {
    private var cache: [String: CacheEntry] = [:]
    private var accessOrder: [String] = []  // LRU 队列
    private let maxMemorySize: Int = 100 * 1024 * 1024  // 100MB
    private var currentSize: Int = 0

    struct CacheEntry {
        let data: Data
        let size: Int
    }

    func get(for key: String) -> Data? {
        guard let entry = cache[key] else { return nil }

        // 更新 LRU（将 key 移到队尾）
        if let idx = accessOrder.firstIndex(of: key) {
            accessOrder.remove(at: idx)
        }
        accessOrder.append(key)

        return entry.data
    }

    func set(_ data: Data, for key: String) {
        let size = data.count

        // 如果已存在则先移除
        if let old = cache[key] {
            currentSize -= old.size
            cache.removeValue(forKey: key)
            accessOrder.removeAll(where: { $0 == key })
        }

        // 插入新值
        cache[key] = CacheEntry(data: data, size: size)
        accessOrder.append(key)
        currentSize += size

        // 内存超出限制 -> 逐个淘汰 LRU
        trimIfNeeded()
    }

    private func trimIfNeeded() {
        while currentSize > maxMemorySize, let oldestKey = accessOrder.first {
            if let entry = cache[oldestKey] {
                currentSize -= entry.size
            }
            cache.removeValue(forKey: oldestKey)
            accessOrder.removeFirst()
        }
    }
}
actor NetWorkQueue {
    private var queue: [String] = []

    func contains(_ key: String) -> Bool {
        return queue.contains(key)
    }

    func append(_ key: String) {
        queue.append(key)
    }
    func remove(_ key: String) {
        if let index = queue.firstIndex(of: key) {
            queue.remove(at: index)
        }
    }
}

actor ItunesSongCache {
    private var cache: [String: SongSearchResult.Song] = [:]
    private var ongoingTasks: [String: Task<SongSearchResult.Song, Error>] = [:]
    private var keysOrder: [String] = []
    private let maxSize: Int
    init(maxSize: Int = 30) {
        self.maxSize = maxSize
    }
    func get(for key: String) -> SongSearchResult.Song? {
        return cache[key]
    }

    func set(_ song: SongSearchResult.Song, for key: String) {
        if cache[key] == nil {
            keysOrder.append(key)
        }
        cache[key] = song
        ongoingTasks[key] = nil
        enforceLimit()
    }
    private func enforceLimit() {
        while keysOrder.count > maxSize {
            let oldestKey = keysOrder.removeFirst()
            cache[oldestKey] = nil
        }
    }
    func task(for key: String) -> Task<SongSearchResult.Song, Error>? {
        return ongoingTasks[key]
    }

    func setTask(_ task: Task<SongSearchResult.Song, Error>, for key: String) {
        ongoingTasks[key] = task
    }
    func removeTask(for key: String) {
        ongoingTasks[key] = nil
    }
}


// ===============================
// FILE: ./AudioSync/model/Key.swift
// ===============================
// API Key
import Foundation

struct Key {
    static let siliconFlow: String =
        "sk-sgcoykpiuvezprgkqdkccxwlmxyhbixkfgfvvdffovsuoemx"
    static let lastfm: String = "7c53dde26c531f5d311fd23734b54150"
}


// ===============================
// FILE: ./AudioSync/model/LyricStruct.swift
// ===============================
import Foundation


public struct LyricLine: Decodable, Hashable, Encodable, Equatable {
    public var startTimeMS: TimeInterval
    public let words: String
    public var attachments: Attachments
    public let id = UUID()

    enum CodingKeys: String, CodingKey {
        case startTimeMS = "startTimeMs"
        case words
        case attachments
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        do {
            self.startTimeMS = try container.decode(
                TimeInterval.self, forKey: .startTimeMS)
        } catch {
            let str = try container.decode(String.self, forKey: .startTimeMS)
            self.startTimeMS = TimeInterval(str) ?? 0
        }
        self.words = try container.decode(String.self, forKey: .words)
        self.attachments =
            try container.decodeIfPresent(
                Attachments.self, forKey: .attachments) ?? Attachments()
    }

    init(
        startTime: TimeInterval, words: String,
        attachments: Attachments = Attachments()
    ) {
        self.startTimeMS = startTime
        self.words = words
        self.attachments = attachments
    }
}

struct NetEaseSearch: Decodable {
    let result: Result

    struct Result: Decodable {
        let songs: [Song]

        struct Song: Decodable {
            let name: String
            let id: Int
            let duration: Int?  // milliseconds
            let al: Album
            let ar: [Artist]
        }

        struct Album: Decodable {
            let id: Int
            let name: String
            let picUrl: String
        }

        struct Artist: Decodable {
            let name: String
        }
    }
}
struct NetEaseArtist: Decodable{
    let result: NetEaseArtist.Result
    
    struct Result: Decodable {
        let artists: [NetEaseArtist.Artist]
    }
    struct Artist: Decodable {
        let name: String
        let picUrl: String
        let id: Int
    }
}

struct NetEaseLyrics: Decodable {
    let lrc: Lyric?
    let klyric: Lyric?
    let tlyric: Lyric?
    let lyricUser: User?
    let yrc: Lyric?
    /*
    let sgc: Bool
    let sfy: Bool
    let qfy: Bool
    let code: Int
    let transUser: User
     */

    struct User: Decodable {
        let nickname: String

        /*
        let id: Int
        let status: Int
        let demand: Int
        let userid: Int
        let uptime: Int
         */
    }

    struct Lyric: Decodable {
        let lyric: String?

        /*
        let version: Int
         */
    }
}
struct QQSearch: Decodable {
    let data: Data
    let code: Int

    struct Data: Decodable {
        let song: Song
        struct Song: Decodable {
            let list: [Item]
            struct Item: Decodable {
                let songmid: String
                let songname: String
                let albumname: String
                let albummid: String
                let albumid: Int?
                let singer: [Singer]
                let interval: Int?
                struct Pay: Decodable {
                    let payalbum: Int
                    let payalbumprice: Int
                    let paydownload: Int
                    let payinfo: Int
                    let payplay: Int
                    let paytrackmouth: Int
                    let paytrackprice: Int
                }
                struct Preview: Decodable {
                    let trybegin: Int
                    let tryend: Int
                    let trysize: Int
                }
                struct Singer: Decodable {
                    let name: String
                }
            }
        }
    }
}

struct QQLyrics: Decodable {
    let retcode: Int
    let code: Int
    let subcode: Int
    let lyric: Data
    let trans: Data?
}
struct QQAlbum: Decodable, Encodable{
    let code: Int
    let data:Album
    struct Album: Decodable, Encodable {
        let album_id:String?
        let album_mid: String
        let album_name: String?
        let headpiclist: [Headpiclist]
        struct Headpiclist: Decodable, Encodable{
            let picurl: String
        }
    }
}
extension QQLyrics {

    var lyricString: String? {
        return String(data: lyric, encoding: .utf8)?.decodingXMLEntities()
    }

    var transString: String? {
        guard let data = trans,
            let string = String(data: data, encoding: .utf8)
        else {
            return nil
        }
        return string.decodingXMLEntities()
    }
}

struct OriginalName: Decodable, Encodable {
    let trackName: String
    let artist: String
    let album: String
}

public struct Attachments: Codable, Hashable {
    var content: [Tag: LyricsLineAttachment] = [:]

    subscript(tag: Tag) -> LyricsLineAttachment? {
        get { content[tag] }
        set { content[tag] = newValue }
    }

    enum Tag: String, Codable, Hashable {
        case translation = "tr"

        static func translation() -> Tag { .translation }
    }
}

enum LyricsLineAttachment: Codable, Hashable {
    case plainText(String)

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let text = try container.decode(String.self)
        self = .plainText(text)
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .plainText(let str):
            try container.encode(str)
        }
    }

}
extension LyricsLineAttachment {
    var stringValue: String? {
        if case let .plainText(str) = self {
            return str
        }
        return nil
    }
}

extension String {

    private static let xmlEntities: [Substring: Character] = [
        "&quot;": "\"",
        "&amp;": "&",
        "&apos;": "'",
        "&lt;": "<",
        "&gt;": ">",
    ]

    func decodingXMLEntities() -> String {

        // ===== Utility functions =====

        // Convert the number in the string to the corresponding
        // Unicode character, e.g.
        //    decodeNumeric("64", 10)   --> "@"
        //    decodeNumeric("20ac", 16) --> "€"
        func decodeNumeric(_ string: Substring, base: Int) -> Character? {
            guard let code = UInt32(string, radix: base),
                let uniScalar = UnicodeScalar(code)
            else { return nil }
            return Character(uniScalar)
        }

        // Decode the HTML character entity to the corresponding
        // Unicode character, return `nil` for invalid input.
        //     decode("&#64;")    --> "@"
        //     decode("&#x20ac;") --> "€"
        //     decode("&lt;")     --> "<"
        //     decode("&foo;")    --> nil
        func decode(_ entity: Substring) -> Character? {

            if entity.hasPrefix("&#x") || entity.hasPrefix("&#X") {
                return decodeNumeric(entity.dropFirst(3).dropLast(), base: 16)
            } else if entity.hasPrefix("&#") {
                return decodeNumeric(entity.dropFirst(2).dropLast(), base: 10)
            } else {
                return String.xmlEntities[entity]
            }
        }

        // ===== Method starts here =====

        var result = ""
        var position = startIndex

        // Find the next '&' and copy the characters preceding it to `result`:
        while let ampRange = self[position...].range(of: "&") {
            result.append(contentsOf: self[position..<ampRange.lowerBound])
            position = ampRange.lowerBound

            // Find the next ';' and copy everything from '&' to ';' into `entity`
            guard let semiRange = self[position...].range(of: ";") else {
                // No matching ';'.
                break
            }
            let entity = self[position..<semiRange.upperBound]
            position = semiRange.upperBound

            if let decoded = decode(entity) {
                // Replace by decoded character:
                result.append(decoded)
            } else {
                // Invalid entity, copy verbatim:
                result.append(contentsOf: entity)
            }
        }
        // Copy remaining characters to `result`:
        result.append(contentsOf: self[position...])
        return result
    }
}


// ===============================
// FILE: ./AudioSync/model/Song.swift
// ===============================
import SwiftData
import Foundation

@Model
final class Song {
    @Attribute(.unique) var id: String
    var trackName: String
    var lyricsData: Data?

    // 自定义属性（不存储，只是映射）
    var lyrics: [LyricLine] {
        get {
            guard let data = lyricsData else { return [] }
            return (try? JSONDecoder().decode([LyricLine].self, from: data)) ?? []
        }
        set {
            lyricsData = try? JSONEncoder().encode(newValue)
        }
    }

    init(id: String, trackName: String, lyrics: [LyricLine]) {
        self.id = id
        self.trackName = trackName
        self.lyricsData = try? JSONEncoder().encode(lyrics)
    }

    func setLyrics(_ lines: [LyricLine]) {
        lyrics = lines
    }

    func getLyrics() -> [LyricLine] {
        lyrics
    }
}


// ===============================
// FILE: ./AudioSync/model/ViewModel.swift
// ===============================
import AppKit
import Combine
//
//  ViewModel.swift
//  AudioSync
//
//  Created by solo on 5/12/25.
//
import Foundation
import ScriptingBridge
import SwiftUI

@MainActor
class ViewModel: ObservableObject {

    static let shared: ViewModel = ViewModel()
    @Published var currentlyPlayingLyrics: [LyricLine] = []
    @Published var currentlyPlayingLyricsIndex: Int?
    @Published var karaokeFont: NSFont = NSFont.boldSystemFont(ofSize: 30)
    @Published var translationExists: Bool = true
    @Published var karaokeShowMultilingual: Bool = true
    @Published var isViewLyricsShow: Bool = false
    @Published var isLyricsPlaying: Bool = false
    @Published var allCandidates: [CandidateSong] = []
    @Published var needNanualSelection: Bool = false
    @Published var currentTrack: TrackInfo?
    @Published var scrollProxy: ScrollViewProxy?
    @Published var isCurrentTrackPlaying: Bool = false
    @Published var similarArtists: [Artist] = []
    @Published var currentAlbum: String?
    @Published var currentSong: String?
    @Published var refreshSimilarArtist: Bool = false
    @Published var enableAudioSync: Bool = true
    @Published var finishSwitch: String?
    var onCandidateSelected: ((CandidateSong) -> Void)?  // ❗️等待用的回调

    lazy var appleMusicScript: MusicApplication? = SBApplication(
        bundleIdentifier: "com.apple.Music"
    )
    private var currentLyricsUpdaterTask: Task<Void, Error>?

    private var cancellables = Set<AnyCancellable>()

    private func lyricUpdater() async throws {
        repeat {
            Log.general.debug(
                "lyric index: \(String(describing: self.currentlyPlayingLyricsIndex))"
            )
            guard let script = self.appleMusicScript else {
                Log.general.info("no script")
                // pauses the timer bc there's no player position
                stopLyricUpdater()
                return
            }
            guard let playerPosition = script.playerPosition else {
                Log.general.info("no player position hence stopped")
                // pauses the timer bc there's no player position
                stopLyricUpdater()
                return
            }
            Log.general.debug("script player position: \(playerPosition)")
            // add a 700 (milisecond?) delay to offset the delta between spotify lyrics and apple music songs (or maybe the way apple music delivers playback position)
            // No need for Spotify Connect delay or fullscreen, this is APPLE MUSIC
            let currentTime = playerPosition * 1000 + 400
            guard let lastIndex: Int = upcomingIndex(currentTime) else {
                stopLyricUpdater()
                return
            }
            // If there is no current index (perhaps lyric updater started late and we're mid-way of the first lyric, or the user scrubbed and our index is expired)
            // Then we set the current index to the one before our anticipated index
            if currentlyPlayingLyricsIndex == nil && lastIndex > 0 {
                withAnimation(.linear(duration: 0.2)) {
                    currentlyPlayingLyricsIndex = lastIndex - 1
                }
            }

            let nextTimestamp = currentlyPlayingLyrics[lastIndex].startTimeMS
            let diff = nextTimestamp - currentTime
            Log.general.debug(
                "current time: \(currentTime). next time: \(nextTimestamp). the difference is \(diff)"
            )
            try await Task.sleep(nanoseconds: UInt64(1_000_000 * diff))
            Log.general.debug("last index: \(lastIndex)")
            if currentlyPlayingLyrics.count > lastIndex {
                withAnimation(.linear(duration: 0.2)) {
                    currentlyPlayingLyricsIndex = lastIndex
                }
            } else {
                currentlyPlayingLyricsIndex = nil
            }
            Log.general.info(
                "current lyrics index is now \(String(describing: self.currentlyPlayingLyricsIndex))"
            )
        } while !Task.isCancelled
    }

    func startLyricUpdater() {
        Log.general.debug("start update task")
        Log.general.debug(
            "isViewLyricsShow: \(self.isViewLyricsShow), lyrics.isEmpty: \(self.currentlyPlayingLyrics.isEmpty)"
        )
        currentLyricsUpdaterTask?.cancel()
        currentLyricsUpdaterTask = Task {
            do {
                try await lyricUpdater()
            } catch {
                Log.general.info("lyric updater were canceled \(error)")
            }
        }
    }

    func stopLyricUpdater() {
        Log.general.debug("stop lyric updater")
        currentLyricsUpdaterTask?.cancel()
    }

    func upcomingIndex(_ currentTime: Double) -> Int? {
        if let currentlyPlayingLyricsIndex {
            let newIndex = currentlyPlayingLyricsIndex + 1
            if newIndex >= currentlyPlayingLyrics.count {
                Log.general.warning("⚠️ REACHED LAST LYRIC!!!!!!!!")
                // if current time is before our current index's start time, the user has scrubbed and rewinded
                // reset into linear search mode
                if currentTime
                    < currentlyPlayingLyrics[currentlyPlayingLyricsIndex]
                    .startTimeMS
                {
                    return currentlyPlayingLyrics.firstIndex(where: {
                        $0.startTimeMS > currentTime
                    })
                }
                return nil
            } else if currentTime
                > currentlyPlayingLyrics[currentlyPlayingLyricsIndex]
                .startTimeMS,
                currentTime < currentlyPlayingLyrics[newIndex].startTimeMS
            {
                Log.general.info("just the next lyric")
                return newIndex
            }
        }
        // linear search through the array to find the first lyric that's right after the current time
        // done on first lyric update for the song, as well as post-scrubbing
        return currentlyPlayingLyrics.firstIndex(where: {
            $0.startTimeMS > currentTime
        })
    }

}
extension NSImage {
    func toSwiftUIImage() -> Image {
        Image(nsImage: self)
    }
    func findDominantColors(maxK: Int = 3) -> [Color]? {
        guard let tiffData = self.tiffRepresentation,
            let bitmap = NSBitmapImageRep(data: tiffData),
            let cgImage = bitmap.cgImage
        else {
            return nil
        }

        let size = CGSize(width: 128, height: 128)
        guard
            let context = CGContext(
                data: nil,
                width: Int(size.width),
                height: Int(size.height),
                bitsPerComponent: 8,
                bytesPerRow: Int(size.width) * 4,
                space: CGColorSpaceCreateDeviceRGB(),
                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
            )
        else { return nil }

        context.draw(cgImage, in: CGRect(origin: .zero, size: size))
        guard let data = context.data else { return nil }
        let ptr = data.bindMemory(
            to: UInt8.self,
            capacity: Int(size.width * size.height * 4)
        )

        var points: [(CGFloat, CGFloat, CGFloat)] = []

        for x in 0..<Int(size.width) {
            for y in 0..<Int(size.height) {
                let offset = 4 * (y * Int(size.width) + x)
                let r = CGFloat(ptr[offset]) / 255.0
                let g = CGFloat(ptr[offset + 1]) / 255.0
                let b = CGFloat(ptr[offset + 2]) / 255.0
                let a = CGFloat(ptr[offset + 3]) / 255.0
                if a > 0.5 {
                    points.append((r, g, b))
                }
            }
        }

        // 自动确定聚类数 k（不超过 maxK）
        let k = min(maxK, max(1, Int(sqrt(Double(points.count)) / 2)))

        guard points.count >= k else { return nil }

        // 简易 k-means 聚类
        var centroids = points.shuffled().prefix(k)
        var clusters: [[(CGFloat, CGFloat, CGFloat)]] = Array(
            repeating: [],
            count: k
        )

        for _ in 0..<10 {
            clusters = Array(repeating: [], count: k)
            for point in points {
                let index = centroids.enumerated().min(by: {
                    pow($0.1.0 - point.0, 2) + pow($0.1.1 - point.1, 2)
                        + pow($0.1.2 - point.2, 2)
                        < pow($1.1.0 - point.0, 2) + pow($1.1.1 - point.1, 2)
                        + pow($1.1.2 - point.2, 2)
                })!.offset
                clusters[index].append(point)
            }

            for i in 0..<k {
                if clusters[i].isEmpty { continue }
                let sum = clusters[i].reduce((0.0, 0.0, 0.0)) {
                    ($0.0 + $1.0, $0.1 + $1.1, $0.2 + $1.2)
                }
                let count = CGFloat(clusters[i].count)
                centroids[i] = (sum.0 / count, sum.1 / count, sum.2 / count)
            }
        }

        // 排序并输出颜色
        let sorted = clusters.enumerated().sorted {
            $0.element.count > $1.element.count
        }
        return sorted.map {
            let sum = $0.element.reduce((0.0, 0.0, 0.0)) {
                ($0.0 + $1.0, $0.1 + $1.1, $0.2 + $1.2)
            }
            let count = CGFloat($0.element.count)
            return Color(
                red: sum.0 / count,
                green: sum.1 / count,
                blue: sum.2 / count
            )
        }
    }

}
struct CandidateSong: Sendable {
    let id: String
    let name: String
    let artist: String
    let album: String
    var albumId: String
    var albumCover: String
    let source: LyricsFormat
}


// ===============================
// FILE: ./AudioSync/service/AppDelegate.swift
// ===============================
//
//  ContentView.swift
//  AudioSync
//
//  Created by solo on 4/29/25.
//

import AppKit
import Cocoa
import Combine
import CoreAudio
import Foundation
import MusicKit
import SwiftData
import SwiftUI
import UserNotifications

class AppDelegate: NSObject, NSApplicationDelegate,
    UNUserNotificationCenterDelegate
{
    var statusBarItem: NSStatusItem!
    var audioManager = AudioFormatManager.shared
    var playbackNotifier: PlaybackNotifier?
    var networkUtil: NetworkUtil?
    @ObservedObject var viewModel: ViewModel = ViewModel.shared
    private var cancellables = Set<AnyCancellable>()
    var modelContainer: ModelContainer?
    private var networkQueue = NetWorkQueue()

    func applicationDidFinishLaunching(_ notification: Notification) {

        NSApp.setActivationPolicy(.accessory)

        UNUserNotificationCenter.current().delegate = self
        Task { @MainActor in
            playbackNotifier = PlaybackNotifier(viewModel: self.viewModel)
            networkUtil = NetworkUtil(viewModel: self.viewModel)

            self.playbackNotifier?.onPlay = {
                [weak self] trackInfo, trigger in
                Log.backend.debug("playbackNotifier.onPlay \(trigger)")
                guard let self = self else {
                    return
                }
                // 采样率和位深同步
                if trigger == .formatSwitch {
                    await withCheckedContinuation { continuation in
                        var didResume = false
                        Task {
                            self.audioManager.onFormatUpdate = {
                                sampleRate,
                                bitDepth in
                                self.audioManager.updateOutputFormat()
                                if !didResume {
                                    didResume = true
                                    continuation.resume()
                                }
                            }
                            self.audioManager.startMonitoring()
                            DispatchQueue.main.asyncAfter(
                                deadline: .now() + 5.0
                            ) {
                                if !didResume {
                                    didResume = true
                                    continuation.resume()
                                }
                                self.audioManager.stopMonitoring()
                            }

                        }
                    }
                }
                // 歌词
                if trigger == .lyrics {
                    Task { [weak self] in
                        guard let self else { return }

                        viewModel.isLyricsPlaying = false
                        if viewModel.isCurrentTrackPlaying
                            && viewModel.isViewLyricsShow
                        {
                            if loadLyricsFromLocal() {
                                return
                            }

                            await loadLyricsFromNetwork()
                        }

                    }
                }
            }

            viewModel.$refreshSimilarArtist
                .removeDuplicates()
                .sink { [weak self] refreshSimilarArtist in
                    guard let self = self else { return }
                    if refreshSimilarArtist {
                        networkUtil?.fetchSimilarArtistsAndCovers()
                        viewModel.refreshSimilarArtist = false
                    }

                }
                .store(in: &cancellables)

            viewModel.$isViewLyricsShow
                .removeDuplicates()
                .sink { [weak self] isShowLyrics in
                    guard let self = self else { return }
                    Log.general.debug("显示歌词 -> \(isShowLyrics)")
                    if isShowLyrics {
                        Task {
                            if let onPlay = self.playbackNotifier?.onPlay {
                                await onPlay(nil, .lyrics)
                            }
                        }
                    } else {
                        viewModel.stopLyricUpdater()
                    }
                }
                .store(in: &cancellables)

            viewModel.$isLyricsPlaying
                .removeDuplicates()
                .sink { [weak self] isLyricsPlaying in
                    guard let self = self else { return }
                    Log.general.debug("isLyricsPlaying -> \(isLyricsPlaying)")
                    if isLyricsPlaying {
                        viewModel.startLyricUpdater()
                    } else {
                        viewModel.stopLyricUpdater()
                        viewModel.currentlyPlayingLyricsIndex = nil
                    }
                }
                .store(in: &cancellables)

        }
        Task {
            let _ = await MusicKit.MusicAuthorization.request()

            do {
                try await UNUserNotificationCenter.current()
                    .requestAuthorization(options: [.alert, .sound, .badge])
            } catch {
                Log.backend.error("用户拒绝了通知权限")
            }
            // 出发启动时歌词显示
            if let onPlay = self.playbackNotifier?.onPlay {
                await onPlay(nil, .lyrics)
            }

        }

    }
    private func loadLyricsFromLocal() -> Bool {
        guard let modelContext = modelContainer?.mainContext else {
            return false
        }
        guard let trackID = viewModel.currentTrack?.trackID else {
            return false
        }
        let descriptor = FetchDescriptor<Song>(
            predicate: #Predicate { $0.id == trackID }
        )

        if let song = try? modelContext.fetch(descriptor).first {
            let localLyrics = song.getLyrics()
            if !localLyrics.isEmpty {
                Log.general.debug("本地歌词")
                viewModel.currentlyPlayingLyrics = localLyrics
                viewModel.isLyricsPlaying = true
                return true
            }
        }
        return false
    }

    private func loadLyricsFromNetwork() async {
        guard let trackInfo = viewModel.currentTrack else {
            return
        }
        let trackName = trackInfo.name
        let artist = trackInfo.artist
        let queueKey = "\(trackName)-\(artist)"

        do {
            if await networkQueue.contains(queueKey) {
                return
            }
            await networkQueue.append(queueKey)
            guard !trackName.isEmpty, !artist.isEmpty else {
                Log.general.warning("⚠️ 原始标题或艺术家为空，跳过歌词请求")
                return
            }

            if let lyrics = try await networkUtil?.fetchLyrics(
                trackName: trackName,
                artist: artist,
                trackID: trackInfo.trackID,
                album: trackInfo.album,
                genre: trackInfo.genre
            ), !lyrics.isEmpty {
                let finishLyrics = finishLyric(lyrics)
                Log.general.debug("网络歌词")

                viewModel.currentlyPlayingLyrics = finishLyrics
                viewModel.isLyricsPlaying = true

                // song 保存
                guard let modelContext = modelContainer?.mainContext else {
                    return
                }
                let song = Song(
                    id: trackInfo.trackID,
                    trackName: trackName,
                    lyrics: finishLyrics
                )
                modelContext.insert(song)
                try? modelContext.save()
                await networkQueue.remove(queueKey)
            }

        } catch {
            Log.general.error("网络歌词获取失败: \(error)")
            Log.notice.notice(
                "网络歌词获取失败",
                error.localizedDescription
            )
            await networkQueue.remove(queueKey)
        }
    }

    func finishLyric(_ rawLyrics: [LyricLine]) -> [LyricLine] {
        guard let last = rawLyrics.last else { return rawLyrics }
        let virtualEndLine = LyricLine(
            startTime: last.startTimeMS + 5000,
            words: ""
        )
        return rawLyrics + [virtualEndLine]
    }

    @objc func delCurrentSongObject() {
        guard let trackID = viewModel.currentTrack?.trackID
        else {
            return
        }
        viewModel.isLyricsPlaying = false
        // 删除song
        let modelContext = modelContainer?.mainContext
        let descriptor = FetchDescriptor<Song>(
            predicate: #Predicate { $0.id == trackID }
        )
        if let song = try? modelContext?.fetch(descriptor).first {
            modelContext?.delete(song)
            try? modelContext?.save()
        }

        Task {
            if let onPlay = playbackNotifier?.onPlay {
                await onPlay(nil, .lyrics)
            }
        }
    }

    @objc func manualNamefetch() {
        Task {
            await manulNameAsyncFetch()
        }
    }

    private func manulNameAsyncFetch() async {
        do {
            guard
                let manualName = NSPasteboard.general.string(forType: .string),
                !manualName.trimmingCharacters(in: .whitespacesAndNewlines)
                    .isEmpty
            else {
                Log.general.warning("⚠️ 粘贴板中没有字符串内容")
                Log.notice.notice(
                    "空歌曲名",
                    "⚠️ 粘贴板中没有字符串内容"
                )
                return
            }
            Log.general.debug("来自粘贴板的歌曲: \(manualName)")
            guard let currentTrack = viewModel.currentTrack else {
                return
            }
            viewModel.isLyricsPlaying = false
            let netEaseLyrics = try await networkUtil?.fetchLyrics(
                trackName: manualName,
                artist: currentTrack.artist,
                trackID: currentTrack.trackID,
                album: currentTrack.album,
                genre: currentTrack.genre
            )

            if !netEaseLyrics!.isEmpty {
                guard let modelContext = modelContainer?.mainContext else {
                    return
                }
                let finishLyrics = finishLyric(netEaseLyrics!)
                let trackID = currentTrack.trackID
                let descriptor = FetchDescriptor<Song>(
                    predicate: #Predicate { $0.id == trackID }
                )
                if let song = try? modelContext.fetch(descriptor).first {
                    modelContext.delete(song)
                }
                let songNew = Song(
                    id: currentTrack.trackID,
                    trackName: currentTrack.name,
                    lyrics: finishLyrics
                )
                modelContext.insert(songNew)

                try? modelContext.save()

                Task {
                    if let onPlay = playbackNotifier?.onPlay {
                        await onPlay(nil, .lyrics)
                    }
                }
            }

        } catch {
            Log.general.error("粘贴板获取歌词失败：\(error)")
        }
    }

    @objc func similarSongTapped() {
        guard let name = viewModel.currentTrack?.name,
            let artist = viewModel.currentTrack?.artist
        else {
            return
        }
        Task {
            let fetched = try? await networkUtil?.fetchSimilarSongs(
                name: name,
                artist: artist
            )
            Log.backend.debug("相似歌曲: \(JSON.stringify(fetched))")
            guard let script = viewModel.appleMusicScript else { return }

        }
    }
}

// 修改后的AudioFormatManager类

// 保持Core Audio相关扩展和工具方法不变
extension OSStatus {
    func toHexString() -> String {
        return String(format: "0x%08X", self)
    }
}
// 3. ✅ 实现代理方法，允许前台通知
extension AppDelegate {
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler:
            @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        // 告诉系统：即使应用在前台，也要显示 Banner 和声音
        // 注意：macOS 11.0+ 使用 .banner，旧版本可能使用 .alert
        if #available(macOS 11.0, *) {
            completionHandler([.banner, .sound])
        } else {
            completionHandler([.alert, .sound])
        }
    }
}


// ===============================
// FILE: ./AudioSync/service/AudioFormatManager.swift
// ===============================
import Combine
import CoreAudio

class AudioFormatManager: ObservableObject {
    @MainActor static let shared: AudioFormatManager = AudioFormatManager()
    @Published var sampleRate: Int?
    @Published var bitDepth: Int?

    private static let logRegex: NSRegularExpression? = {
        let pattern = #"(\d+) Hz.*?from (\d+)-bit source"#
        return try? NSRegularExpression(pattern: pattern)
    }()
    var needChange: Bool = true
    var currentFormat: (sampleRate: Int, bitDepth: Int) = (0, 0) {
        didSet {
            Log.backend.info("Format change from \(oldValue) to \(currentFormat)")
            // 避免不必要的更新，如果值没有实际变化
            if oldValue.sampleRate != currentFormat.sampleRate
                || oldValue.bitDepth != currentFormat.bitDepth
            {
                sampleRate = currentFormat.sampleRate
                bitDepth = currentFormat.bitDepth
                needChange = true
                onFormatUpdate?(
                    currentFormat.sampleRate,
                    currentFormat.bitDepth
                )
            } else {
                needChange = false
            }
        }
    }
    var onFormatUpdate: ((Int, Int) -> Void)?

    // 保持原有日志监控和格式设置逻辑...
    // [原有代码的私有属性和方法保持不变]
    private var logProcess: Process?
    private var logPipe: Pipe?
    private var isMonitoring = false
    private let processingQueue = DispatchQueue(
        label: "com.audio.format.monitor",
        qos: .userInitiated
    )

    private var lastLogEntry: String = ""
    private var lastLogTime: TimeInterval = 0

    func startMonitoring() {
        guard !isMonitoring else { return }
        isMonitoring = true
        Log.backend.info("start log monitoring")
        // 先抓过去 1 秒的历史日志，避免漏掉启动前的 Input format
        fetchRecentLogs()

        setupLogProcess()
    }

    private func isDeviceRunning(_ deviceID: AudioDeviceID) -> Bool {
        var isRunning: UInt32 = 0
        var size = UInt32(MemoryLayout.size(ofValue: isRunning))
        var address = AudioObjectPropertyAddress(
            mSelector: kAudioDevicePropertyDeviceIsRunning,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain
        )

        let status = AudioObjectGetPropertyData(
            deviceID,
            &address,
            0,
            nil,
            &size,
            &isRunning
        )

        return status == noErr && isRunning != 0
    }
    private func fetchRecentLogs() {
        // 在后台队列中执行，避免阻塞主线程
        processingQueue.async { [weak self] in
            let showProcess = Process()
            showProcess.executableURL = URL(fileURLWithPath: "/usr/bin/log")
            showProcess.arguments = [
                "show",
                "--style", "syslog",
                "--last", "1s",
                "--predicate",
                "process == 'Music' AND message CONTAINS 'ACAppleLosslessDecoder' AND message CONTAINS 'Input format' AND message CONTAINS 'source'",
                "--info",
            ]

            let pipe = Pipe()
            showProcess.standardOutput = pipe

            do {
                try showProcess.run()

                // 同步读取所有输出数据，直到进程结束
                let data = pipe.fileHandleForReading.readDataToEndOfFile()
                showProcess.waitUntilExit()  // 确保进程已完全终止

                if let output = String(data: data, encoding: .utf8),
                    !output.isEmpty
                {
                    self?.parseLogOnBackground(output)
                }
            } catch {
                Log.backend.error(
                    "AudioFormatManager: fetchRecentLogs error: \(error)"
                )
            }
        }
    }
    private func setupLogProcess() {
        logProcess = Process()
        logProcess?.executableURL = URL(fileURLWithPath: "/usr/bin/log")
        logProcess?.arguments = [
            "stream",
            "--predicate",
            "process == 'Music' AND message CONTAINS 'ACAppleLosslessDecoder' AND message CONTAINS 'Input format' AND message CONTAINS 'source'",
            "--info",
        ]

        let pipe = Pipe()
        self.logPipe = pipe
        logProcess?.standardOutput = pipe

        // 2. ✅ 优化读取处理逻辑
        pipe.fileHandleForReading.readabilityHandler = { [weak self] handle in
            // 使用 autoreleasepool 确保每次读取的临时变量立即释放
            autoreleasepool {
                let data = handle.availableData
                guard !data.isEmpty else { return }

                guard let output = String(data: data, encoding: .utf8) else {
                    return
                }

                // 3. ✅ 在后台线程直接解析，不要派发给 MainActor
                self?.parseLogOnBackground(output)
            }
        }

        logProcess?.terminationHandler = { process in
            DispatchQueue.main.async {
                if AudioFormatManager.shared.isMonitoring == true {  // 仅在仍在监控状态时重置
                    AudioFormatManager.shared.isMonitoring = false
                }
            }
        }

        do {
            try logProcess?.run()
        } catch {
            Log.backend.error(
                "AudioFormatManager: setupLogProcess   error: \(error)"
            )
            DispatchQueue.main.async {
                AudioFormatManager.shared.isMonitoring = false  // 启动失败，重置状态
            }
        }
    }
    private func parseLogOnBackground(_ log: String) {
        let now = Date().timeIntervalSince1970
        guard let regex = AudioFormatManager.logRegex else { return }

        let nsLog = log as NSString

        regex.enumerateMatches(
            in: log,
            range: NSRange(location: 0, length: nsLog.length)
        ) { match, _, _ in
            guard let match = match, match.numberOfRanges >= 3 else { return }

            let sampleRateStr = nsLog.substring(with: match.range(at: 1))
            let bitDepthStr = nsLog.substring(with: match.range(at: 2))

            if let sr = Int(sampleRateStr), let bd = Int(bitDepthStr) {
                // 5. ✅ 解析成功后，再检查是否需要更新，减少主线程负担
                if self.currentFormat.sampleRate == sr,
                    self.currentFormat.bitDepth == bd
                {
                    return
                }
                // 只有真正需要更新时，才切回主线程
                Task { @MainActor in
                    AudioFormatManager.shared.currentFormat = (sr, bd)
                    AudioFormatManager.shared.stopMonitoring()
                }
            }
        }
    }

    func updateOutputFormat() {
        if !needChange {
            return
        }
        guard let deviceID = getDefaultOutputDevice(),
            deviceID != kAudioObjectUnknown
        else {
            return
        }

        setNominalSampleRate(currentFormat.sampleRate, for: deviceID)
        setStreamBitDepth(currentFormat.bitDepth, for: deviceID)
    }

    func stopMonitoring() {
        guard isMonitoring else { return }
        Log.backend.info("stop log monitoring")
        // 1. 清理流式监控的 handler
        logPipe?.fileHandleForReading.readabilityHandler = nil

        // 2. 终止流式监控的进程
        if logProcess?.isRunning == true {
            logProcess?.terminate()
        }

        // 3. 释放资源引用
        logProcess = nil
        logPipe = nil

        DispatchQueue.main.async {
            AudioFormatManager.shared.isMonitoring = false
        }
    }

    deinit {
        // 清理 Process 资源
        logProcess?.terminate()
        logProcess = nil
    }

    private func setNominalSampleRate(_ rate: Int, for device: AudioDeviceID) {

        var address = AudioObjectPropertyAddress(
            mSelector: kAudioDevicePropertyNominalSampleRate,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain
        )

        var sampleRate = Float64(rate)
        let status = AudioObjectSetPropertyData(
            device,
            &address,
            0,
            nil,
            UInt32(MemoryLayout.size(ofValue: sampleRate)),
            &sampleRate
        )

        if status != noErr {
            Log.backend.error("Sample rate set  \(status)")
        }
    }

    private func getDefaultOutputDevice() -> AudioDeviceID? {
        var deviceID: AudioDeviceID = kAudioObjectUnknown
        var address = AudioObjectPropertyAddress(
            mSelector: kAudioHardwarePropertyDefaultOutputDevice,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain
        )

        var size = UInt32(MemoryLayout.size(ofValue: deviceID))
        guard
            AudioObjectGetPropertyData(
                AudioObjectID(kAudioObjectSystemObject),
                &address,
                0,
                nil,
                &size,
                &deviceID
            ) == noErr
        else {
            return nil
        }
        return deviceID
    }
    private func getDeviceName(_ deviceID: AudioDeviceID) -> String? {
        var name: CFString = "" as CFString
        var size = UInt32(MemoryLayout<CFString>.size)
        var address = AudioObjectPropertyAddress(
            mSelector: kAudioObjectPropertyName,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain
        )

        let status = AudioObjectGetPropertyData(
            deviceID,
            &address,
            0,
            nil,
            &size,
            &name
        )
        if status == noErr {
            return name as String
        } else {
            return nil
        }
    }
    private func setStreamBitDepth(_ depth: Int, for device: AudioDeviceID) {
        // 先获取设备的所有输出流
        guard let streams = getOutputStreams(for: device) else {
            Log.backend.error("无法获取输出流")
            return
        }

        for stream in streams {
            // 1. 获取该流支持的物理格式
            guard let supportedFormats = getSupportedFormats(for: stream) else {
                continue
            }

            // 2. 寻找匹配的格式
            let targetFormat = findMatchingFormat(
                supportedFormats,
                depth: depth,
                rate: currentFormat.sampleRate
            )

            // 3. 设置物理格式
            var address = AudioObjectPropertyAddress(
                mSelector: kAudioStreamPropertyPhysicalFormat,
                mScope: kAudioObjectPropertyScopeGlobal,
                mElement: 0
            )

            var format = targetFormat.mFormat
            let status = AudioObjectSetPropertyData(
                stream,  // 关键修改：在stream上设置而不是device
                &address,
                0,
                nil,
                UInt32(MemoryLayout<AudioStreamBasicDescription>.size),
                &format
            )

            if status == noErr {
                let deviceName =
                    getDeviceName(device) as NSString? ?? "Unknown Device"
                Log.backend.info(
                    "成功为「\(deviceName)」同步格式：\(format.mBitsPerChannel)bit/\(format.mSampleRate)Hz"
                )
            } else {
                Log.backend.error("设置失败 - \(status)")
            }
        }
    }

    // 新增方法：获取设备的所有输出流
    private func getOutputStreams(for device: AudioDeviceID) -> [AudioStreamID]?
    {
        var address = AudioObjectPropertyAddress(
            mSelector: kAudioDevicePropertyStreams,
            mScope: kAudioDevicePropertyScopeOutput,
            mElement: 0
        )

        var dataSize: UInt32 = 0
        guard
            AudioObjectGetPropertyDataSize(device, &address, 0, nil, &dataSize)
                == noErr
        else {
            return nil
        }

        let streamCount = Int(dataSize) / MemoryLayout<AudioStreamID>.size
        var streams = [AudioStreamID](repeating: 0, count: streamCount)
        guard
            AudioObjectGetPropertyData(
                device,
                &address,
                0,
                nil,
                &dataSize,
                &streams
            ) == noErr
        else {
            return nil
        }

        return streams
    }

    // 新增方法：获取流支持的物理格式
    private func getSupportedFormats(for stream: AudioStreamID)
        -> [AudioStreamRangedDescription]?
    {
        var address = AudioObjectPropertyAddress(
            mSelector: kAudioStreamPropertyAvailablePhysicalFormats,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: 0
        )

        var dataSize: UInt32 = 0
        guard
            AudioObjectGetPropertyDataSize(stream, &address, 0, nil, &dataSize)
                == noErr
        else {
            return nil
        }

        let formatCount =
            Int(dataSize) / MemoryLayout<AudioStreamRangedDescription>.size
        var formats = [AudioStreamRangedDescription](
            repeating: AudioStreamRangedDescription(),
            count: formatCount
        )
        guard
            AudioObjectGetPropertyData(
                stream,
                &address,
                0,
                nil,
                &dataSize,
                &formats
            ) == noErr
        else {
            return nil
        }

        return formats
    }

    // 新增方法：寻找匹配的格式
    private func findMatchingFormat(
        _ formats: [AudioStreamRangedDescription],
        depth: Int,
        rate: Int
    ) -> AudioStreamRangedDescription {
        // 优先寻找完全匹配
        if let exactMatch = formats.first(where: {
            Int($0.mFormat.mSampleRate) == rate
                && $0.mFormat.mBitsPerChannel == UInt32(depth)
        }) {
            return exactMatch
        }
        let simplifiedFormats = formats.map { format in
            [
                "sampleRate": format.mFormat.mSampleRate,
                "bitDepth": format.mFormat.mBitsPerChannel,
            ]
        }
        let msg =
            "从\(JSON.stringify(simplifiedFormats))中未找到匹配「\(depth)Bit \(rate)kHz」的输出格式"
        Log.notice.notice("格式匹配失败", msg)
        Log.backend.info(
            msg
        )
        // 次选：匹配采样率，使用更高位深
        if let rateMatch = formats.filter({
            Int($0.mFormat.mSampleRate) == rate
        }).sorted(by: {
            $0.mFormat.mBitsPerChannel > $1.mFormat.mBitsPerChannel
        }).first {
            return rateMatch
        }

        // 最后返回默认格式
        return formats.first!
    }
}


// ===============================
// FILE: ./AudioSync/service/PlaybackNotifier.swift
// ===============================
import AppKit
import CoreAudio
import ScriptingBridge
import SwiftUI

struct TrackInfo: Encodable, Equatable {
    let name: String
    let artist: String
    let albumArtist: String
    let trackID: String
    let album: String
    let state: PlayState
    let genre: String
    let color: [Color]?
    let albumCover: NSImage?
    enum CodingKeys: String, CodingKey {
        case name, artist, albumArtist, trackID, album, state, genre
    }
    static func == (lhs: TrackInfo, rhs: TrackInfo) -> Bool {
        return lhs.trackID == rhs.trackID
    }
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(name, forKey: .name)
        try container.encode(artist, forKey: .artist)
        try container.encode(albumArtist, forKey: .albumArtist)
        try container.encode(trackID, forKey: .trackID)
        try container.encode(album, forKey: .album)
        try container.encode(state, forKey: .state)
        try container.encode(genre, forKey: .genre)
    }
}
enum PlayState: String, Encodable {
    case playing
    case stop
}
enum PlaybackTrigger {
    case formatSwitch
    case lyrics
}
@MainActor
class PlaybackNotifier {
    var onPlay: ((TrackInfo?, PlaybackTrigger) async -> Void)?

    private lazy var appleMusicScript: MusicApplication? = SBApplication(
        bundleIdentifier: "com.apple.Music"
    )
    var viewModel: ViewModel

    private var lastNotificationKey: String?
    var lock: Bool = false

    init(viewModel: ViewModel) {
        self.viewModel = viewModel
        DistributedNotificationCenter.default().addObserver(
            self,
            selector: #selector(receivedPlaybackNotification(_:)),
            name: NSNotification.Name("com.apple.Music.playerInfo"),
            object: nil
        )
    }

    deinit {
        DistributedNotificationCenter.default().removeObserver(self)
    }

    @objc private func receivedPlaybackNotification(
        _ notification: Notification
    ) {
        guard let userInfo = notification.userInfo,
            let state = userInfo["Player State"] as? String
        else {
            Log.backend.error(
                "appleNotification:  userInfo is missing required fields."
            )
            Log.notice.notice(
                "trackInfo is missing",
                "apple music distributedNotification"
            )
            return
        }

        let uniqueKey = userInfo.uniqueKey(using: [
            "Name", "Artist", "Album", "Player State",
        ])
        if uniqueKey == lastNotificationKey {
            return
        }
        lastNotificationKey = uniqueKey

        let songKey = userInfo.uniqueKey(using: [
            "Name", "Artist", "Album",
        ])
    
        viewModel.isCurrentTrackPlaying = (state == "Playing")
        Log.backend.info("appleNotification userInfo: \(userInfo)")
        let nextAlbum = userInfo["Album"] as? String ?? ""
        let nextName = userInfo["Name"] as? String ?? ""
        if !lock && state == "Playing" && !nextAlbum.isEmpty
            && viewModel.currentAlbum != nextAlbum && viewModel.enableAudioSync
        {
            lock = true
            Task {
                defer { lock = false }
                viewModel.currentAlbum = nextAlbum
                guard let script = self.appleMusicScript else { return }
                script.playpause?()
                Log.backend.info("pause \(nextName) ⏹️")
                if let onPlay = self.onPlay {
                    await onPlay(nil, .formatSwitch)  // 等待执行完
                }
                
                script.setPlayerPosition?(0.0)
                await waitUntilPaused(script)
                script.playpause?()
                Log.backend.info("play \(nextName) ✅")

            }
        }
        if state != "Playing" {
            viewModel.isLyricsPlaying = false
        }
        let nextArtist = userInfo["Artist"] as? String ?? ""
        if songKey != viewModel.currentSong {
            viewModel.currentSong = songKey
            let genre = userInfo["Genre"] as? String ?? ""
            Task {
                let trackID = try await IDFetcher.fetchTrackID(
                    name: nextName,
                    artist: nextArtist
                )
                let albumData = try await IDFetcher.fetchArtworkData(
                    name: nextName,
                    artist: nextArtist
                )

                let trackInfo = TrackInfo(
                    name: nextName,
                    artist: nextArtist,
                    albumArtist: nextAlbum,
                    trackID: String(trackID),
                    album: nextAlbum,
                    state: stringFromPlayerState(state),
                    genre: genre,
                    color: albumData.findDominantColors(),
                    albumCover: albumData
                )
                viewModel.currentTrack = trackInfo
                if let onPlay = self.onPlay {
                    await onPlay(nil, .lyrics)
                }
            }

        } else {
            Log.backend.debug("跳过重复通知: \(nextName) - \(nextArtist)")
            Task {
                if let onPlay = self.onPlay {
                    await onPlay(nil, .lyrics)
                }
            }
        }

    }

    func stringFromPlayerState(_ state: String) -> PlayState {
        switch state {
        case "Playing": return .playing
        case "Paused": return .stop
        default: return .stop
        }
    }
    func waitUntilPaused(
        _ script: MusicApplication,
        timeout: Int = 50
    ) async {
        for i in 0..<timeout {
            let isPaused = await MainActor.run {
                script.playerState != .playing
            }

            if isPaused {
                Log.backend.info("waitUntilPaused active play time consuming : \(i * 80) ms")
                return
            }

            try? await Task.sleep(nanoseconds: 80_000_000)
        }
    }
}
extension Dictionary where Key == AnyHashable, Value == Any {
    func uniqueKey(using fields: [String]) -> String {
        let parts = fields.map { key -> String in
            if let value = self[key] {
                return "\(key)=\(value)"
            } else {
                return "\(key)=nil"
            }
        }
        return parts.joined(separator: "|").hashValue.description
    }
}


// ===============================
// FILE: ./AudioSync/utils/Log.swift
// ===============================
import OSLog
enum LogLevel: Int {
    case debug = 0
    case info = 1
    case warning = 2
    case error = 3
}
enum Log {
    static let subsystem = "com.solo.AudioSync"
    static let notice = AppLogger(subsystem: subsystem, category: "notice")
    static let general = AppLogger(subsystem: subsystem, category: "general")
    static let backend = AppLogger(subsystem: subsystem, category: "backend")
    static let ui = AppLogger(subsystem: subsystem, category: "ui")
}
/// 封装 Logger，支持全局等级控制
struct AppLogger {
    let logger: Logger
    let category: String
    
    static let globalLevel: LogLevel = .debug // 可动态修改
    
    init(subsystem: String, category: String) {
        self.logger = Logger(subsystem: subsystem, category: category)
        self.category = category
    }
    
    func debug(_ message: String) {
        guard AppLogger.globalLevel.rawValue <= LogLevel.debug.rawValue else { return }
        logger.debug("\(message, privacy: .public)")
    }
    
    func info(_ message: String) {
        guard AppLogger.globalLevel.rawValue <= LogLevel.info.rawValue else { return }
        logger.info("\(message, privacy: .public)")
    }
    
    func warning(_ message: String) {
        guard AppLogger.globalLevel.rawValue <= LogLevel.warning.rawValue else { return }
        logger.warning("\(message, privacy: .public)")
    }
    
    func error(_ message: String) {
        guard AppLogger.globalLevel.rawValue <= LogLevel.error.rawValue else { return }
        logger.error("\(message, privacy: .public)")
    }
    func notice(_ title: String , _ message: String) {
        NotificationUtils.sendNotification(title: title, body: message)
    }
}


// ===============================
// FILE: ./AudioSync/utils/NetworkUtil.swift
// ===============================
import AppKit
import Foundation

public class NetworkUtil {

    var viewModel: ViewModel
    let fakeSpotifyUserAgentconfig = URLSessionConfiguration.default
    let fakeSpotifyUserAgentSession: URLSession
    let coverCacheActor = CoverCache()
    var fetchSimilarArtistsAndCoversTask: Task<Void, Error>?
    init(viewModel: ViewModel) {
        fakeSpotifyUserAgentSession = URLSession(
            configuration: fakeSpotifyUserAgentconfig
        )
        self.viewModel = viewModel
    }
    func fetchLyrics(
        trackName: String,
        artist: String,
        trackID: String,
        album: String,
        genre: String
    ) async throws -> [LyricLine] {
        await MainActor.run {
            viewModel.allCandidates.removeAll()
            viewModel.needNanualSelection = false
        }
        var effectiveTrackName = trackName
        var effectiveArtist = artist
        var effectiveAlbum = album
        if ["J-Pop", "Kayokyoku", "J-Rock"].contains(genre) {
            Log.general.info("获取日文原名...")
            let originalNameResult = try await fetchOriginalName(
                trackName: trackName,
                artist: artist,
                album: album
            )
            let msg = "日文原名: \(JSON.stringify(originalNameResult))"
            Log.general.info("日文原名: \(JSON.stringify(originalNameResult))")
            Log.notice.notice("获取日文原名成功", msg)
            if !originalNameResult.trackName.isEmpty {
                effectiveTrackName = originalNameResult.trackName
            }
            if !originalNameResult.artist.isEmpty {
                effectiveArtist = originalNameResult.artist
            }
            if !originalNameResult.album.isEmpty {
                effectiveAlbum = originalNameResult.album
            }
        }
        // 尝试网易云音乐
        var lyrics = await fetchNetEaseLyrics(
            trackName: effectiveTrackName,
            artist: effectiveArtist,
            trackID: trackID,  // trackID 似乎未使用，但保持签名一致
            album: effectiveAlbum
        )
        if !lyrics.isEmpty {
            return lyrics
        }

        // 尝试 QQ 音乐
        lyrics = await fetchQQLyrics(
            trackName: effectiveTrackName,
            artist: effectiveArtist,
            album: effectiveAlbum
        )
        if !lyrics.isEmpty {
            return lyrics
        }

        // 如果上述都失败，并且收集到了候选歌曲，则触发手动选择
        // 先获取QQ音乐的封面
        await fetchAlbumCover()

        // 检查是否有候选歌曲，并触发手动选择流程
        // 在 MainActor 上更新 UI 相关状态
        await MainActor.run {
            var seen = Set<String>()
            viewModel.allCandidates.removeAll { candidate in
                if seen.contains(candidate.id) {
                    return true  // 移除重复
                } else {
                    seen.insert(candidate.id)
                    return false
                }
            }
        }
        let shouldAskForManualSelection = await MainActor.run { () -> Bool in
            if !self.viewModel.allCandidates.isEmpty {
                self.viewModel.needNanualSelection = true
                Log.general.info("需要手动选择 -> true")
                return true
            }
            return false
        }
        if shouldAskForManualSelection {
            Log.general.info("等待用户手动选择...")
            // 为 continuation 添加超时机制
            let continuationTimeout: TimeInterval = 20.0  // 例如 10 秒超时

            do {
                let selectedSong: CandidateSong =
                    try await withCheckedThrowingContinuation { continuation in
                        Task {
                            try? await Task.sleep(
                                nanoseconds: UInt64(
                                    continuationTimeout * 1_000_000_000
                                )
                            )
                            await MainActor.run {
                                if self.viewModel.onCandidateSelected != nil {
                                    Log.general.warning("⚠️ 选择超时")
                                    Log.notice.notice("⚠️ 选择超时", "")
                                    self.viewModel.onCandidateSelected = nil
                                    self.viewModel.needNanualSelection = false
                                    continuation.resume(
                                        throwing: FetchError
                                            .manualSelectionTimeout
                                    )
                                }
                            }
                        }

                        Task { @MainActor in
                            self.viewModel.onCandidateSelected = { song in
                                self.viewModel.onCandidateSelected = nil  // 清理回调
                                continuation.resume(returning: song)
                            }
                        }
                    }
                // 用户选择后，根据 ID 获取歌词
                return try await fetchLyricsByID(song: selectedSong)
            } catch FetchError.manualSelectionTimeout {
                await MainActor.run {
                    self.viewModel.needNanualSelection = false  // 确保UI状态被重置
                    self.viewModel.isLyricsPlaying = false
                }
                return []  // 或抛出错误
            } catch {
                Log.general.error("手动选择发生错误: \(error)")
                await MainActor.run {
                    self.viewModel.needNanualSelection = false  // 确保UI状态被重置
                    self.viewModel.isLyricsPlaying = false
                }
                throw error  // 重新抛出其他错误
            }
        }
        return []
    }

    // 定义一个错误类型用于超时
    enum FetchError: Error {
        case manualSelectionTimeout
        case apiError(String)
        case parsingError(String)
    }

    func fetchNetEaseArtist(name: String) async throws -> Artist? {

        if let data = await coverCacheActor.get(for: name) {
            Log.backend.debug("命中 \(name) 缓存封面")
            var artist = Artist(name: name)
            artist.image = data
            return artist
        }
        let request = URLRequest(
            url: URL(
                string:
                    "https://neteasecloudmusicapi-ten-wine.vercel.app/cloudsearch?keywords=\(name)&limit=1&type=100"
            )!
        )

        let response = try await fakeSpotifyUserAgentSession.data(for: request)
        let decoder = JSONDecoder()
        let netEaseArtists = try decoder.decode(
            NetEaseArtist.self,
            from: response.0
        )
        guard let netEaseArtist = netEaseArtists.result.artists.first else {
            return nil
        }
        let data = try await fetchImageData(netEaseArtist.picUrl)
        var artist = Artist(name: netEaseArtist.name, url: netEaseArtist.picUrl)
        artist.image = data
        Log.backend.info("找到歌手 \(name) 封面：\(artist.url)")
        await coverCacheActor.set(artist.image!, for: name)
        return artist
    }
    func fetchSimilarArtistsAndCovers() {
        fetchSimilarArtistsAndCoversTask?.cancel()
        fetchSimilarArtistsAndCoversTask = Task {
            do {
                // 1. 获取相似歌手
                let fetched = try await fetchSimilarArtists(
                    name: viewModel.currentTrack?.artist ?? ""
                )
                await MainActor.run {
                    viewModel.similarArtists.removeAll()
                    viewModel.similarArtists = fetched
                }
                // 2. 查封面
                await withTaskGroup(of: (Int, Data?).self) { group in
                    for i in await viewModel.similarArtists.indices {
                        if Task.isCancelled { break }
                        let name = await viewModel.similarArtists[i].name
                        group.addTask {
                            let cover = try? await self.fetchNetEaseArtist(
                                name: name
                            )
                            return (i, cover?.image)
                        }
                    }

                    for await (i, image) in group {
                        if Task.isCancelled { break }
                        if let image {
                            await MainActor.run {
                                viewModel.similarArtists[i].image = image
                            }
                        }
                    }
                }
            } catch {
                Log.ui.error("Failed to fetch similar artists: \(error)")
            }
        }
    }
    func fetchNetEaseLyrics(
        trackName: String,
        artist: String,
        trackID: String,
        album: String
    ) async -> [LyricLine] {
        if let url = URL(
            string:
                "https://neteasecloudmusicapi-ten-wine.vercel.app/cloudsearch?keywords=\(trackName) \(artist)&limit=5"
        ) {
            do {
                let request = URLRequest(url: url)
                let urlResponseAndData =
                    try await fakeSpotifyUserAgentSession.data(
                        for: request
                    )
                let decoder = JSONDecoder()
                let neteasesearch = try decoder.decode(
                    NetEaseSearch.self,
                    from: urlResponseAndData.0
                )
                Log.general.info("netease 找到歌曲：\(neteasesearch.result.songs)")

                let matchedSong = neteasesearch.result.songs.first {
                    $0.name.normalized == trackName.normalized
                        && $0.ar.contains(where: {
                            $0.name.normalized == artist.normalized
                        })
                        && ($0.al.name.normalized == album.normalized
                            || album.normalized.contains(
                                $0.al.name.normalized
                            )
                            || $0.al.name.normalized.contains(
                                album.normalized
                            ))
                }

                guard let song = matchedSong else {
                    Log.general.info(
                        "❌ 没有匹配到 netease 歌曲：trackName=\(trackName), artist=\(artist), album=\(album)"
                    )
                    // Append all netease songs as candidates
                    for song in neteasesearch.result.songs {
                        let candidate = CandidateSong(
                            id: song.id.codingKey.stringValue,
                            name: song.name,
                            artist: song.ar.map { $0.name }.joined(
                                separator: ", "
                            ),
                            album: song.al.name,
                            albumId: song.al.id.codingKey.stringValue,
                            albumCover: song.al.picUrl,
                            source: .netEase
                        )
                        await MainActor.run {
                            viewModel.allCandidates.append(candidate)
                        }
                    }
                    return []
                }

                let lyricRequest = URLRequest(
                    url: URL(
                        string:
                            "https://neteasecloudmusicapi-ten-wine.vercel.app/lyric?id=\(song.id)"
                    )!
                )
                let urlResponseAndDataLyrics =
                    try await fakeSpotifyUserAgentSession.data(
                        for: lyricRequest
                    )

                let neteaseLyrics = try decoder.decode(
                    NetEaseLyrics.self,
                    from: urlResponseAndDataLyrics.0
                )

                guard let neteaselrc = neteaseLyrics.lrc,
                    let neteaseLrcString = neteaselrc.lyric
                else {
                    return []
                }

                let originalParser = LyricsParser(
                    lyrics: neteaseLrcString,
                    format: .netEase
                )
                var finalLyrics = originalParser.lyrics

                // 合并歌词翻译
                if let tlyric = neteaseLyrics.tlyric,
                    let tlyricString = tlyric.lyric, !tlyricString.isEmpty
                {
                    let translationParser = LyricsParser(
                        lyrics: tlyricString,
                        format: .netEase
                    )
                    if !translationParser.lyrics.isEmpty {
                        finalLyrics = originalParser.mergeLyrics(
                            translation: translationParser
                        )
                    }
                }
                return finalLyrics
            } catch {
                Log.general.error("fetch netease lyrics:\(error)")
            }
        }
        return []
    }

    func fetchQQLyrics(trackName: String, artist: String, album: String)
        async -> [LyricLine]
    {
        if let url = URL(
            string:
                "https://c.y.qq.com/soso/fcgi-bin/client_search_cp?p=1&n=5&w=\(trackName) \(artist)"
        ) {
            do {
                let request = URLRequest(url: url)
                let urlResponseAndData =
                    try await fakeSpotifyUserAgentSession.data(
                        for: request
                    )
                guard
                    let rawText = String(
                        data: urlResponseAndData.0,
                        encoding: .utf8
                    ),
                    let rangeStart = rawText.range(of: "("),
                    let rangeEnd = rawText.range(of: ")", options: .backwards)
                else {
                    return []
                }
                let jsonString = String(
                    rawText[rangeStart.upperBound..<rangeEnd.lowerBound]
                )
                guard let jsonData = jsonString.data(using: .utf8) else {
                    return []
                }
                let decoder = JSONDecoder()
                let QQSearchData = try decoder.decode(
                    QQSearch.self,
                    from: jsonData
                )
                Log.general.info("qq 找到歌曲:\(QQSearchData.data.song.list)")
                let QQSong = QQSearchData.data.song.list.first {
                    $0.songname.normalized == trackName.normalized
                        && $0.singer.contains(where: {
                            $0.name.normalized == artist.normalized
                        })
                        && ($0.albumname.normalized == album.normalized
                            || album.normalized.contains(
                                $0.albumname.normalized
                            )
                            || $0.albumname.normalized.contains(
                                album.normalized
                            ))
                }
                if QQSong == nil {
                    Log.general.info(
                        "❌ 没有匹配到 QQ 歌曲：trackName=\(trackName), artist=\(artist), album=\(album)"
                    )
                    // Append all QQ songs as candidates
                    for song in QQSearchData.data.song.list {
                        let candidate = CandidateSong(
                            id: song.songmid,
                            name: song.songname,
                            artist: song.singer.map { $0.name }.joined(
                                separator: ", "
                            ),
                            album: song.albumname,
                            albumId: song.albummid,
                            albumCover: "",
                            source: .qq
                        )
                        await MainActor.run {
                            viewModel.allCandidates.append(candidate)
                        }
                    }
                    return []
                }
                let url = URL(
                    string:
                        "https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg?songmid=\(QQSong!.songmid)&g_tk=5381"
                )!
                var lyricRequest = URLRequest(url: url)
                lyricRequest.setValue(
                    "y.qq.com/portal/player.html",
                    forHTTPHeaderField: "Referer"
                )

                let lyricResponseAndData =
                    try await fakeSpotifyUserAgentSession.data(
                        for: lyricRequest
                    )

                guard
                    let lyrRawText = String(
                        data: lyricResponseAndData.0,
                        encoding: .utf8
                    ),
                    let lyrRangeStart = lyrRawText.range(of: "("),
                    let lyrRangeEnd = lyrRawText.range(
                        of: ")",
                        options: .backwards
                    )
                else {
                    return []
                }
                let lyrJsonString = String(
                    lyrRawText[
                        lyrRangeStart.upperBound..<lyrRangeEnd.lowerBound
                    ]
                )
                guard let lyrJsonData = lyrJsonString.data(using: .utf8) else {
                    return []
                }

                let qqLyricsData = try decoder.decode(
                    QQLyrics.self,
                    from: lyrJsonData
                )
                guard let lyricString = qqLyricsData.lyricString else {
                    return []
                }
                let lyricsParser = LyricsParser(
                    lyrics: lyricString,
                    format: .qq
                )
                if let tlyricString = qqLyricsData.transString {
                    let tlyricsParser = LyricsParser(
                        lyrics: tlyricString,
                        format: .qq
                    )
                    return lyricsParser.mergeLyrics(translation: tlyricsParser)
                }
                return lyricsParser.lyrics
            } catch {
                Log.general.error("fetch qq lyrics : \(error)")
            }
        }
        return []
    }
    func fetchOriginalName(trackName: String, artist: String, album: String)
        async throws
        -> OriginalName
    {
        let url = URL(string: "https://api.siliconflow.cn/v1/chat/completions")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(
            "Bearer \(Key.siliconFlow)",
            forHTTPHeaderField: "Authorization"
        )
        let payload: [String: Any] = [
            "model": "deepseek-ai/DeepSeek-R1",
            "messages": [
                [
                    "role": "system",
                    "content":
                        "You are very familiar with Japanese music and proficient in Japanese (including Japanese-style Romanization). Help me find the original Japanese song title and artist name. Wrap the song title in <>, Wrap the album title in [] and the artist name in {},and if there is a year and the word 'live' they should be retained. Your answer should omit the thinking process and analysis. Response format example: <涙そうそう 1997 live> [南風] {夏川 りみ} ",
                ],
                [
                    "role": "user",
                    "content": "歌名: \(trackName), 歌手: \(artist), 专辑: \(album)",
                ],
            ],
            "stream": false,
        ]

        request.httpBody = try JSONSerialization.data(
            withJSONObject: payload,
            options: []
        )

        let (data, _) = try await fakeSpotifyUserAgentSession.data(for: request)
        struct CompletionResponse: Decodable {
            struct Choice: Decodable {
                struct Message: Decodable {
                    let content: String
                }
                let message: Message
            }
            let choices: [Choice]
        }
        let decoder = JSONDecoder()
        let response = try decoder.decode(CompletionResponse.self, from: data)
        let rawContent = response.choices.first?.message.content ?? ""
        let originalName = rawContent.trimmingCharacters(
            in: CharacterSet(charactersIn: "<>")
        )
        let artist = rawContent.trimmingCharacters(
            in: CharacterSet(charactersIn: "{}")
        )
        let album = rawContent.trimmingCharacters(
            in: CharacterSet(charactersIn: "[]")
        )
        return OriginalName(
            trackName: originalName,
            artist: artist,
            album: album
        )
    }

    func fetchLyricsByID(song: CandidateSong) async throws -> [LyricLine] {
        switch song.source {
        case .netEase:
            let lyricRequest = URLRequest(
                url: URL(
                    string:
                        "https://neteasecloudmusicapi-ten-wine.vercel.app/lyric?id=\(song.id)"
                )!
            )
            let urlResponseAndDataLyrics =
                try await fakeSpotifyUserAgentSession.data(for: lyricRequest)
            let decoder = JSONDecoder()
            let neteaseLyrics = try decoder.decode(
                NetEaseLyrics.self,
                from: urlResponseAndDataLyrics.0
            )

            guard let neteaselrc = neteaseLyrics.lrc,
                let neteaseLrcString = neteaselrc.lyric
            else {
                return []
            }

            let originalParser = LyricsParser(
                lyrics: neteaseLrcString,
                format: .netEase
            )

            guard let tlrc = neteaseLyrics.tlyric, let tlrcString = tlrc.lyric
            else {
                return originalParser.lyrics
            }
            let translationParser = LyricsParser(
                lyrics: tlrcString,
                format: .netEase
            )
            return originalParser.mergeLyrics(translation: translationParser)
        case .qq:
            let url = URL(
                string:
                    "https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg?songmid=\(song.id)&g_tk=5381"
            )!
            var lyricRequest = URLRequest(url: url)
            lyricRequest.setValue(
                "y.qq.com/portal/player.html",
                forHTTPHeaderField: "Referer"
            )

            let lyricResponseAndData =
                try await fakeSpotifyUserAgentSession.data(for: lyricRequest)

            guard
                let lyrRawText = String(
                    data: lyricResponseAndData.0,
                    encoding: .utf8
                ),
                let lyrRangeStart = lyrRawText.range(of: "("),
                let lyrRangeEnd = lyrRawText.range(of: ")", options: .backwards)
            else {
                return []
            }
            let lyrJsonString = String(
                lyrRawText[lyrRangeStart.upperBound..<lyrRangeEnd.lowerBound]
            )
            guard let lyrJsonData = lyrJsonString.data(using: .utf8) else {
                return []
            }
            let decoder = JSONDecoder()
            let qqLyricsData = try decoder.decode(
                QQLyrics.self,
                from: lyrJsonData
            )
            guard let lyricString = qqLyricsData.lyricString else {
                return []
            }
            let lyricsParser = LyricsParser(lyrics: lyricString, format: .qq)
            if let tlyricString = qqLyricsData.transString {
                let tlyricsParser = LyricsParser(
                    lyrics: tlyricString,
                    format: .qq
                )
                return lyricsParser.mergeLyrics(translation: tlyricsParser)
            }
            return lyricsParser.lyrics
        }
    }
    func fetchAlbumCover() async {
        let qq = await MainActor.run { () -> ([String]) in
            var qqCandidates: [String] = []
            for candidate in viewModel.allCandidates {
                switch candidate.source {
                case .qq:
                    if !candidate.albumId.isEmpty {
                        qqCandidates.append(candidate.albumId)
                    }
                case .netEase:
                    break
                }
            }
            return qqCandidates
        }

        await withTaskGroup(of: (String, String).self) { group in
            for id in qq {
                group.addTask {
                    let cover =
                        (try? await self.fetchQQAlbumCoverByID(id: id)) ?? ""
                    return (id, cover)
                }
            }

            let coverMap = await group.reduce(into: [String: String]()) {
                $0[$1.0] = $1.1
            }

            await MainActor.run {
                for i in 0..<viewModel.allCandidates.count {
                    let candidate = viewModel.allCandidates[i]
                    if candidate.source == .qq,
                        let cover = coverMap[candidate.albumId]
                    {
                        viewModel.allCandidates[i].albumCover = cover
                    }
                }
            }
        }
    }
    func fetchQQAlbumCoverByID(id: String) async throws -> String {
        do {
            let albumRequest = URLRequest(
                url: URL(
                    string:
                        "https://c.y.qq.com/v8/fcg-bin/musicmall.fcg?albummid=\(id)&format=json&inCharset=utf-8&outCharset=utf-8&cmd=get_album_buy_page"
                )!
            )
            let albumData = try await fakeSpotifyUserAgentSession.data(
                for: albumRequest
            )
            let decoder = JSONDecoder()
            let album = try decoder.decode(QQAlbum.self, from: albumData.0)
            guard let pic = album.data.headpiclist.first?.picurl else {
                Log.general.error("辑封面获取失败: \(JSON.stringify(album))")
                return ""
            }
            Log.general.info("专辑 url: \(pic) ")
            return pic

        } catch {
            Log.general.error("获取专辑 \(error)")
        }
        return ""
    }
    func fetchSimilarArtists(name: String) async throws -> [Artist] {
        let request = URLRequest(
            url: URL(
                string:
                    "http://ws.audioscrobbler.com/2.0/?method=artist.getsimilar&artist=\(name)&api_key=\(Key.lastfm)&limit=10&format=json"
            )!
        )
        let response = try await fakeSpotifyUserAgentSession.data(for: request)
        let decoder = JSONDecoder()
        let artistResponse = try decoder.decode(
            ArtistFromLastFMResponse.self,
            from: response.0
        )
        guard let similars = artistResponse.similarartists?.artist else {
            return []
        }
        var similarArtists: [Artist] = []
        similars.forEach {
            let similarArtist = Artist(
                name: $0.name.toSimplified,
                url: $0.url,
                mbid: $0.mbid ?? ""
            )
            similarArtists.append(similarArtist)
        }
        return similarArtists
    }
    func fetchSimilarSongs(name: String, artist: String) async throws
        -> [SimilarSong]
    {
        let traditionalName = name.toTraditional

        // 相同则执行原有逻辑
        if traditionalName == name {
            let request = URLRequest(
                url: URL(
                    string:
                        "http://ws.audioscrobbler.com/2.0/?method=track.getsimilar&track=\(name)&artist=\(artist)&api_key=\(Key.lastfm)&limit=10&format=json"
                )!
            )
            let response = try await fakeSpotifyUserAgentSession.data(
                for: request
            )
            let decoder = JSONDecoder()
            let songsResponse = try decoder.decode(
                SongFromLastFMResponse.self,
                from: response.0
            )
            guard let similars = songsResponse.similartracks?.track else {
                Log.notice.notice("相似歌曲", "从lastfm未找到相似歌曲")
                return []
            }
            var similarSongs: [SimilarSong] = []
            similars.forEach {
                let similarSong = SimilarSong(
                    name: $0.name.toSimplified,
                    mbid: $0.mbid ?? "",
                    artist: $0.artist.name.toSimplified
                )
                similarSongs.append(similarSong)
            }
            return similarSongs
        }

        // 并发执行两个请求，取第一个有返回的
        return try await withThrowingTaskGroup(of: [SimilarSong].self) {
            group in
            // 请求1：原名
            group.addTask {
                let request = URLRequest(
                    url: URL(
                        string:
                            "http://ws.audioscrobbler.com/2.0/?method=track.getsimilar&track=\(name)&artist=\(artist)&api_key=\(Key.lastfm)&limit=10&format=json"
                    )!
                )
                let response = try await self.fakeSpotifyUserAgentSession.data(
                    for: request
                )
                let decoder = JSONDecoder()
                let songsResponse = try decoder.decode(
                    SongFromLastFMResponse.self,
                    from: response.0
                )
                guard let similars = songsResponse.similartracks?.track else {
                    return []
                }
                return similars.map {
                    SimilarSong(
                        name: $0.name.toSimplified,
                        mbid: $0.mbid ?? "",
                        artist: $0.artist.name.toSimplified
                    )
                }
            }

            // 请求2：繁体名
            group.addTask {
                let request = URLRequest(
                    url: URL(
                        string:
                            "http://ws.audioscrobbler.com/2.0/?method=track.getsimilar&track=\(traditionalName)&artist=\(artist)&api_key=\(Key.lastfm)&limit=10&format=json"
                    )!
                )
                let response = try await self.fakeSpotifyUserAgentSession.data(
                    for: request
                )
                let decoder = JSONDecoder()
                let songsResponse = try decoder.decode(
                    SongFromLastFMResponse.self,
                    from: response.0
                )
                guard let similars = songsResponse.similartracks?.track else {
                    return []
                }
                return similars.map {
                    SimilarSong(
                        name: $0.name.toSimplified,
                        mbid: $0.mbid ?? "",
                        artist: $0.artist.name.toSimplified
                    )
                }
            }

            // 谁先返回非空结果就用谁
            for try await result in group {
                if !result.isEmpty {
                    group.cancelAll()
                    return result
                }
            }
            Log.notice.notice("相似歌曲", "使用简繁歌曲名从lastfm未找到相似歌曲")
            return []
        }
    }

    func fetchImageData(_ urlString: String) async throws -> Data {
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }

        let (data, _) = try await URLSession.shared.data(from: url)

        // 直接尝试压缩
        return try await compressImageData(data, maxWidth: 300, quality: 0.7)
    }
}

extension String {

    var normalized: String {
        self
            .replacingOccurrences(
                of: #"\s+"#,
                with: " ",
                options: .regularExpression
            )
            .replacingOccurrences(of: "(", with: "-")
            .replacingOccurrences(of: ")", with: "-")
            .replacingOccurrences(of: "：", with: "-")
            .replacingOccurrences(of: "（", with: "-")
            .replacingOccurrences(of: "）", with: "-")
            .lowercased()
    }
    var toTraditional: String {
        self.applyingTransform(
            StringTransform("Simplified-Traditional"),
            reverse: false
        ) ?? self
    }

    var toSimplified: String {
        self.applyingTransform(
            StringTransform("Traditional-Simplified"),
            reverse: false
        ) ?? self
    }
}


// ===============================
// FILE: ./AudioSync/utils/NotificationUtils.swift
// ===============================
import UserNotifications
class NotificationUtils {
   static func sendNotification(title: String, body: String) {
        let content = UNMutableNotificationContent()
        content.title = title
        content.body = body
        content.sound = UNNotificationSound.default
        
        // 立即发送
        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 1, repeats: false)
        
        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: trigger)
        UNUserNotificationCenter.current().add(request) { error in
            if let error = error {
                Log.backend.error("发送通知失败: \(error)")
            }
        }
    }
}


// ===============================
// FILE: ./AudioSync/utils/Utils.swift
// ===============================
import AppKit
import Foundation

enum JSON {

    // MARK: - 对象/数组转 JSON 字符串
    static func stringify<T: Encodable>(_ value: T, pretty: Bool = false)
        -> String
    {
        let encoder = JSONEncoder()
        if pretty {
            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
        }
        do {
            let data = try encoder.encode(value)
            return String(data: data, encoding: .utf8) ?? "{}"
        } catch {
            Log.general.error("JSON 编码失败: \(error)")
            return "{}"
        }
    }

    static func stringify(_ dict: [AnyHashable: Any], pretty: Bool = false)
        -> String
    {
        do {
            let data = try JSONSerialization.data(
                withJSONObject: dict,
                options: pretty ? [.prettyPrinted] : []
            )
            return String(data: data, encoding: .utf8) ?? "{}"
        } catch {
            Log.general.error("字典 JSON 编码失败: \(error)")
            return "{}"
        }
    }

    static func stringify(_ array: [Any], pretty: Bool = false) -> String {
        do {
            let data = try JSONSerialization.data(
                withJSONObject: array,
                options: pretty ? [.prettyPrinted] : []
            )
            return String(data: data, encoding: .utf8) ?? "[]"
        } catch {
            Log.general.error("数组 JSON 编码失败: \(error)")
            return "[]"
        }
    }

    // MARK: - JSON 字符串转对象/数组
    static func parse<T: Decodable>(_ jsonString: String, to type: T.Type) -> T?
    {
        guard let data = jsonString.data(using: .utf8) else { return nil }
        do {
            return try JSONDecoder().decode(T.self, from: data)
        } catch {
            Log.general.error("JSON 解码失败: \(error)")
            return nil
        }
    }

    static func parseDictionary(_ jsonString: String) -> [String: Any]? {
        guard let data = jsonString.data(using: .utf8) else { return nil }
        do {
            let obj = try JSONSerialization.jsonObject(with: data, options: [])
            return obj as? [String: Any]
        } catch {
            Log.general.error("JSON 字符串转字典失败: \(error)")
            return nil
        }
    }

    static func parseArray(_ jsonString: String) -> [Any]? {
        guard let data = jsonString.data(using: .utf8) else { return nil }
        do {
            let obj = try JSONSerialization.jsonObject(with: data, options: [])
            return obj as? [Any]
        } catch {
            Log.general.error("JSON 字符串转数组失败: \(error)")
            return nil
        }
    }
}
func compressImageData(_ data: Data, maxWidth: CGFloat, quality: CGFloat)
    async throws -> Data
{
    guard let image = NSImage(data: data) else {
        throw NSError(domain: "InvalidImage", code: -1)
    }

    // 取出 CGImage
    guard
        let cgImage = image.cgImage(
            forProposedRect: nil,
            context: nil,
            hints: nil
        )
    else {
        throw NSError(domain: "InvalidCGImage", code: -1)
    }

    let originalWidth = CGFloat(cgImage.width)
    let originalHeight = CGFloat(cgImage.height)

    // 如果图片本来就够小，直接存
    if originalWidth <= maxWidth {
        return data
    }

    // 计算缩放比
    let scale = maxWidth / originalWidth
    let newWidth = maxWidth
    let newHeight = originalHeight * scale

    // 新图像 context
    let colorSpace = CGColorSpaceCreateDeviceRGB()

    guard
        let context = CGContext(
            data: nil,
            width: Int(newWidth),
            height: Int(newHeight),
            bitsPerComponent: 8,
            bytesPerRow: 0,
            space: colorSpace,
            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
        )
    else {
        throw NSError(domain: "CreateContextFailed", code: -1)
    }

    context.interpolationQuality = .high
    context.draw(
        cgImage,
        in: CGRect(x: 0, y: 0, width: newWidth, height: newHeight)
    )

    guard let resizedCGImage = context.makeImage() else {
        throw NSError(domain: "ResizeFailed", code: -1)
    }

    // 导出 JPEG 数据
    let rep = NSBitmapImageRep(cgImage: resizedCGImage)
    guard
        let jpegData = rep.representation(
            using: .jpeg,
            properties: [.compressionFactor: quality]
        )
    else {
        throw NSError(domain: "JPEGEncodeFailed", code: -1)
    }

    return jpegData
}
// MARK: - Encodable 扩展
extension Encodable {
    func toJSONString(pretty: Bool = false) -> String {
        JSON.stringify(self, pretty: pretty)
    }
}


// ===============================
// FILE: ./AudioSync/view/AnimatedMeshGradientView.swift
// ===============================
import SwiftUI
import MetalKit

struct AnimatedMeshGradientView: View {
    var colors: [Color]
    
    var body: some View {
        MetalMeshGradientView(colors: colors)
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .ignoresSafeArea()
    }
}

struct MetalMeshGradientView: NSViewRepresentable {
    var colors: [Color]
    
    func makeNSView(context: Context) -> MTKView {
        let mtkView = MTKView()
        mtkView.device = context.coordinator.device
        mtkView.delegate = context.coordinator
        // 设置背景透明，以便 SwiftUI 背景可以透过
        mtkView.clearColor = MTLClearColor(red: 0, green: 0, blue: 0, alpha: 0)
        mtkView.colorPixelFormat = .bgra8Unorm
        mtkView.framebufferOnly = false // 需要能够读取 framebuffer 内容（虽然这里不直接读取，但通常设为 false 以免问题）
        mtkView.autoResizeDrawable = true
        mtkView.enableSetNeedsDisplay = true // 允许按需重绘
        mtkView.isPaused = false // 确保视图不暂停
        mtkView.preferredFramesPerSecond = 60 // 目标帧率
        return mtkView
    }
    
    func updateNSView(_ nsView: MTKView, context: Context) {
        // 当 SwiftUI 视图更新时，通知 Coordinator 更新颜色
        context.coordinator.updateColors(colors)
        // 请求重绘
        nsView.setNeedsDisplay(nsView.bounds)
    }
    
    func makeCoordinator() -> Coordinator {
        Coordinator(colors: colors)
    }
    
    class Coordinator: NSObject, MTKViewDelegate {
        let device: MTLDevice
        let commandQueue: MTLCommandQueue
        let pipelineState: MTLRenderPipelineState
        var vertexBuffer: MTLBuffer
        var timeBuffer: MTLBuffer
        var colorBuffer: MTLBuffer
        var gridPointsBuffer: MTLBuffer // 存储网格点位置
        var startTime: TimeInterval
        
        // 顶点结构体
        struct Vertex {
            var position: SIMD2<Float>
        }
        
        // 时间 uniform 结构体
        struct TimeUniforms {
            var time: Float
        }
        
        // 颜色 uniform 结构体 (着色器中会定义为数组)
        // struct ColorUniforms {
        //     var colors: [SIMD4<Float>] // 实际在着色器中是 float4 colors[9]
        // }
        
        // 网格点结构体
        struct GridPoint {
            var position: SIMD2<Float>
        }

        // MovingPoint 结构体
        struct MovingPoint {
            var position: SIMD2<Float>
            var direction: SIMD2<Float>
        }

        // 存储9个动态点
        var movingPoints: [MovingPoint] = []
        
        init(colors: [Color]) {
            // 获取默认 Metal 设备
            guard let device = MTLCreateSystemDefaultDevice(),
                  let commandQueue = device.makeCommandQueue() else {
                fatalError("Metal is not supported on this device")
            }
            
            self.device = device
            self.commandQueue = commandQueue
            self.startTime = CACurrentMediaTime() // 记录开始时间，用于动画
            
            // 创建渲染管线
            let library: MTLLibrary
            do {
                // 从 metalShaderSource 字符串编译着色器
                library = try device.makeLibrary(source: metalShaderSource, options: nil)
            } catch {
                fatalError("Failed to compile Metal shaders: \(error)")
            }

            guard let vertexFunction = library.makeFunction(name: "vertexShader"),
                  let fragmentFunction = library.makeFunction(name: "fragmentShader") else {
                fatalError("Failed to load shader functions from Metal library")
            }
            
            let pipelineDescriptor = MTLRenderPipelineDescriptor()
            pipelineDescriptor.vertexFunction = vertexFunction
            pipelineDescriptor.fragmentFunction = fragmentFunction
            pipelineDescriptor.colorAttachments[0].pixelFormat = .bgra8Unorm // 与 MTKView 格式匹配

            // 配置顶点描述符 (虽然我们的顶点着色器很简单，但这是标准做法)
            let vertexDescriptor = MTLVertexDescriptor()
            // 属性0: 位置
            vertexDescriptor.attributes[0].format = .float2 // SIMD2<Float>
            vertexDescriptor.attributes[0].offset = 0
            vertexDescriptor.attributes[0].bufferIndex = 0 // 对应顶点缓冲区的索引

            // 布局0: 描述顶点数据如何排列
            vertexDescriptor.layouts[0].stride = MemoryLayout<Vertex>.stride // 单个顶点的步长
            vertexDescriptor.layouts[0].stepRate = 1
            vertexDescriptor.layouts[0].stepFunction = .perVertex

            pipelineDescriptor.vertexDescriptor = vertexDescriptor
            
            do {
                pipelineState = try device.makeRenderPipelineState(descriptor: pipelineDescriptor)
            } catch {
                fatalError("Failed to create pipeline state: \(error)")
            }
            
            // 创建顶点缓冲区 (一个覆盖全屏的大三角形)
            // 这些坐标是归一化设备坐标 (NDC)
            let vertices: [Vertex] = [
                Vertex(position: SIMD2<Float>(-1, -1)), // 左下
                Vertex(position: SIMD2<Float>(-1,  3)), // 左上延伸 (确保覆盖)
                Vertex(position: SIMD2<Float>( 3, -1))  // 右下延伸 (确保覆盖)
            ]
            
            vertexBuffer = device.makeBuffer(
                bytes: vertices,
                length: MemoryLayout<Vertex>.stride * vertices.count,
                options: .storageModeManaged // CPU 和 GPU 共享内存
            )!
            
            // 创建时间缓冲区
            var initialTime = TimeUniforms(time: 0)
            timeBuffer = device.makeBuffer(
                bytes: &initialTime,
                length: MemoryLayout<TimeUniforms>.stride,
                options: .storageModeManaged
            )!
            
            // 创建颜色缓冲区 (9个颜色, 每个颜色是 SIMD4<Float>)
            colorBuffer = device.makeBuffer(
                length: MemoryLayout<SIMD4<Float>>.stride * 9, // 9 个颜色
                options: .storageModeManaged
            )!
            
            // 创建网格点缓冲区 (9个点, 每个点是 SIMD2<Float>)
            gridPointsBuffer = device.makeBuffer(
                length: MemoryLayout<GridPoint>.stride * 9, // 9 个网格点
                options: .storageModeManaged
            )!
            
            super.init()

            // 初始化9个随机位置和方向的movingPoints
            for _ in 0..<9 {
                let pos = SIMD2<Float>(
                    Float.random(in: 0.2...0.8),
                    Float.random(in: 0.2...0.8)
                )
                let angle = Float.random(in: 0..<2 * .pi)
                let dir = SIMD2<Float>(cos(angle), sin(angle))
                movingPoints.append(MovingPoint(position: pos, direction: dir))
            }

            // 初始化颜色和网格点
            updateColors(colors) // 初始颜色加载
            updateGridPoints(time: 0) // 初始网格点位置
        }
        
        func updateColors(_ swiftUIColors: [Color]) {
            // 确保有9个颜色，如果不够则随机补充
            var adjustedColors = swiftUIColors
            while adjustedColors.count < 9 {
                adjustedColors.append(adjustedColors.randomElement() ?? .blue) // 默认补充蓝色
            }
            
            // 将 SwiftUI Color 转换为 Metal 使用的 SIMD4<Float> (RGBA)
            var floatColors: [SIMD4<Float>] = adjustedColors.prefix(9).map { color in
                // NSColor 用于更准确地获取 RGBA 分量
                let nsColor = NSColor(color).usingColorSpace(.sRGB) ?? NSColor.blue
                return SIMD4<Float>(
                    Float(nsColor.redComponent),
                    Float(nsColor.greenComponent),
                    Float(nsColor.blueComponent),
                    Float(nsColor.alphaComponent)
                )
            }
            
            // 更新颜色缓冲区内容
            // `memcpy` 用于将数据从 `floatColors` 数组复制到 Metal 缓冲区的内存中
            memcpy(colorBuffer.contents(), &floatColors, MemoryLayout<SIMD4<Float>>.stride * 9)
            // 通知 Metal 缓冲区内容已修改 (对于 .storageModeManaged)
            colorBuffer.didModifyRange(0..<colorBuffer.length)
        }
        
        func smoothRandom(_ seed: Float, time: Float) -> Float {
            // 基于 seed+time 生成伪随机序列（可替换为更复杂插值）
            let sinS = sin(seed * 12.9898 + time * 0.19)
            let trunS = 43758.5453.truncatingRemainder(dividingBy: 1.0) * 2.0
            return sinS * Float(trunS) - 1.0
        }
        
        func updateGridPoints(time: Float) {
            let speed: Float = 0.0005 // 控制运动速度

            for i in 0..<movingPoints.count {
                // 更新位置
                movingPoints[i].position += movingPoints[i].direction * speed

                // 边缘碰撞检测 + 反弹（保持在 [0, 1] 范围内）
                var pos = movingPoints[i].position
                var dir = movingPoints[i].direction

                if pos.x < 0.0 { pos.x = 0.0; dir.x *= -1 }
                if pos.x > 1.0 { pos.x = 1.0; dir.x *= -1 }
                if pos.y < 0.0 { pos.y = 0.0; dir.y *= -1 }
                if pos.y > 1.0 { pos.y = 1.0; dir.y *= -1 }

                movingPoints[i] = MovingPoint(position: pos, direction: dir)
            }

            // 转换为 GridPoint 传给 GPU
            let gridPoints = movingPoints.map { GridPoint(position: $0.position) }
            memcpy(gridPointsBuffer.contents(), gridPoints, MemoryLayout<GridPoint>.stride * 9)
            gridPointsBuffer.didModifyRange(0..<gridPointsBuffer.length)
        }
        
        // MTKViewDelegate 方法：当视图大小改变时调用
        func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) {
            // 通常在这里处理投影矩阵等的更新，但对于这个2D效果不是必需的
        }
        
        // MTKViewDelegate 方法：每帧绘制时调用
        func draw(in view: MTKView) {
            // 获取当前的 drawable 和 render pass descriptor
            guard let drawable = view.currentDrawable,
                  let renderPassDescriptor = view.currentRenderPassDescriptor else {
                return
            }
            // 更新时间 uniform
            let currentTime = CACurrentMediaTime() - startTime // 计算经过的时间
            var timeUniforms = TimeUniforms(time: Float(currentTime))
            memcpy(timeBuffer.contents(), &timeUniforms, MemoryLayout<TimeUniforms>.stride)
            timeBuffer.didModifyRange(0..<timeBuffer.length)
            
            // 根据当前时间更新网格点的位置
            updateGridPoints(time: timeUniforms.time)
            
            // 创建命令缓冲区
            guard let commandBuffer = commandQueue.makeCommandBuffer(),
                  // 创建渲染命令编码器
                  let renderEncoder = commandBuffer.makeRenderCommandEncoder(descriptor: renderPassDescriptor) else {
                return
            }
            
            // 设置渲染管线状态
            renderEncoder.setRenderPipelineState(pipelineState)
            
            // 设置顶点缓冲区
            renderEncoder.setVertexBuffer(vertexBuffer, offset: 0, index: 0) // 顶点数据
            // 注意：时间缓冲区在这里没有直接给顶点着色器，因为顶点位置是固定的。
            // 如果顶点也需要随时间变化，则需要在这里传递。

            // 设置片段着色器所需的缓冲区
            renderEncoder.setFragmentBuffer(colorBuffer, offset: 0, index: 0)       // 颜色数据
            renderEncoder.setFragmentBuffer(gridPointsBuffer, offset: 0, index: 1)  // 网格点位置
            renderEncoder.setFragmentBuffer(timeBuffer, offset: 0, index: 2)        // 时间数据 (片段着色器也可能需要)
            
            // 绘制三角形 (3个顶点)
            renderEncoder.drawPrimitives(
                type: .triangle,
                vertexStart: 0,
                vertexCount: 3
            )
            
            // 结束编码
            renderEncoder.endEncoding()
            
            // 呈现 drawable
            commandBuffer.present(drawable)
            
            // 提交命令缓冲区执行
            commandBuffer.commit()
        }
    }
}

// Metal 着色器代码字符串
// 修改了片段着色器以使用反距离加权法来混合颜色
let metalShaderSource = """
#include <metal_stdlib>
using namespace metal;

// 顶点着色器的输入结构
struct VertexIn {
    float2 position [[attribute(0)]]; // 从顶点缓冲区读取的位置属性
};

// 顶点着色器的输出结构 (传递给片段着色器)
struct VertexOut {
    float4 position [[position]]; // 裁剪空间中的顶点位置 (必需)
    float2 uv;                   // 纹理/归一化坐标
};

// Uniform 结构体，从 CPU 传递给 GPU
struct TimeUniforms {
    float time;
};

struct ColorUniforms { // 在着色器中，我们将直接使用 float4 colors[9]
    float4 colors[9]; // 9个颜色
};

struct GridPoint {
    float2 position; // 网格点的归一化位置
};

// 顶点着色器
vertex VertexOut vertexShader(
    VertexIn in [[stage_in]] // [[stage_in]] 表示这是顶点着色器的输入
) {
    VertexOut out;
    
    // 直接将输入的2D位置转换为裁剪空间的4D位置
    // z=0, w=1 是2D渲染的常见设置
    out.position = float4(in.position, 0.0, 1.0);
    
    // 将输入的顶点位置从 [-1, 1] (NDC范围的一部分) 映射到 [0, 1] 的 UV 坐标
    // 这个 UV 坐标将覆盖整个渲染区域
    out.uv = (in.position + 1.0) * 0.5; 
    
    return out;
}

// 片段着色器
fragment float4 fragmentShader(
    VertexOut in [[stage_in]], // 从顶点着色器接收插值后的数据
    constant float4 *colorsArray [[buffer(0)]],        // 颜色数组 (9个颜色)
    constant GridPoint *gridPoints [[buffer(1)]],   // 网格点数组 (9个点)
    constant TimeUniforms &timeUniforms [[buffer(2)]] // 时间 (如果需要直接在片段着色器中使用)
) {
    float2 uv = in.uv; // 当前片段的 UV 坐标 [0,1]
    
    float4 totalColor = float4(0.0); // 初始化累积颜色
    float totalWeight = 0.0;         // 初始化累积权重
    
    // sharpness 控制颜色点的“锐度”或影响范围
    // 数值越大，影响范围越小，颜色点越清晰；数值越小，混合越平滑模糊
    float sharpness = 10.0; // 可以调整这个值以获得期望的效果

    // 遍历所有9个网格点
    for (int i = 0; i < 9; ++i) {
        float2 pointPos = gridPoints[i].position;
        float2 offset = uv - pointPos;
        float dist = length(offset);
        float angleFactor = offset.x * 0.5 + offset.y * 1.5;
        float weight = exp(-sharpness * dist) * (1.0 + 0.8 * sin(angleFactor * 10.0));

        totalColor += colorsArray[i] * weight;
        totalWeight += weight;
    }

    float4 finalColor;
    if (totalWeight == 0.0 || totalWeight < 0.0001) { // 避免除以零或极小的权重
        // 如果总权重几乎为零 (例如像素离所有点都很远，或者 sharpness 极高)
        // 可以返回一个默认颜色，或者第一个点的颜色，或者透明
        finalColor = colorsArray[0]; 
    } else {
        finalColor = totalColor / totalWeight; // 标准化颜色
    }
    
    // 可以选择性地对最终的 alpha 进行平滑处理，如果需要的话
    // finalColor.a = smoothstep(0.0, 1.0, finalColor.a); 
    // 如果颜色本身已经包含了alpha，并且希望它平滑过渡，可以保留此行。
    // 如果希望alpha直接由混合决定，可以注释掉。

    return finalColor;
}
"""


// ===============================
// FILE: ./AudioSync/view/FullScreenView.swift
// ===============================
import AppKit
import Combine
import SwiftUI

struct FullScreenView: View {
    @EnvironmentObject var viewmodel: ViewModel
    @State private var cachedColors: [Color] = []
    @Binding var isPresented: Bool

    var body: some View {
        Group {
            if isPresented {
                ZStack {
                    GeometryReader { geo in
                        HStack {
                            albumArt
                                .frame(
                                    minWidth: 0.50 * (geo.size.width),
                                    maxWidth: canDisplayLyrics
                                        ? 0.50 * (geo.size.width) : .infinity
                                )
                            if canDisplayLyrics {
                                LyricsPlayerViewWrapper(
                                    lyrics: viewmodel.currentlyPlayingLyrics,
                                    currentIndex: $viewmodel
                                        .currentlyPlayingLyricsIndex,
                                    geo: geo
                                )
                                .frame(
                                    minWidth: 0.50 * (geo.size.width),
                                    maxWidth: 0.50 * (geo.size.width)
                                )
                            }
                        }
                    }
                }
                .background {
                    ZStack {
                        if !cachedColors.isEmpty {
                            AnimatedMeshGradientView(
                                colors: cachedColors
                            )
                        }
                        Color.black.opacity(0.1)
                    }
                }
                .onAppear {
                    // 修复：确保视图出现时初始化颜色和歌词
                    cachedColors = meshColors()
                }
                .onChange(of: viewmodel.currentTrack?.color) {
                    oldValue,
                    newValue in
                    cachedColors = meshColors()
                }
                // 修复：监听歌词变化以确保更新
                .onChange(of: viewmodel.currentlyPlayingLyrics) { _, newValue in
                    if !newValue.isEmpty {
                        cachedColors = meshColors()
                    }
                }
            }
        }
    }

    struct LyricsPlayerViewWrapper: NSViewRepresentable {
        let lyrics: [LyricLine]
        @Binding var currentIndex: Int?
        let geo: GeometryProxy
        let padding: CGFloat = 22
        let textHeight: CGFloat = 60
        var translationHeight: CGFloat = 0

        func makeNSView(context: Context) -> NSScrollView {
            let scrollView = NSScrollView()
            scrollView.hasVerticalScroller = true
            scrollView.autohidesScrollers = true
            scrollView.drawsBackground = false

            // 创建文档视图容器
            let containerView = NSView()
            scrollView.documentView = containerView
            context.coordinator.containerView = containerView

            // 设置滚动视图代理
            scrollView.contentView.postsBoundsChangedNotifications = true
            NotificationCenter.default.addObserver(
                context.coordinator,
                selector: #selector(Coordinator.scrollViewDidScroll(_:)),
                name: NSView.boundsDidChangeNotification,
                object: scrollView.contentView
            )

            return scrollView
        }

        func updateNSView(_ scrollView: NSScrollView, context: Context) {
            let coordinator = context.coordinator
            coordinator.parent = self

            // 更新歌词行
            updateLyricLines(
                coordinator: coordinator,
                scrollView: scrollView
            )

            // 自动滚动逻辑
            if !coordinator.isUserScrolling {
                scrollToCurrentLyric(
                    coordinator: coordinator,
                    scrollView: scrollView
                )
            }

            // 优化：只更新附近行的透明度
            updateNearbyLineTransparencies(coordinator: coordinator)
        }

        private func updateLyricLines(
            coordinator: Coordinator,
            scrollView: NSScrollView
        ) {
            guard let containerView = coordinator.containerView else { return }

            // 如果歌词数量没有变化，只需更新受影响的行
            if coordinator.lastLyricsCount == lyrics.count {
                // 优化：只更新变化的行
                updateChangedLines(coordinator: coordinator)
                return
            }

            // 清除旧视图
            containerView.subviews.forEach { $0.removeFromSuperview() }
            coordinator.lineViews.removeAll()

            // 创建新歌词行
            var yOffset: CGFloat = 0
            let topSpacing = geo.size.height / 2.5
            let bottomSpacing = geo.size.height / 1.5

            // 添加顶部间距
            let topSpacer = NSView(
                frame: CGRect(
                    x: 0,
                    y: yOffset,
                    width: geo.size.width,
                    height: topSpacing
                )
            )
            containerView.addSubview(topSpacer)
            yOffset += topSpacing

            for (index, line) in lyrics.reversed().enumerated() {
                let reversedIndex = lyrics.count - 1 - index
                let isActive = reversedIndex == currentIndex
                var duration: Int = 0
                if reversedIndex < lyrics.count - 1 {
                    let nextTime = lyrics[reversedIndex + 1].startTimeMS
                    let currentTime = lyrics[reversedIndex].startTimeMS
                    duration = Int((nextTime - currentTime) * 1000)
                }
                // 计算翻译高度（如果存在）
                let translationHeight: CGFloat =
                    if let translation = line.attachments[.translation()]?
                        .stringValue,
                        !translation.isEmpty
                    {
                        30  // 为翻译预留额外高度
                    } else {
                        0
                    }
                let totalHeight = textHeight + translationHeight
                let lineView = LyricLineView(
                    element: line,
                    isActive: isActive,
                    fontName: NSFont.boldSystemFont(ofSize: 30).fontName,
                    currentIndex: currentIndex,
                    lineIndex: reversedIndex,
                    duration: duration,
                    totalHeight: totalHeight,
                    width: geo.size.width
                )

                lineView.frame = CGRect(
                    x: 0,
                    y: yOffset,
                    width: geo.size.width,  // 使用geo的宽度确保初始布局正确
                    height: totalHeight
                )

                containerView.addSubview(lineView)
                yOffset += totalHeight + padding

                // 存储引用
                coordinator.lineViews.append(lineView)
            }

            // 添加底部间距
            let bottomSpacer = NSView(
                frame: CGRect(
                    x: 0,
                    y: yOffset,
                    width: geo.size.width,
                    height: bottomSpacing
                )
            )
            containerView.addSubview(bottomSpacer)
            yOffset += bottomSpacing

            // 更新容器大小
            containerView.frame = CGRect(
                origin: .zero,
                size: CGSize(
                    width: geo.size.width,
                    height: yOffset
                )
            )

            // 更新内容大小
            scrollView.documentView?.setFrameSize(
                NSSize(width: geo.size.width, height: yOffset)
            )

            // 记录当前歌词数量
            coordinator.lastLyricsCount = lyrics.count
            coordinator.lastCurrentIndex = currentIndex
        }

        // 优化：只更新变化的行
        private func updateChangedLines(coordinator: Coordinator) {
            guard let lastIndex = coordinator.lastCurrentIndex,
                let newIndex = currentIndex,
                lastIndex != newIndex
            else { return }

            // 更新旧当前行
            if let oldLineView = coordinator.lineViews.first(where: {
                $0.lineIndex == lastIndex
            }) {
                oldLineView.updateActiveState(isActive: false)
            }

            // 更新新当前行
            if let newLineView = coordinator.lineViews.first(where: {
                $0.lineIndex == newIndex
            }) {
                newLineView.updateActiveState(isActive: true)
            }

            coordinator.lastCurrentIndex = newIndex
        }

        private func scrollToCurrentLyric(
            coordinator: Coordinator,
            scrollView: NSScrollView
        ) {
            guard let currentIndex = currentIndex,
                lyrics.indices.contains(currentIndex),
                let documentView = scrollView.documentView
            else { return }

            let topSpacing = geo.size.height / 2.5
            let totalLines = lyrics.count
            let visibleIndex = totalLines - 1 - currentIndex
            let lineViews = coordinator.lineViews
            let targetLineIndex = visibleIndex

            // 累加目标行之前所有行的高度
            let yOffset = lineViews.prefix(targetLineIndex).reduce(CGFloat(0)) {
                partialResult,
                lineView in
                partialResult + lineView.totalHeight + padding
            }

            // 再加上目标行的一半高度让它居中
            let targetY =
                yOffset - (scrollView.contentSize.height - topSpacing) / 2
                + (lineViews[targetLineIndex].totalHeight / 2)
            // 确保目标位置在有效范围内
            let maxY = documentView.frame.height - scrollView.contentSize.height
            let clampedY = min(max(targetY, 0), maxY)

            coordinator.isProgrammaticScroll = true
            NSAnimationContext.runAnimationGroup { context in
                context.duration = 1  // 缩短动画时间
                context.timingFunction = CAMediaTimingFunction(
                    name: .easeInEaseOut
                )
                scrollView.contentView.animator().setBoundsOrigin(
                    NSPoint(x: 0, y: clampedY)
                )
            } completionHandler: {
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                    coordinator.isProgrammaticScroll = false
                }
            }
        }

        // 优化：只更新附近行的透明度
        private func updateNearbyLineTransparencies(coordinator: Coordinator) {
            guard let currentIndex = currentIndex else { return }

            let visibleRange =
                max(
                    0,
                    currentIndex - 2
                )...min(
                    lyrics.count - 1,
                    currentIndex + 2
                )

            for lineView in coordinator.lineViews {
                if visibleRange.contains(lineView.lineIndex) {
                    lineView.updateTransparency(currentIndex: currentIndex)
                }
            }
        }

        func makeCoordinator() -> Coordinator {
            Coordinator(parent: self)
        }

        class Coordinator: NSObject {
            var parent: LyricsPlayerViewWrapper
            var isUserScrolling = false
            var containerView: NSView?
            var lineViews: [LyricLineView] = []
            var isProgrammaticScroll = false
            var lastLyricsCount = 0
            var lastCurrentIndex: Int? = nil  // 跟踪上一次的当前行索引

            init(parent: LyricsPlayerViewWrapper) {
                self.parent = parent
            }

            @objc func scrollViewDidScroll(_ notification: Notification) {
                guard !isProgrammaticScroll else { return }
                isUserScrolling = true
                NSObject.cancelPreviousPerformRequests(withTarget: self)
                perform(
                    #selector(resetScrollingFlag),
                    with: nil,
                    afterDelay: 1.0
                )
            }

            @objc private func resetScrollingFlag() {
                isUserScrolling = false
            }
        }
    }

    // MARK: - macOS 歌词行视图（优化版）
    class LyricLineView: NSView {
        private let backgroundLabel = NSTextField()
        private let highlightLabel = NSTextField()
        private var element: LyricLine
        private var currentIndex: Int?
        let lineIndex: Int
        let duration: Int?
        let dispearMills = 500
        private var lastDistance: Int? = nil
        private var displayLink: CADisplayLink?
        private var animationStartTime: CFTimeInterval = 0
        private var animationDuration: CFTimeInterval = 0
        let totalHeight: CGFloat
        private let translationLabel = NSTextField()  // 将翻译标签改为属性
        private var translationHeight: CGFloat = 0
        private let maxWidth: CGFloat
        init(
            element: LyricLine,
            isActive: Bool,
            fontName: String,
            currentIndex: Int?,
            lineIndex: Int,
            duration: Int?,
            totalHeight: CGFloat,
            width: CGFloat
        ) {
            self.element = element
            self.currentIndex = currentIndex
            self.lineIndex = lineIndex
            self.duration = duration
            self.totalHeight = totalHeight
            self.maxWidth = width
            super.init(frame: .zero)
            self.wantsLayer = true
            setupViews(isActive: isActive, fontName: fontName)
        }

        required init?(coder: NSCoder) {
            fatalError("init(coder:) has not been implemented")
        }

        private func setupViews(isActive: Bool, fontName: String) {
            // 配置标签
            configureLabel(
                label: backgroundLabel,
                text: element.words,
                isActive: isActive,
                isHighlight: false,
                fontName: fontName
            )
            configureLabel(
                label: highlightLabel,
                text: element.words,
                isActive: isActive,
                isHighlight: true,
                fontName: fontName
            )

            // 添加翻译（如果存在）
            if let translation = element.attachments[.translation()]?
                .stringValue,
                !translation.isEmpty
            {
                translationHeight = 40  // 翻译行高度
                configureLabel(
                    label: translationLabel,
                    text: translation,
                    isActive: isActive,
                    isHighlight: true,
                    fontName: fontName,
                    isTranslation: true
                )
                addSubview(translationLabel)
            } else {
                translationHeight = 0
            }

            // 添加子视图
            addSubview(backgroundLabel)
            addSubview(highlightLabel)

            // 设置初始透明度
            updateTransparency(currentIndex: currentIndex)
        }

        func updateActiveState(isActive: Bool) {
            configureLabel(
                label: backgroundLabel,
                text: element.words,
                isActive: isActive,
                isHighlight: false,
                fontName: backgroundLabel.font?.fontName ?? ""
            )
            configureLabel(
                label: highlightLabel,
                text: element.words,
                isActive: isActive,
                isHighlight: true,
                fontName: highlightLabel.font?.fontName ?? ""
            )
        }

        func updateElement(element: LyricLine, isActive: Bool, fontName: String)
        {
            self.element = element
            backgroundLabel.stringValue = element.words
            highlightLabel.stringValue = element.words

            // 更新翻译
            if let translation = element.attachments[.translation()]?
                .stringValue, !translation.isEmpty
            {
                // 查找现有的翻译标签或创建新的
                var translationLabel: NSTextField?
                for subview in subviews {
                    if let label = subview as? NSTextField,
                        label != backgroundLabel && label != highlightLabel
                    {
                        translationLabel = label
                        break
                    }
                }

                if translationLabel == nil {
                    translationLabel = NSTextField()
                    translationLabel?.isEditable = false
                    translationLabel?.isBordered = false
                    translationLabel?.isBezeled = false
                    translationLabel?.drawsBackground = false
                    addSubview(translationLabel!)
                }

                configureLabel(
                    label: translationLabel!,
                    text: translation,
                    isActive: isActive,
                    isHighlight: true,
                    fontName: fontName,
                    isTranslation: true
                )
                translationLabel?.frame = CGRect(
                    x: 0,
                    y: 40,
                    width: bounds.width,
                    height: 20
                )
            } else {
                // 移除翻译标签（如果存在）
                for subview in subviews {
                    if let label = subview as? NSTextField,
                        label != backgroundLabel && label != highlightLabel
                    {
                        label.removeFromSuperview()
                    }
                }
            }

            // 更新透明度
            updateTransparency(currentIndex: currentIndex)
        }

        func updateTransparency(currentIndex: Int?) {
            self.currentIndex = currentIndex
            guard let currentIndex = currentIndex else {
                alphaValue = 0.5
                return
            }

            // 计算当前行与目标行的距离
            let distance = lineIndex - currentIndex

            if distance == -1 {
                // 确保动画只在需要时触发
                if lastDistance == 0 || alphaValue > 0 {
                    startFadeOutAnimation()
                }
            }
            // 其他情况直接设置透明度
            else {
                // 根据距离设置透明度
                var opacity: CGFloat
                if distance == 0 {
                    opacity = 1.0
                } else if distance < -1 {
                    opacity = 0
                } else {
                    opacity = 0.5
                }

                // 立即设置透明度
                NSAnimationContext.runAnimationGroup { context in
                    context.duration = 0.1
                    self.animator().alphaValue = opacity
                }
            }

            lastDistance = distance
        }

        private func configureLabel(
            label: NSTextField,
            text: String,
            isActive: Bool,
            isHighlight: Bool,
            fontName: String,
            isTranslation: Bool = false
        ) {
            // 添加换行支持
            label.cell?.wraps = true
            label.cell?.isScrollable = false
            label.lineBreakMode = .byWordWrapping
            label.maximumNumberOfLines = 0
            label.stringValue = text
            label.isEditable = false
            label.isBordered = false
            label.isBezeled = false
            label.drawsBackground = false

            label.font = NSFont(name: fontName, size: isTranslation ? 24 : 38)

            if isActive {
                if isHighlight {
                    label.textColor = .white
                } else {
                    label.textColor = NSColor.white.withAlphaComponent(0.3)
                }
            } else {
                label.textColor = NSColor.white.withAlphaComponent(0.5)
            }

            let textHeight = calculateTextHeight(
                text: text,
                font: label.font,
                width: maxWidth
            )

            // 如果是翻译标签，更新高度
            if isTranslation {
                translationHeight = textHeight
            }
        }
        // 计算文本高度
        private func calculateTextHeight(
            text: String,
            font: NSFont?,
            width: CGFloat
        ) -> CGFloat {
            guard let font = font else { return 40 }

            let textRect = (text as NSString).boundingRect(
                with: CGSize(width: width, height: .greatestFiniteMagnitude),
                options: [.usesLineFragmentOrigin, .usesFontLeading],
                attributes: [.font: font],
                context: nil
            )

            return max(40, textRect.height)  // 最小高度40
        }
        override func layout() {
            super.layout()
            backgroundLabel.frame = CGRect(
                x: 0,
                y: 0,
                width: bounds.width,
                height: 60  // 增加高度以适应多行
            )
            highlightLabel.frame = backgroundLabel.frame

            // 翻译标签布局
            if translationHeight > 0 {
                translationLabel.frame = CGRect(
                    x: 0,
                    y: backgroundLabel.frame.maxY + 5,
                    width: bounds.width,
                    height: translationHeight
                )
                translationLabel.isHidden = false
            } else {
                translationLabel.isHidden = true
            }

            // 更新翻译标签位置和高度
            for subview in subviews {
                if let label = subview as? NSTextField,
                    label != backgroundLabel && label != highlightLabel
                {
                    label.frame = CGRect(
                        x: 0,
                        y: 40,
                        width: bounds.width,
                        height: totalHeight - 40  // 使用剩余高度
                    )
                }
            }
        }

        private func startFadeOutAnimation() {
            // 停止任何正在进行的动画
            stopFadeOutAnimation()

            // 计算动画持续时间
            animationDuration =
                Double(min(dispearMills, duration ?? dispearMills)) / 1000.0

            // 设置动画开始时间
            animationStartTime = CACurrentMediaTime()
            // 使用新的 displayLink API
            displayLink = self.displayLink(
                target: self,
                selector: #selector(updateFadeAnimation)
            )
            displayLink?.add(to: .main, forMode: .common)
        }

        @objc private func updateFadeAnimation() {
            guard displayLink != nil else { return }

            let currentTime = CACurrentMediaTime()
            let elapsedTime = currentTime - animationStartTime
            let progress = min(1.0, CGFloat(elapsedTime / animationDuration))

            // 在主线程安全更新 UI
            DispatchQueue.main.async {
                self.alphaValue = 1.0 - progress

                if progress >= 1.0 {
                    self.stopFadeOutAnimation()
                }
            }
        }

        private func stopFadeOutAnimation() {
            if let token = displayLink {
                token.invalidate()
                displayLink = nil
            }
        }

        deinit {
            stopFadeOutAnimation()
        }
    }

    var canDisplayLyrics: Bool {
        viewmodel.isViewLyricsShow
    }

    func meshColors() -> [Color] {
        if var result = viewmodel.currentTrack?.color {
            while result.count < 9 {
                if let color = viewmodel.currentTrack?.color?.randomElement() {
                    result.append(color)
                }
            }
            return result
        }
        return []
    }

    @ViewBuilder var albumArt: some View {
        VStack {
            Spacer()
            if let album = viewmodel.currentTrack?.albumCover {
                Image(nsImage: album)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
                    .clipShape(
                        .rect(
                            cornerRadii: .init(
                                topLeading: 10,
                                bottomLeading: 10,
                                bottomTrailing: 10,
                                topTrailing: 10
                            )
                        )
                    )
                    .shadow(radius: 5)
                    .frame(
                        width: canDisplayLyrics ? 450 : 700,
                        height: canDisplayLyrics ? 450 : 700
                    )
            } else {
                Image(systemName: "music.note.list")
                    .resizable()
                    .shadow(radius: 3)
                    .scaleEffect(0.5)
                    .background(.gray)
                    .clipShape(
                        .rect(
                            cornerRadii: .init(
                                topLeading: 10,
                                bottomLeading: 10,
                                bottomTrailing: 10,
                                topTrailing: 10
                            )
                        )
                    )
                    .shadow(radius: 5)
                    .frame(
                        width: canDisplayLyrics ? 450 : 650,
                        height: canDisplayLyrics ? 450 : 650
                    )
            }
            Group {
                Text(verbatim: viewmodel.currentTrack?.name ?? "")
                    .font(
                        .custom(
                            NSFont.boldSystemFont(ofSize: 28).fontName,
                            size: 28
                        )
                    )
                    .bold()
                    .foregroundStyle(.white)
                    .padding(.top, 30)
                    .lineLimit(2)
                    .multilineTextAlignment(.center)
                    .frame(maxWidth: (canDisplayLyrics ? 450 : 650) * 0.9)
                Text(verbatim: viewmodel.currentTrack?.artist ?? "")
                    .font(
                        .custom(
                            NSFont.boldSystemFont(ofSize: 22).fontName,
                            size: 22
                        )
                    )
                    .foregroundStyle(.white)
                    .opacity(0.7)
            }
            .frame(height: 35)
            HStack {
                Button {
                    viewmodel.isViewLyricsShow.toggle()
                } label: {
                    Image(systemName: "music.note.list")
                }
                .disabled(viewmodel.currentlyPlayingLyrics.isEmpty)
            }
            Spacer()
        }
    }

}


// ===============================
// FILE: ./AudioSync/view/KaraokeView.swift
// ===============================
//
//  KaraokeView.swift
//  AudioSync
//
//  Created by solo on 5/12/25.
//

import SwiftUI

struct KaraokeView: View {

    @EnvironmentObject var viewmodel: ViewModel
    func multilingualView(_ currentlyPlayingLyricsIndex: Int) -> some View {
        VStack(spacing: 6) {
            Text(
                verbatim: viewmodel.currentlyPlayingLyrics[
                    currentlyPlayingLyricsIndex
                ].words
            )
            if let trlycs = viewmodel.currentlyPlayingLyrics[
                currentlyPlayingLyricsIndex
            ].attachments[.translation()]?.stringValue, !trlycs.isEmpty {
                Text(verbatim: trlycs)
                    .font(
                        .custom(
                            viewmodel.karaokeFont.fontName,
                            size: 0.9 * (viewmodel.karaokeFont.pointSize)
                        )
                    )
                //                    .opacity(0.85)
            }
        }
    }

    @ViewBuilder func lyricsView() -> some View {
        if let currentlyPlayingLyricsIndex = viewmodel
            .currentlyPlayingLyricsIndex,
            viewmodel.currentlyPlayingLyrics.indices.contains(
                currentlyPlayingLyricsIndex
            ),
            !viewmodel.currentlyPlayingLyrics[currentlyPlayingLyricsIndex].words
                .isEmpty
        {
            multilingualView(currentlyPlayingLyricsIndex)
        } else {
            Text("···")
        }
    }
    var body: some View {
        lyricsView()
            .lineLimit(2)
            .foregroundStyle(.white)
            .minimumScaleFactor(0.9)
            .font(
                .custom(
                    viewmodel.karaokeFont.fontName,
                    size: viewmodel.karaokeFont.pointSize
                )
            )
            .padding(10)
            .padding(.horizontal, 10)
            .background {
                VisualEffectView().ignoresSafeArea()
                if let colors = viewmodel.currentTrack?.color {
                    if !colors.isEmpty {
                        ZStack {
                            LinearGradient(
                                gradient: Gradient(
                                    colors: colors
                                ),
                                startPoint: .topLeading,
                                endPoint: .bottomTrailing
                            )
                            Color.black.opacity(0.1)
                        }
                    }
                }

            }
            .cornerRadius(16)
            .multilineTextAlignment(.center)
            .frame(
                minWidth: 800,
                maxWidth: 800,
                minHeight: 100,
                maxHeight: 100,
                alignment: .center
            )

    }
}
struct VisualEffectView: NSViewRepresentable {
    func makeNSView(context: Context) -> NSVisualEffectView {
        let view = NSVisualEffectView()

        view.blendingMode = .behindWindow
        view.state = .active
        view.material = .popover

        return view
    }

    func updateNSView(_ nsView: NSVisualEffectView, context: Context) {

        nsView.material = .popover
        nsView.blendingMode = .behindWindow
    }
}
//#Preview {
//    KaraokeView()
//        .environmentObject(ViewModel.preview)
//}


// ===============================
// FILE: ./AudioSync/view/LyricsSelectorView.swift
// ===============================
//
//  LyricsSelectorView.swift
//  AudioSync
//
//  Created by solo on 5/19/25.
//
import SwiftUI

struct LyricsSelectorView: View {
    @EnvironmentObject var viewModel: ViewModel

    var body: some View {
        ZStack {
            VStack(alignment: .leading, spacing: 0) {
                // 固定 currentTrack 显示
                if let trackName = viewModel.currentTrack?.name {
                    HStack(spacing: 12) {
                        // 左侧封面（圆角封面图片，支持 NSImage 转换；无图时显示默认占位图形）
                        if let albumCover = viewModel.currentTrack?.albumCover {
                            albumCover.toSwiftUIImage()
                                .resizable()
                                .aspectRatio(contentMode: .fill)
                                .frame(width: 45, height: 45)
                                .clipShape(RoundedRectangle(cornerRadius: 4))
                        } else {
                            RoundedRectangle(cornerRadius: 4)
                                .fill(Color(NSColor.controlAccentColor))
                                .frame(width: 45, height: 45)
                        }

                        // 歌曲名 + 艺人信息
                        VStack(alignment: .leading, spacing: 2) {
                            Text("\(trackName)")
                                .font(.system(size: 15, weight: .semibold))
                                .foregroundColor(Color(NSColor.labelColor))

                            if let artist = viewModel.currentTrack?.artist {
                                Text(artist)
                                    .font(.system(size: 13))
                                    .foregroundColor(Color(NSColor.secondaryLabelColor))
                            }
                        }

                        Spacer()
                        
                        Button(action: {
                            withAnimation {
                                viewModel.needNanualSelection = false
                                viewModel.onCandidateSelected = nil
                            }
                        }) {
                            Image(systemName: "xmark.circle.fill")
                                .foregroundColor(Color.green.opacity(0.6))
                                .imageScale(.large)
                        }
                        .buttonStyle(.plain)
                        .help("取消选择")
                    }
                    .padding(.horizontal, 16)
                    .padding(.bottom, 5)
                    .padding(.top, 5)
                }
                // 滚动候选项
                ScrollView(.vertical, showsIndicators: true) {
                    LazyVStack(spacing: 0) {
                        ForEach(viewModel.allCandidates, id: \.id) { song in
                            CandidateRow(song: song, viewModel: viewModel) // 提取子视图
                                .frame(height: 42) // 固定行高
                                .padding(.horizontal)
                            
                            Divider()
                                .background(Color(NSColor.separatorColor))
                                .padding(.horizontal)
                        }
                    }
                    .padding(.top, 8)
                }
            }
            .frame(width: 420, height: 450) // 固定尺寸
            .background(
                RoundedRectangle(cornerRadius: 16)
                    .fill(Color(NSColor.windowBackgroundColor).opacity(0.9))
                    .shadow(color: .black.opacity(0.2), radius: 8, y: 4)
            )
            .padding(20)
        }
    }

    // 提取子视图
    private struct CandidateRow: View {
        let song: CandidateSong // 假设Song是你的数据模型
        let viewModel: ViewModel
        @State private var isHovered = false
        
        var body: some View {
            Button(action: selectSong) {
                HStack {
                    if  !song.albumCover.isEmpty, let url = URL(string: song.albumCover) {
                        AsyncImage(url: url) { image in
                            image
                                .resizable()
                                .aspectRatio(contentMode: .fill)
                        } placeholder: {
                            RoundedRectangle(cornerRadius: 4)
                                .fill(Color(NSColor.controlAccentColor).opacity(0.3))
                        }
                        .frame(width: 40, height: 40)
                        .clipShape(RoundedRectangle(cornerRadius: 4))
                    } else {
                        RoundedRectangle(cornerRadius: 4)
                            .fill(Color(NSColor.controlAccentColor))
                            .frame(width: 40, height:40)
                    }
                    // 水平滚动文本容器
                    ScrollView(.horizontal, showsIndicators: false) {
                        Text("\(song.name) - \(song.artist) - \(song.album)")
                            .font(.system(size: 16, weight: .medium))
                            .foregroundColor(Color(NSColor.secondaryLabelColor))
                            .padding(.horizontal, 16)
                    }
                    .frame(maxWidth: .infinity, alignment: .leading)
                }
                .frame(height: 42)
                .background(isHovered ? Color.blue.opacity(0.6) : Color.clear) // 悬停背景
                .cornerRadius(8)
                .contentShape(Rectangle()) // 确保整个区域可点击
            }
            .buttonStyle(.plain)
            .onHover { hovering in
                withAnimation(.easeInOut(duration: 0.15)) {
                    isHovered = hovering
                }
            }
        }
        
        private func selectSong() {
            withAnimation {
                viewModel.needNanualSelection = false
                viewModel.onCandidateSelected?(song)
                viewModel.onCandidateSelected = nil
            }
        }
    }
}


// ===============================
// FILE: ./AudioSync/view/SimilarArtistView.swift
// ===============================
//
//  SimilarArtist.swift
//  AudioSync
//
//  Created by solo on 11/6/25.
//

import SwiftUI

struct SimilarArtistView: View {
    @EnvironmentObject var viewmodel: ViewModel
    var body: some View {
        if let artist = viewmodel.currentTrack?.artist {
            HStack(spacing: 8) {
                Spacer()
                ScrollView(.horizontal, showsIndicators: false) {
                    HStack {
                        Text("\(artist)")
                            .font(.system(size: 16, weight: .medium))
                            .foregroundColor(Color(NSColor.secondaryLabelColor))
                            .frame(maxWidth: .infinity, alignment: .center)
                    }
                    .frame(minWidth: 120)
                }
                .frame(width: 120)
                Text(" 相似歌手")
                    .font(.system(size: 16, weight: .medium))
                    .foregroundColor(
                        Color(NSColor.secondaryLabelColor)
                    )
                    .frame(width: 70)
                Button(action: {
                    withAnimation {
                        viewmodel.refreshSimilarArtist = true
                    }
                }) {
                    Image(systemName: "arrow.clockwise.circle")
                        .font(.system(size: 18))  // 放大按钮图标
                        .foregroundColor(.secondary)  // 与整体配色一致
                        .background(Color.clear)  // 背景透明
                        .contentShape(Circle())  // 扩大点击范围但保持透明
                }
                .buttonStyle(PlainButtonStyle())
                Spacer()
            }
            .padding(5)
            .frame(width: 250)
        }
        ScrollView {
            LazyVStack(spacing: 12) {
                ForEach(0..<viewmodel.similarArtists.count, id: \.self) { i in
                    Button(action: {
                        openMusic(artist: viewmodel.similarArtists[i].name)
                    }) {
                        HStack(alignment: .center, spacing: 18) {
                            if let image = viewmodel.similarArtists[i].image,
                                let nsImage = NSImage(data: image)
                            {
                                Image(nsImage: nsImage)
                                    .resizable()
                                    .frame(width: 45, height: 45)
                                    .clipShape(
                                        RoundedRectangle(cornerRadius: 4)
                                    )
                            } else {
                                Image(systemName: "person.crop.square")
                                    .frame(width: 45, height: 45)
                                    .clipShape(
                                        RoundedRectangle(cornerRadius: 4)
                                    )
                            }

                            ScrollView(.horizontal, showsIndicators: false) {
                                Text(viewmodel.similarArtists[i].name)
                                    .font(.system(size: 16, weight: .medium))
                                    .foregroundColor(
                                        Color(NSColor.secondaryLabelColor)
                                    )
                                    .padding()
                            }
                            .frame(width: 120, alignment: .center)

                        }
                        .padding()
                        .frame(maxWidth: .infinity, alignment: .center)
                        .background(
                            RoundedRectangle(cornerRadius: 10)
                                .fill(
                                    Color(NSColor.windowBackgroundColor)
                                        .opacity(
                                            0.15
                                        )
                                )
                        )
                    }
                    .contentShape(Rectangle())
                    .buttonStyle(PlainButtonStyle())  // 去掉默认蓝色按钮效果
                    .frame(height: 50)
                    Divider()
                }
            }
        }
        .cornerRadius(10)
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(Color(NSColor.controlBackgroundColor))  // 整体背景色
        //.padding(.vertical, 16)
    }
    private func openMusic(artist: String) {
        Task {
            let artistID = try await IDFetcher.fetchArtistID(
                name: "",
                artist: artist
            )
            // 步骤 2: 使用 ID 跳转到艺术家主页 (使用 Universal Link，如 MusicNavigator 中所推荐)
            _ = try MusicNavigator.openArtistPage(
                by: String(artistID)
            )
        }
    }
}

#Preview {
    let previewViewModel: ViewModel = {
        let vm = ViewModel()
        vm.currentTrack = TrackInfo(
            name: "nextName",
            artist: "nextArtist",
            albumArtist: "nextAlbum",
            trackID: "trackID",
            album: "nextAlbum",
            state: .playing,
            genre: "genre",
            color: [],
            albumCover: nil
        )
        vm.similarArtists = [
            Artist(name: "Artist A", url: ""),
            Artist(name: "Artist B", url: ""),
            Artist(name: "Artist C", url: ""),
        ]
        return vm
    }()

    SimilarArtistView()
        .environmentObject(previewViewModel)
}


// ===============================
// FILE: ./AudioSync/view/SimilarSongView.swift
// ===============================
//
//  SimilarSongView.swift
//  AudioSync
//
//  Created by solo on 5/19/25.
//
import SwiftUI

struct SimilarSongView: View {
    @EnvironmentObject var viewModel: ViewModel

    var body: some View {
        ZStack {
            VStack(alignment: .leading, spacing: 0) {
                // 固定 currentTrack 显示
                if let trackName = viewModel.currentTrack?.name {
                    HStack(spacing: 12) {
                        // 左侧封面（圆角封面图片，支持 NSImage 转换；无图时显示默认占位图形）
                        if let albumCover = viewModel.currentTrack?.albumCover {
                            albumCover.toSwiftUIImage()
                                .resizable()
                                .aspectRatio(contentMode: .fill)
                                .frame(width: 45, height: 45)
                                .clipShape(RoundedRectangle(cornerRadius: 4))
                        } else {
                            RoundedRectangle(cornerRadius: 4)
                                .fill(Color(NSColor.controlAccentColor))
                                .frame(width: 45, height: 45)
                        }

                        // 歌曲名 + 艺人信息
                        VStack(alignment: .leading, spacing: 2) {
                            Text("\(trackName)")
                                .font(.system(size: 15, weight: .semibold))
                                .foregroundColor(Color(NSColor.labelColor))

                            if let artist = viewModel.currentTrack?.artist {
                                Text(artist)
                                    .font(.system(size: 13))
                                    .foregroundColor(
                                        Color(NSColor.secondaryLabelColor)
                                    )
                            }
                        }

                        Spacer()

                        Button(action: {
                            withAnimation {
                                viewModel.needNanualSelection = false
                                viewModel.onCandidateSelected = nil
                            }
                        }) {
                            Image(systemName: "xmark.circle.fill")
                                .foregroundColor(Color.green.opacity(0.6))
                                .imageScale(.large)
                        }
                        .buttonStyle(.plain)
                        .help("取消选择")
                    }
                    .padding(.horizontal, 16)
                    .padding(.bottom, 5)
                    .padding(.top, 5)
                }
                // 滚动候选项
                ScrollView(.vertical, showsIndicators: true) {
                    LazyVStack(spacing: 0) {
                        ForEach(viewModel.allCandidates, id: \.id) { song in
                            CandidateRow(song: song, viewModel: viewModel)  // 提取子视图
                                .frame(height: 42)  // 固定行高
                                .padding(.horizontal)

                            Divider()
                                .background(Color(NSColor.separatorColor))
                                .padding(.horizontal)
                        }
                    }
                    .padding(.top, 8)
                }
            }
            .frame(width: 420, height: 450)  // 固定尺寸
            .background(
                RoundedRectangle(cornerRadius: 16)
                    .fill(Color(NSColor.windowBackgroundColor).opacity(0.9))
                    .shadow(color: .black.opacity(0.2), radius: 8, y: 4)
            )
            .padding(20)
        }
    }

    // 提取子视图
    private struct CandidateRow: View {
        let song: CandidateSong  // 假设Song是你的数据模型
        let viewModel: ViewModel
        @State private var isHovered = false

        var body: some View {
            Button(action: selectSong) {
                HStack {
                    if !song.albumCover.isEmpty,
                        let url = URL(string: song.albumCover)
                    {
                        AsyncImage(url: url) { image in
                            image
                                .resizable()
                                .aspectRatio(contentMode: .fill)
                        } placeholder: {
                            RoundedRectangle(cornerRadius: 4)
                                .fill(
                                    Color(NSColor.controlAccentColor).opacity(
                                        0.3
                                    )
                                )
                        }
                        .frame(width: 40, height: 40)
                        .clipShape(RoundedRectangle(cornerRadius: 4))
                    } else {
                        RoundedRectangle(cornerRadius: 4)
                            .fill(Color(NSColor.controlAccentColor))
                            .frame(width: 40, height: 40)
                    }
                    // 水平滚动文本容器
                    ScrollView(.horizontal, showsIndicators: false) {
                        Text("\(song.name) - \(song.artist) - \(song.album)")
                            .font(.system(size: 16, weight: .medium))
                            .foregroundColor(Color(NSColor.secondaryLabelColor))
                            .padding(.horizontal, 16)
                    }
                    .frame(maxWidth: .infinity, alignment: .leading)
                }
                .frame(height: 42)
                .background(isHovered ? Color.blue.opacity(0.6) : Color.clear)  // 悬停背景
                .cornerRadius(8)
                .contentShape(Rectangle())  // 确保整个区域可点击
            }
            .buttonStyle(.plain)
            .onHover { hovering in
                withAnimation(.easeInOut(duration: 0.15)) {
                    isHovered = hovering
                }
            }
        }

        private func selectSong() {
            withAnimation {
                viewModel.needNanualSelection = false
                viewModel.onCandidateSelected?(song)
                viewModel.onCandidateSelected = nil
            }
        }
    }
}