AIPlayRingtones/AIPlayRingtones/Common/TSAudioPlayer/TSBusinessAudioPlayer.swift

//
//  TSBusinessAudioPlayer.swift
//  AIRingtone
//
//  Created by 100Years on 2025/3/7.
//

import AVFoundation
class TSBusinessAudioPlayer {
    
    static let shared = TSBusinessAudioPlayer()
    
    enum PlayerState:Equatable {
        case play
        case pause
        case stop
        case loading(Float)
        case volume(Float)
        case currentTime(Double)
    }
    
    private var audioPlayer: TSAudioPlayer?
    
    var stateChangedHandle:((PlayerState) -> Void)?
    var currentTimeChangedHandle:((Double,Double) -> Void)?
    
    var currentPlayerState:PlayerState = .stop
    var duration:Double{
        if let audioPlayer = audioPlayer {
            return audioPlayer.duration
        }
        return 0.0
    }

    var isPlaying:Bool{
        if let audioPlayer = audioPlayer {
            return audioPlayer.isPlaying
        }
        return false
    }
    
    var isLoading:Bool{
        switch currentPlayerState {
        case .loading(let float):
            return float < 1.0 ? true : false
        default:
            return false
        }
    }
    
    var currentTime:Double{
        if let audioPlayer = audioPlayer {
            return audioPlayer.currentTime
        }
        return 0.0
    }
    
    /// 跳转到指定时间
    /// - Parameter time: 目标时间（秒）
    func seek(to time: Double) {
        audioPlayer?.seek(to: time)
    }
    
    var playProgress:Double{
        let playProgress = currentTime / duration
//        dePrint("TSAudioPlayer playProgress = \(playProgress)")
        return playProgress
    }
    
    //播放器是否可用
    var playerUsable:Bool {
        if let audioPlayer = audioPlayer {
            return audioPlayer.playerUsable
        }
        return false
    }
    var currentURLString:String = ""
    var currentLocalURL:URL? = nil
    var currentIndexPath:IndexPath? = nil
    
    //加载音乐可能 2-3 秒有结果,停止加载后播放.
    private var isStopPlayingAfterLoading:Bool = false

    func isPlayURLString(string:String,localURL:URL? = nil,indexPath:IndexPath? = nil) -> Bool {

        if currentURLString == string {
            
            if let currentIndexPath = currentIndexPath,
               let indexPath = indexPath,
               indexPath != currentIndexPath
            {
                return false
            }else if let currentLocalURL = currentLocalURL,
                let localURL = localURL,
                currentLocalURL != localURL
             {
                 return false
             }else{
                return true
            }
        }
        return false
    }
    
    func loadLoactionURL(url:URL){
        self.audioPlayer = TSAudioPlayer(url: url)
    }

    func playUrlString(_ urlString:String?,localURL:URL? = nil,loop:Bool = false,indexPath:IndexPath? = nil) {
        self.stop()
        if let urlString = urlString {
            
            self.currentURLString = urlString
            self.currentLocalURL = localURL
            self.currentIndexPath = indexPath

            let palyFile:(URL)->Void = { [weak self] url in
                guard let self = self else { return }
                debugPrint("TSAudioPlayer 正在播放url:\(currentURLString)")
                debugPrint("TSAudioPlayer 正在播放path:\(url)")
                self.audioPlayer = TSAudioPlayer(url: url)
                self.audioPlayer?.setLoop(loop)
                
                if self.audioPlayer?.volume == 0 {
                    setVolume(volume: 1.0)
                }
                
                self.audioPlayer?.currentTimeChanged = { [weak self] currentTime,duration in
                    guard let self = self else { return }
                    currentTimeChangedHandle?(currentTime,duration)
                    changePlayerState(.currentTime(currentTime))
                }
                
                self.play()
                dePrint(self.audioPlayer?.duration)
                
                self.audioPlayer?.audioPlayerDidFinishHandle = { [weak self] flag in
                    guard let self = self else { return }
                    if flag == true, self.audioPlayer?.isLooping == false{
                        stop()
                    }
                }
            }
            
            isStopPlayingAfterLoading = false
            
            if let path = self.currentLocalURL,TSFileManagerTool.fileExists(at: path){
                palyFile(path) //播放
                
            }else{
                self.changePlayerState(.loading(0.0))
                
                _ = ASDownloadManager.getDownLoadRing(urlString: urlString, progressHandler: { progress in
                    dePrint("ASDownloadManager.etDownLoadRing progress = \(progress)")
                }, complete: {[weak self] url, success in
                    
                    guard let self = self else { return }
                    
                    self.changePlayerState(.loading(1.0))
                
                    if isStopPlayingAfterLoading == true || currentURLString != urlString{
                        isStopPlayingAfterLoading = false
                        return
                    }
                    
                    if let url = url {
                        palyFile(url) //播放
                    }else{
                        //暂停
                        self.stop()
                    }
                })
            }
        }
    }
    

    func play() {
        self.audioPlayer?.play()
        changePlayerState(.play)
    }
    
    func stop() {
        self.audioPlayer?.currentTimeChanged = nil
        isStopPlayingAfterLoading = true
        currentURLString = ""
        self.audioPlayer?.stop()
        changePlayerState(.stop)
    }
    
    func pause() {
        isStopPlayingAfterLoading = true
        self.audioPlayer?.pause()
        changePlayerState(.pause)
    }
    
    func setVolume(volume:Float){
        self.audioPlayer?.volume = volume
        changePlayerState(.volume(volume))
    }
    

    func changeAudioSwitch()->Float {
        let volume:Float = self.audioPlayer?.volume == 0.0 ? 1.0 : 0.0
        setVolume(volume: volume)
        return volume
    }
    
    func changePlayerState(_ state:PlayerState){

        if case .currentTime(let time) = state {} else {
            debugPrint("TSAudioPlayer changePlayerState=\(state)")
        }
        currentPlayerState = state
        kExecuteOnMainThread{
            self.stateChangedHandle?(state)
//            NotificationCenter.default.post(name: .kBusinessAudioStateChange, object: nil, userInfo: ["PlayerState": state])
        }
    }
     
    deinit {
        dePrint("TSAudioPlayer TSBusinessAudioPlayer deinit")
    }
}


extension TSBusinessAudioPlayer{
    struct AudioFileInfo {
        let sizeInBytes: UInt64?    // 文件大小（字节）
        let durationInSeconds: Double?  // 音频时长（秒）
        let songName: String?  // 音频时长（秒）
    }

    static func getAudioFileInfo(path: String) -> AudioFileInfo? {
        // 1. 检查URL有效性
        guard let url = URL(string: path) else {
            print("getAudioFileInfo 无效的URL字符串")
            return nil
        }
        
        // 2. 检查文件是否存在（仅限本地文件）
        guard FileManager.default.fileExists(atPath: url.path) else {
            print("getAudioFileInfo 文件不存在或不是本地路径")
            return nil
        }
        
        // 3. 获取文件大小
        let fileSize: UInt64? = {
            do {
                let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
                return attributes[.size] as? UInt64
            } catch {
                print("获取文件大小失败: \(error.localizedDescription)")
                return nil
            }
        }()
        
        // 4. 获取音频时长
        let duration: Double? = {
            return getAudioDurationWithAudioFile(url: url)
        }()
        
        // 5. 获取音频名称
        let songName: String? = {
            return getSongNameFromLocalFile(fileURL: url)
        }()
        
        return AudioFileInfo(sizeInBytes: fileSize, durationInSeconds: duration,songName: songName)
    }
    
    /// 同步获取音频时长（可能阻塞线程！）
    /// 使用 AudioFile 同步获取音频时长
    static func getAudioDurationWithAudioFile(url: URL) -> TimeInterval? {
        var audioFile: AudioFileID?
        let status = AudioFileOpenURL(url as CFURL, .readPermission, 0, &audioFile)
        
        guard status == noErr, let file = audioFile else {
            print("⚠️ 打开音频文件失败: \(status)")
            return nil
        }
        
        // 获取音频时长（单位：秒）
        var duration: Float64 = 0
        var propertySize = UInt32(MemoryLayout.size(ofValue: duration))
        let durationStatus = AudioFileGetProperty(
            file,
            kAudioFilePropertyEstimatedDuration,
            &propertySize,
            &duration
        )
        
        AudioFileClose(file)
        
        return durationStatus == noErr ? duration : nil
    }
    
    //获取音频的名称
    static func getSongNameFromLocalFile(fileURL: URL) -> String? {
        // 1. 检查文件是否存在
        guard FileManager.default.fileExists(atPath: fileURL.path) else {
            print("文件不存在")
            return nil
        }
        
        // 2. 创建 AVAsset 对象（代表音频文件）
        let asset = AVAsset(url: fileURL)
        
        // 3. 同步读取元数据（适用于本地文件）
        var songName: String? = nil
        let metadataFormats = asset.availableMetadataFormats
        
        for format in metadataFormats {
            let metadata = asset.metadata(forFormat: format)
            
            // 4. 遍历元数据项，查找歌曲标题
            for item in metadata {
                if item.commonKey == .commonKeyTitle, // 标准键：标题
                   let value = item.value as? String { // 确保值是字符串
                    songName = value
                    break
                }
                
                // 额外检查 ID3 标签（某些 MP3 文件可能用非标准键）
                if item.key as? String == "TIT2", // ID3v2 标题键
                   let value = item.value as? String {
                    songName = value
                    break
                }
            }
            
            if songName != nil { break }
        }
        
        // 5. 返回结果（若未找到，则尝试从文件名推断）
        return songName ?? fileURL.deletingPathExtension().lastPathComponent
    }
}