// M3U8DownloadManager.kt

import kotlinx.coroutines.*
import okhttp3.*
import okio.buffer
import okio.sink
import okio.source
import java.io.*
import java.util.concurrent.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import java.util.regex.Pattern
import java.net.URL

/**
 * M3U8文件解析器
 */
class M3U8Parser {
    // M3U8文件信息
    data class M3U8Info(
        val masterUrl: String,             // 主M3U8 URL
        val baseUrl: String,               // 基础URL
        val duration: Float = 0f,          // 总时长(秒)
        val segmentList: List<M3U8Segment> // 分片列表
    )
    
    // 分片信息
    data class M3U8Segment(
        val url: String,         // 分片URL
        val duration: Float,     // 分片时长(秒)
        val index: Int,          // 分片索引
        var tsFilePath: String = "" // 本地保存路径
    )
    
    // 解析M3U8文件
    suspend fun parse(url: String, client: OkHttpClient): M3U8Info = withContext(Dispatchers.IO) {
        // 发送请求获取M3U8内容
        val request = Request.Builder()
            .url(url)
            .build()
            
        val response = client.newCall(request).execute()
        if (!response.isSuccessful) {
            throw IOException("Failed to fetch M3U8 file: ${response.code}")
        }
        
        val content = response.body?.string() ?: throw IOException("Empty M3U8 content")
        
        // 判断是否是主播放列表
        if (content.contains("#EXT-X-STREAM-INF")) {
            return@withContext parseMainPlaylist(url, content, client)
        } else {
            return@withContext parseMediaPlaylist(url, content)
        }
    }
    
    // 解析主播放列表
    private suspend fun parseMainPlaylist(masterUrl: String, content: String, client: OkHttpClient): M3U8Info = withContext(Dispatchers.IO) {
        // 提取带宽最高的子播放列表
        val lines = content.split("\n")
        var maxBandwidth = 0
        var selectedUrl = ""
        
        for (i in lines.indices) {
            val line = lines[i]
            if (line.startsWith("#EXT-X-STREAM-INF")) {
                // 提取带宽参数
                val bandwidthPattern = Pattern.compile("BANDWIDTH=(\\d+)")
                val matcher = bandwidthPattern.matcher(line)
                if (matcher.find()) {
                    val bandwidth = matcher.group(1).toInt()
                    if (bandwidth > maxBandwidth) {
                        maxBandwidth = bandwidth
                        // 下一行应该是URL
                        if (i + 1 < lines.size) {
                            val urlLine = lines[i + 1].trim()
                            if (!urlLine.startsWith("#")) {
                                selectedUrl = urlLine
                            }
                        }
                    }
                }
            }
        }
        
        // 如果URL是相对路径，转换为完整URL
        val fullUrl = if (selectedUrl.startsWith("http")) {
            selectedUrl
        } else {
            val baseUrl = URL(masterUrl)
            val path = if (selectedUrl.startsWith("/")) {
                selectedUrl
            } else {
                val masterPath = baseUrl.path
                val lastSlash = masterPath.lastIndexOf('/')
                if (lastSlash != -1) {
                    masterPath.substring(0, lastSlash + 1) + selectedUrl
                } else {
                    "/$selectedUrl"
                }
            }
            URL(baseUrl.protocol, baseUrl.host, baseUrl.port, path).toString()
        }
        
        // 解析子播放列表
        return@withContext parse(fullUrl, client)
    }
    
    // 解析媒体播放列表
    private fun parseMediaPlaylist(url: String, content: String): M3U8Info {
        val lines = content.split("\n")
        val segments = mutableListOf<M3U8Segment>()
        var totalDuration = 0f
        var segmentDuration = 0f
        var segmentIndex = 0
        var isFirstSegment = true
        
        // 提取基础URL
        val baseUrl = getBaseUrl(url)
        
        for (line in lines) {
            val trimmedLine = line.trim()
            
            // 提取片段时长
            if (trimmedLine.startsWith("#EXTINF:")) {
                val durationText = trimmedLine.substring(8).split(",")[0]
                segmentDuration = durationText.toFloat()
                isFirstSegment = false
                continue
            }
            
            // 提取片段URL
            if (!trimmedLine.startsWith("#") && trimmedLine.isNotEmpty() && !isFirstSegment) {
                // 构建完整URL
                val segmentUrl = if (trimmedLine.startsWith("http")) {
                    trimmedLine
                } else {
                    if (trimmedLine.startsWith("/")) {
                        // 绝对路径
                        val urlObj = URL(url)
                        URL(urlObj.protocol, urlObj.host, urlObj.port, trimmedLine).toString()
                    } else {
                        // 相对路径
                        "$baseUrl$trimmedLine"
                    }
                }
                
                segments.add(M3U8Segment(segmentUrl, segmentDuration, segmentIndex++))
                totalDuration += segmentDuration
            }
        }
        
        return M3U8Info(url, baseUrl, totalDuration, segments)
    }
    
    // 获取基础URL
    private fun getBaseUrl(url: String): String {
        val lastSlash = url.lastIndexOf('/')
        return if (lastSlash != -1) {
            url.substring(0, lastSlash + 1)
        } else {
            "$url/"
        }
    }
}

/**
 * M3U8下载管理器
 */
class M3U8DownloadManager {
    private val client = OkHttpClient.Builder()
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .build()
        
    private val downloadScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    private val m3u8Parser = M3U8Parser()
    private val downloadManager = DownloadManager.getInstance()
    
    // 下载状态
    enum class M3U8DownloadStatus {
        IDLE, PARSING, DOWNLOADING, MERGING, COMPLETED, FAILED, CANCELED
    }
    
    // M3U8下载监听器
    interface M3U8DownloadListener {
        fun onParsingProgress(url: String, progress: Int)
        fun onDownloadProgress(url: String, progress: Int, downloadedSegments: Int, totalSegments: Int)
        fun onMergingProgress(url: String, progress: Int)
        fun onStatusChanged(url: String, status: M3U8DownloadStatus)
        fun onSuccess(url: String, filePath: String)
        fun onFailed(url: String, e: Exception)
    }
    
    // M3U8下载任务
    data class M3U8DownloadTask(
        val url: String,
        val savePath: String,
        val fileName: String,
        var status: M3U8DownloadStatus = M3U8DownloadStatus.IDLE,
        var m3u8Info: M3U8Parser.M3U8Info? = null,
        var downloadedSegments: AtomicInteger = AtomicInteger(0),
        var mergeProgress: AtomicInteger = AtomicInteger(0)
    )
    
    private val downloadTasks = ConcurrentHashMap<String, M3U8DownloadTask>()
    private val listeners = ConcurrentHashMap<String, MutableList<M3U8DownloadListener>>()
    private val activeDownloads = AtomicInteger(0)
    private val maxConcurrentDownloads = 3
    
    // 添加下载任务
    fun addTask(url: String, savePath: String, fileName: String): M3U8DownloadTask {
        val taskId = url.hashCode().toString()
        
        return downloadTasks.getOrPut(taskId) {
            // 创建保存目录
            val saveDir = File(savePath)
            if (!saveDir.exists()) {
                saveDir.mkdirs()
            }
            
            // 创建临时目录
            val tempDir = File(savePath, ".temp_$fileName")
            if (!tempDir.exists()) {
                tempDir.mkdirs()
            }
            
            M3U8DownloadTask(url, savePath, fileName)
        }
    }
    
    // 添加监听器
    fun addListener(url: String, listener: M3U8DownloadListener) {
        val taskId = url.hashCode().toString()
        val taskListeners = listeners.getOrPut(taskId) { mutableListOf() }
        taskListeners.add(listener)
    }
    
    // 移除监听器
    fun removeListener(url: String, listener: M3U8DownloadListener) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.remove(listener)
    }
    
    // 开始下载
    fun startDownload(url: String) {
        val taskId = url.hashCode().toString()
        val task = downloadTasks[taskId] ?: return
        
        if (task.status != M3U8DownloadStatus.IDLE && 
            task.status != M3U8DownloadStatus.FAILED) {
            return
        }
        
        // 修改状态为解析中
        task.status = M3U8DownloadStatus.PARSING
        notifyStatusChanged(task.url, task.status)
        
        downloadScope.launch {
            try {
                // 1. 解析M3U8文件
                notifyParsingProgress(task.url, 0)
                val m3u8Info = m3u8Parser.parse(task.url, client)
                task.m3u8Info = m3u8Info
                notifyParsingProgress(task.url, 100)
                
                // 2. 准备下载分片
                task.status = M3U8DownloadStatus.DOWNLOADING
                notifyStatusChanged(task.url, task.status)
                
                // 重置计数器
                task.downloadedSegments.set(0)
                
                // 3. 下载所有分片
                val tempDir = File(task.savePath, ".temp_${task.fileName}")
                downloadAllSegments(task, m3u8Info, tempDir.absolutePath)
                
                // 4. 合并分片
                task.status = M3U8DownloadStatus.MERGING
                notifyStatusChanged(task.url, task.status)
                task.mergeProgress.set(0)
                
                mergeSegments(task, m3u8Info, tempDir.absolutePath)
                
                // 5. 完成
                task.status = M3U8DownloadStatus.COMPLETED
                notifyStatusChanged(task.url, task.status)
                
                // 6. 清理临时文件
                cleanupTempFiles(tempDir)
                
                // 7. 通知成功
                val outputFilePath = File(task.savePath, task.fileName).absolutePath
                notifySuccess(task.url, outputFilePath)
                
            } catch (e: Exception) {
                if (task.status != M3U8DownloadStatus.CANCELED) {
                    task.status = M3U8DownloadStatus.FAILED
                    notifyStatusChanged(task.url, task.status)
                    notifyFailed(task.url, e)
                }
            }
        }
    }
    
    // 下载所有分片
    private suspend fun downloadAllSegments(
        task: M3U8DownloadTask, 
        m3u8Info: M3U8Parser.M3U8Info, 
        tempDirPath: String
    ) = withContext(Dispatchers.IO) {
        val totalSegments = m3u8Info.segmentList.size
        val segmentJobs = mutableListOf<Deferred<Boolean>>()
        val semaphore = Semaphore(20) // 限制同时下载的分片数
        
        for (segment in m3u8Info.segmentList) {
            val segmentFile = File(tempDirPath, "segment_${segment.index}.ts")
            segment.tsFilePath = segmentFile.absolutePath
            
            // 如果分片已存在且大小大于0，则跳过
            if (segmentFile.exists() && segmentFile.length() > 0) {
                task.downloadedSegments.incrementAndGet()
                val progress = (task.downloadedSegments.get() * 100 / totalSegments)
                notifyDownloadProgress(task.url, progress, task.downloadedSegments.get(), totalSegments)
                continue
            }
            
            // 使用信号量限制并发
            semaphore.acquire()
            
            val job = downloadScope.async {
                try {
                    // 下载分片
                    val request = Request.Builder()
                        .url(segment.url)
                        .build()
                        
                    client.newCall(request).execute().use { response ->
                        if (!response.isSuccessful) {
                            throw IOException("Failed to download segment: ${response.code}")
                        }
                        
                        val responseBody = response.body ?: throw IOException("Empty response body")
                        
                        // 保存分片
                        segmentFile.sink().buffer().use { sink ->
                            responseBody.source().use { source ->
                                sink.writeAll(source)
                            }
                        }
                        
                        // 更新进度
                        val downloaded = task.downloadedSegments.incrementAndGet()
                        val progress = (downloaded * 100 / totalSegments)
                        notifyDownloadProgress(task.url, progress, downloaded, totalSegments)
                        
                        return@async true
                    }
                } catch (e: Exception) {
                    return@async false
                } finally {
                    semaphore.release()
                }
            }
            
            segmentJobs.add(job)
        }
        
        // 等待所有分片下载完成
        val results = segmentJobs.awaitAll()
        
        // 检查是否有失败的分片
        if (results.contains(false)) {
            throw IOException("Some segments failed to download")
        }
    }
    
    // 合并分片
    private suspend fun mergeSegments(
        task: M3U8DownloadTask, 
        m3u8Info: M3U8Parser.M3U8Info, 
        tempDirPath: String
    ) = withContext(Dispatchers.IO) {
        val segments = m3u8Info.segmentList
        val totalSegments = segments.size
        val outputFile = File(task.savePath, task.fileName)
        
        // 如果是mp4文件，需要先合并为ts，再转换为mp4
        val isMp4 = task.fileName.endsWith(".mp4", ignoreCase = true)
        val tempOutputFile = if (isMp4) {
            File(task.savePath, "${task.fileName}.ts")
        } else {
            outputFile
        }
        
        // 创建输出流
        val outputStream = FileOutputStream(tempOutputFile)
        
        try {
            // 依次写入每个分片
            for ((index, segment) in segments.withIndex()) {
                val segmentFile = File(segment.tsFilePath)
                if (!segmentFile.exists()) {
                    throw IOException("Segment file not found: ${segment.tsFilePath}")
                }
                
                // 写入分片数据
                segmentFile.source().buffer().use { source ->
                    outputStream.sink().buffer().use { sink ->
                        sink.writeAll(source)
                    }
                }
                
                // 更新进度
                val progress = ((index + 1) * 100 / totalSegments)
                task.mergeProgress.set(progress)
                notifyMergingProgress(task.url, progress)
            }
        } finally {
            outputStream.close()
        }
        
        // 如果是mp4，需要进行格式转换
        if (isMp4) {
            // 这里使用简单文件重命名代替格式转换
            // 实际应用中，应该使用FFmpeg等工具进行正确的格式转换
            if (tempOutputFile.exists()) {
                tempOutputFile.renameTo(outputFile)
            }
        }
    }
    
    // 清理临时文件
    private fun cleanupTempFiles(tempDir: File) {
        if (tempDir.exists()) {
            tempDir.listFiles()?.forEach { it.delete() }
            tempDir.delete()
        }
    }
    
    // 取消下载
    fun cancelDownload(url: String) {
        val taskId = url.hashCode().toString()
        val task = downloadTasks[taskId] ?: return
        
        task.status = M3U8DownloadStatus.CANCELED
        notifyStatusChanged(task.url, task.status)
        
        // 清理临时目录
        val tempDir = File(task.savePath, ".temp_${task.fileName}")
        cleanupTempFiles(tempDir)
    }
    
    // 获取下载任务
    fun getTask(url: String): M3U8DownloadTask? {
        val taskId = url.hashCode().toString()
        return downloadTasks[taskId]
    }
    
    // 通知解析进度
    private fun notifyParsingProgress(url: String, progress: Int) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onParsingProgress(url, progress)
        }
    }
    
    // 通知下载进度
    private fun notifyDownloadProgress(url: String, progress: Int, downloadedSegments: Int, totalSegments: Int) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onDownloadProgress(url, progress, downloadedSegments, totalSegments)
        }
    }
    
    // 通知合并进度
    private fun notifyMergingProgress(url: String, progress: Int) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onMergingProgress(url, progress)
        }
    }
    
    // 通知状态变化
    private fun notifyStatusChanged(url: String, status: M3U8DownloadStatus) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onStatusChanged(url, status)
        }
    }
    
    // 通知下载成功
    private fun notifySuccess(url: String, filePath: String) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onSuccess(url, filePath)
        }
    }
    
    // 通知下载失败
    private fun notifyFailed(url: String, e: Exception) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onFailed(url, e)
        }
    }
    
    // 释放资源
    fun release() {
        downloadScope.cancel()
        downloadTasks.clear()
        listeners.clear()
    }
}

// M3U8下载示例

fun main() {
    // 创建M3U8下载管理器
    val m3u8DownloadManager = M3U8DownloadManager()
    
    // 添加下载任务
    val task = m3u8DownloadManager.addTask(
        url = "https://example.com/video.m3u8",
        savePath = "/downloads",
        fileName = "video.mp4"  // 可以是.mp4或.ts格式
    )
    
    // 添加下载监听器
    m3u8DownloadManager.addListener(task.url, object : M3U8DownloadManager.M3U8DownloadListener {
        override fun onParsingProgress(url: String, progress: Int) {
            println("解析进度: $progress%")
        }
        
        override fun onDownloadProgress(url: String, progress: Int, downloadedSegments: Int, totalSegments: Int) {
            println("下载进度: $progress%, 已下载分片: $downloadedSegments/$totalSegments")
        }
        
        override fun onMergingProgress(url: String, progress: Int) {
            println("合并进度: $progress%")
        }
        
        override fun onStatusChanged(url: String, status: M3U8DownloadManager.M3U8DownloadStatus) {
            println("状态变更: $status")
        }
        
        override fun onSuccess(url: String, filePath: String) {
            println("下载成功: $filePath")
        }
        
        override fun onFailed(url: String, e: Exception) {
            println("下载失败: ${e.message}")
        }
    })
    
    // 开始下载
    m3u8DownloadManager.startDownload(task.url)
    
    // 等待下载完成
    readLine()
    
    // 清理资源
    m3u8DownloadManager.release()
}

// WorkManagerNetworkDownloader.kt

import android.app.*
import android.content.Context
import android.content.Intent
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import android.os.Build
import androidx.annotation.RequiresApi
import androidx.core.app.NotificationCompat
import androidx.lifecycle.*
import androidx.room.*
import androidx.work.*
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import okhttp3.*
import java.io.*
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger

/**
 * 下载任务实体类
 */
@Entity(tableName = "download_tasks")
data class DownloadTask(
    @PrimaryKey val id: String,
    val url: String,
    val fileName: String,
    val savePath: String,
    val totalBytes: Long = 0,
    val downloadedBytes: Long = 0,
    val status: DownloadStatus = DownloadStatus.PENDING,
    val priority: Int = 0,
    val createTime: Long = System.currentTimeMillis(),
    val lastUpdated: Long = System.currentTimeMillis(),
    val errorCount: Int = 0,
    val errorMessage: String? = null
)

/**
 * 下载状态枚举
 */
enum class DownloadStatus {
    PENDING,            // 等待下载
    CONNECTING,         // 连接中
    DOWNLOADING,        // 下载中
    PAUSED,             // 暂停状态（用户主动暂停）
    WAITING_FOR_NETWORK,// 等待网络连接
    COMPLETED,          // 下载完成
    FAILED,             // 下载失败
    CANCELED            // 下载取消
}

/**
 * 下载任务DAO
 */
@Dao
interface DownloadTaskDao {
    @Query("SELECT * FROM download_tasks ORDER BY priority DESC, createTime ASC")
    fun getAllTasks(): Flow<List<DownloadTask>>

    @Query("SELECT * FROM download_tasks WHERE status = :status ORDER BY priority DESC, createTime ASC")
    fun getTasksByStatus(status: DownloadStatus): Flow<List<DownloadTask>>

    @Query("SELECT * FROM download_tasks WHERE status IN (:statuses) ORDER BY priority DESC, createTime ASC")
    fun getTasksByStatuses(statuses: List<DownloadStatus>): Flow<List<DownloadTask>>

    @Query("SELECT * FROM download_tasks WHERE id = :taskId")
    suspend fun getTaskById(taskId: String): DownloadTask?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertTask(task: DownloadTask)

    @Update
    suspend fun updateTask(task: DownloadTask)

    @Delete
    suspend fun deleteTask(task: DownloadTask)

    @Query("UPDATE download_tasks SET status = :newStatus WHERE id = :taskId")
    suspend fun updateTaskStatus(taskId: String, newStatus: DownloadStatus)

    @Query("UPDATE download_tasks SET downloadedBytes = :downloadedBytes, lastUpdated = :lastUpdated WHERE id = :taskId")
    suspend fun updateTaskProgress(taskId: String, downloadedBytes: Long, lastUpdated: Long)

    @Query("UPDATE download_tasks SET status = :newStatus WHERE status = :currentStatus")
    suspend fun updateTasksStatus(currentStatus: DownloadStatus, newStatus: DownloadStatus)

    @Query("UPDATE download_tasks SET status = :newStatus WHERE status IN (:currentStatuses)")
    suspend fun updateMultipleTasksStatus(currentStatuses: List<DownloadStatus>, newStatus: DownloadStatus)
}

/**
 * 下载数据库
 */
@Database(entities = [DownloadTask::class], version = 1, exportSchema = false)
abstract class DownloadDatabase : RoomDatabase() {
    abstract fun downloadTaskDao(): DownloadTaskDao

    companion object {
        @Volatile
        private var INSTANCE: DownloadDatabase? = null

        fun getDatabase(context: Context): DownloadDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    DownloadDatabase::class.java,
                    "download_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

/**
 * 下载事件 - 用于UI层观察
 */
sealed class DownloadEvent {
    data class Progress(val taskId: String, val progress: Int, val downloadedBytes: Long, val totalBytes: Long) : DownloadEvent()
    data class StatusChanged(val taskId: String, val status: DownloadStatus) : DownloadEvent()
    data class Complete(val taskId: String, val filePath: String) : DownloadEvent()
    data class Error(val taskId: String, val error: String) : DownloadEvent()
}

/**
 * 网络状态监听器
 */
class NetworkMonitor(private val context: Context) {

    interface NetworkListener {
        fun onNetworkAvailable()
        fun onNetworkUnavailable()
    }

    private val listeners = mutableListOf<NetworkListener>()
    private var isNetworkAvailable = false
    private var isMonitoring = false

    private val connectivityManager by lazy {
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    }

    // 网络回调
    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            if (!isNetworkAvailable) {
                isNetworkAvailable = true
                notifyNetworkAvailable()
            }
        }

        override fun onLost(network: Network) {
            if (!isAnyNetworkAvailable()) {
                isNetworkAvailable = false
                notifyNetworkUnavailable()
            }
        }
    }

    // 开始监听
    fun startMonitoring() {
        if (isMonitoring) return

        isNetworkAvailable = isAnyNetworkAvailable()

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            val request = NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                .build()
            connectivityManager.registerNetworkCallback(request, networkCallback)
        } else {
            // 旧版本Android可以使用广播接收器，此处省略
        }

        isMonitoring = true
    }

    // 停止监听
    fun stopMonitoring() {
        if (!isMonitoring) return

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.unregisterNetworkCallback(networkCallback)
        }

        isMonitoring = false
    }

    // 添加监听器
    fun addListener(listener: NetworkListener) {
        if (!listeners.contains(listener)) {
            listeners.add(listener)
        }
    }

    // 移除监听器
    fun removeListener(listener: NetworkListener) {
        listeners.remove(listener)
    }

    // 检查是否有可用网络
    fun isNetworkAvailable(): Boolean {
        return isAnyNetworkAvailable()
    }

    // 检查是否有任何可用网络
    private fun isAnyNetworkAvailable(): Boolean {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val network = connectivityManager.activeNetwork ?: return false
            val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false

            return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
        } else {
            @Suppress("DEPRECATION")
            val networkInfo = connectivityManager.activeNetworkInfo
            return networkInfo != null && networkInfo.isConnected
        }
    }

    // 通知网络可用
    private fun notifyNetworkAvailable() {
        listeners.forEach { it.onNetworkAvailable() }
    }

    // 通知网络不可用
    private fun notifyNetworkUnavailable() {
        listeners.forEach { it.onNetworkUnavailable() }
    }
}

/**
 * 下载工作器 - 基于WorkManager
 */
class DownloadWorker(
    appContext: Context,
    workerParams: WorkerParameters
) : CoroutineWorker(appContext, workerParams) {

    companion object {
        const val TAG_DOWNLOAD = "download_worker"
        const val KEY_TASK_ID = "task_id"
        const val KEY_RETRY_COUNT = "retry_count"
        const val MAX_RETRY_COUNT = 5
        const val NOTIFICATION_CHANNEL_ID = "download_channel"
        const val NOTIFICATION_ID = 1

        // 调度下载任务
        fun scheduleDownload(context: Context, taskId: String, retryCount: Int = 0): Operation {
            val constraints = Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresStorageNotLow(true)
                .build()

            val inputData = workDataOf(
                KEY_TASK_ID to taskId,
                KEY_RETRY_COUNT to retryCount
            )

            val request = OneTimeWorkRequestBuilder<DownloadWorker>()
                .setConstraints(constraints)
                .setInputData(inputData)
                .addTag(TAG_DOWNLOAD)
                .addTag(taskId)
                .setBackoffCriteria(
                    BackoffPolicy.EXPONENTIAL,
                    WorkRequest.MIN_BACKOFF_MILLIS,
                    TimeUnit.MILLISECONDS
                )
                .build()

            return WorkManager.getInstance(context)
                .enqueueUniqueWork(
                    "download_$taskId",
                    ExistingWorkPolicy.REPLACE,
                    request
                )
        }

        // 取消下载任务
        fun cancelDownload(context: Context, taskId: String) {
            WorkManager.getInstance(context).cancelUniqueWork("download_$taskId")
        }
    }

    private val downloadManager by lazy {
        WorkManagerNetworkDownloader.getInstance(applicationContext)
    }

    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
        val notificationManager = applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        val channel = NotificationChannel(
            NOTIFICATION_CHANNEL_ID,
            "下载通知",
            NotificationManager.IMPORTANCE_LOW
        ).apply {
            description = "显示下载进度"
            setShowBadge(false)
        }

        notificationManager.createNotificationChannel(channel)
    }

    // 创建前台通知信息
    private fun createForegroundInfo(title: String, progress: Int = 0): ForegroundInfo {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            createNotificationChannel()
        }

        val cancelIntent = WorkManager.getInstance(applicationContext)
            .createCancelPendingIntent(id)

        val notification = NotificationCompat.Builder(applicationContext, NOTIFICATION_CHANNEL_ID)
            .setContentTitle(title)
            .setTicker(title)
            .setContentText("下载中...")
            .setSmallIcon(android.R.drawable.stat_sys_download)
            .setOngoing(true)
            .setProgress(100, progress, progress == 0)
            .addAction(android.R.drawable.ic_delete, "取消", cancelIntent)
            .build()

        return ForegroundInfo(NOTIFICATION_ID, notification)
    }

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        val taskId = inputData.getString(KEY_TASK_ID) ?: return@withContext Result.failure()
        val retryCount = inputData.getInt(KEY_RETRY_COUNT, 0)

        try {
            // 获取下载任务
            val task = downloadManager.getTaskById(taskId) ?: return@withContext Result.failure()

            // 设置为前台Worker
            setForeground(createForegroundInfo("下载: ${task.fileName}"))

            // 更新任务状态
            downloadManager.updateTaskStatus(taskId, DownloadStatus.DOWNLOADING)

            // 执行下载
            val file = downloadManager.performDownload(task, this@DownloadWorker)

            // 下载完成
            downloadManager.updateTaskStatus(taskId, DownloadStatus.COMPLETED)
            downloadManager.notifyDownloadComplete(task.id, file.absolutePath)

            Result.success()
        } catch (e: Exception) {
            e.printStackTrace()

            // 判断错误类型
            val isNetworkError = e is IOException && (
                e.message?.contains("network", ignoreCase = true) == true ||
                e.message?.contains("connect", ignoreCase = true) == true ||
                e.message?.contains("timeout", ignoreCase = true) == true
            )

            if (isNetworkError) {
                // 网络错误，更新状态为等待网络
                downloadManager.updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)

                // 判断是否需要重试
                if (retryCount < MAX_RETRY_COUNT) {
                    Result.retry()
                } else {
                    downloadManager.updateTaskStatus(taskId, DownloadStatus.FAILED)
                    downloadManager.updateTaskError(
                        taskId,
                        "网络连接失败: ${e.message ?: "未知错误"}"
                    )
                    Result.failure()
                }
            } else if (isStopped) {
                // Worker被停止，可能是系统限制或用户取消
                downloadManager.updateTaskStatus(taskId, DownloadStatus.PAUSED)
                Result.retry()
            } else {
                // 其他错误
                downloadManager.updateTaskStatus(taskId, DownloadStatus.FAILED)
                downloadManager.updateTaskError(
                    taskId,
                    "下载失败: ${e.message ?: "未知错误"}"
                )
                Result.failure()
            }
        }
    }
}

/**
 * 应用生命周期观察者
 */
class AppLifecycleObserver(private val context: Context) : DefaultLifecycleObserver {

    private val downloader = WorkManagerNetworkDownloader.getInstance(context)

    override fun onStart(owner: LifecycleOwner) {
        // 应用进入前台
        downloader.onAppForeground()
    }

    override fun onStop(owner: LifecycleOwner) {
        // 应用进入后台
        downloader.onAppBackground()
    }
}

/**
 * 主下载管理器类
 */
class WorkManagerNetworkDownloader private constructor(private val context: Context) : NetworkMonitor.NetworkListener {

    companion object {
        @Volatile
        private var INSTANCE: WorkManagerNetworkDownloader? = null

        fun getInstance(context: Context): WorkManagerNetworkDownloader {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: WorkManagerNetworkDownloader(context.applicationContext).also {
                    INSTANCE = it
                }
            }
        }
    }

    private val database = DownloadDatabase.getDatabase(context)
    private val downloadTaskDao = database.downloadTaskDao()
    private val workManager = WorkManager.getInstance(context)
    private val networkMonitor = NetworkMonitor(context)

    private val downloadScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
    private val activeDownloads = AtomicInteger(0)

    private val _downloadEvents = MutableSharedFlow<DownloadEvent>(extraBufferCapacity = 64)
    val downloadEvents: SharedFlow<DownloadEvent> = _downloadEvents.asSharedFlow()

    // 任务列表Flow
    val allTasks = downloadTaskDao.getAllTasks()
    val pendingTasks = downloadTaskDao.getTasksByStatus(DownloadStatus.PENDING)
    val activeTasks = downloadTaskDao.getTasksByStatuses(
        listOf(DownloadStatus.DOWNLOADING, DownloadStatus.CONNECTING)
    )
    val completedTasks = downloadTaskDao.getTasksByStatus(DownloadStatus.COMPLETED)
    val failedTasks = downloadTaskDao.getTasksByStatus(DownloadStatus.FAILED)
    val pausedTasks = downloadTaskDao.getTasksByStatuses(
        listOf(DownloadStatus.PAUSED, DownloadStatus.WAITING_FOR_NETWORK)
    )

    // OkHttp客户端
    private val okHttpClient = OkHttpClient.Builder()
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS)
        .build()

    init {
        // 启动网络监控
        networkMonitor.addListener(this)
        networkMonitor.startMonitoring()

        // 初始化时恢复所有应该运行的任务
        downloadScope.launch {
            // 将之前正在下载的任务标记为等待状态
            downloadTaskDao.updateMultipleTasksStatus(
                listOf(DownloadStatus.DOWNLOADING, DownloadStatus.CONNECTING),
                DownloadStatus.PENDING
            )

            // 如果网络可用，启动所有等待网络的任务
            if (networkMonitor.isNetworkAvailable()) {
                downloadTaskDao.getTasksByStatus(DownloadStatus.WAITING_FOR_NETWORK).first().forEach { task ->
                    resumeDownload(task.id)
                }
            }

            // 恢复所有待处理的任务
            downloadTaskDao.getTasksByStatus(DownloadStatus.PENDING).first().forEach { task ->
                startDownload(task.id)
            }
        }
    }

    // 添加下载任务
    suspend fun addDownloadTask(
        url: String,
        fileName: String,
        savePath: String,
        priority: Int = 0
    ): String {
        val taskId = "${url.hashCode()}_${System.currentTimeMillis()}"

        // 确保保存目录存在
        val saveDir = File(savePath)
        if (!saveDir.exists()) {
            saveDir.mkdirs()
        }

        // 创建任务
        val task = DownloadTask(
            id = taskId,
            url = url,
            fileName = fileName,
            savePath = savePath,
            status = DownloadStatus.PENDING,
            priority = priority
        )

        // 保存到数据库
        downloadTaskDao.insertTask(task)

        // 触发状态变更事件
        _downloadEvents.emit(DownloadEvent.StatusChanged(taskId, DownloadStatus.PENDING))

        // 如果网络可用，立即开始下载
        if (networkMonitor.isNetworkAvailable()) {
            startDownload(taskId)
        } else {
            // 网络不可用，标记为等待网络
            updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)
        }

        return taskId
    }

    // 开始下载
    suspend fun startDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status == DownloadStatus.PENDING || task.status == DownloadStatus.PAUSED ||
            task.status == DownloadStatus.WAITING_FOR_NETWORK || task.status == DownloadStatus.FAILED) {

            // 如果网络不可用，标记为等待网络
            if (!networkMonitor.isNetworkAvailable()) {
                updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)
                return
            }

            // 更新状态为等待中
            updateTaskStatus(taskId, DownloadStatus.CONNECTING)

            // 调度下载任务
            DownloadWorker.scheduleDownload(context, taskId)

            // 增加活跃下载计数
            activeDownloads.incrementAndGet()
        }
    }

    // 暂停下载
    suspend fun pauseDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status == DownloadStatus.DOWNLOADING || task.status == DownloadStatus.CONNECTING ||
            task.status == DownloadStatus.PENDING || task.status == DownloadStatus.WAITING_FOR_NETWORK) {

            // 取消Worker
            DownloadWorker.cancelDownload(context, taskId)

            // 更新状态
            updateTaskStatus(taskId, DownloadStatus.PAUSED)

            // 减少活跃下载计数
            val activeCount = activeDownloads.decrementAndGet()
            if (activeCount < 0) {
                activeDownloads.set(0)
            }
        }
    }

    // 恢复下载
    suspend fun resumeDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status == DownloadStatus.PAUSED || task.status == DownloadStatus.FAILED ||
            task.status == DownloadStatus.WAITING_FOR_NETWORK) {

            // 如果网络可用，开始下载
            if (networkMonitor.isNetworkAvailable()) {
                updateTaskStatus(taskId, DownloadStatus.PENDING)
                startDownload(taskId)
            } else {
                // 网络不可用，标记为等待网络
                updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)
            }
        }
    }

    // 取消下载
    suspend fun cancelDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        // 取消Worker
        DownloadWorker.cancelDownload(context, taskId)

        // 更新状态
        updateTaskStatus(taskId, DownloadStatus.CANCELED)

        // 减少活跃下载计数
        val activeCount = activeDownloads.decrementAndGet()
        if (activeCount < 0) {
            activeDownloads.set(0)
        }

        // 删除部分下载的文件
        val file = File(task.savePath, task.fileName)
        if (file.exists()) {
            file.delete()
        }
    }

    // 删除任务
    suspend fun deleteTask(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        // 如果正在下载，先取消
        if (task.status == DownloadStatus.DOWNLOADING || task.status == DownloadStatus.CONNECTING ||
            task.status == DownloadStatus.PENDING || task.status == DownloadStatus.WAITING_FOR_NETWORK) {
            cancelDownload(taskId)
        }

        // 从数据库删除
        downloadTaskDao.deleteTask(task)
    }

    // 获取任务
    suspend fun getTaskById(taskId: String): DownloadTask? {
        return downloadTaskDao.getTaskById(taskId)
    }

    // 更新任务状态
    suspend fun updateTaskStatus(taskId: String, status: DownloadStatus) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status != status) {
            val updatedTask = task.copy(
                status = status,
                lastUpdated = System.currentTimeMillis()
            )

            downloadTaskDao.updateTask(updatedTask)
            _downloadEvents.emit(DownloadEvent.StatusChanged(taskId, status))
        }
    }

    // 更新任务错误信息
    suspend fun updateTaskError(taskId: String, errorMessage: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        val updatedTask = task.copy(
            errorCount = task.errorCount + 1,
            errorMessage = errorMessage,
            lastUpdated = System.currentTimeMillis()
        )

        downloadTaskDao.updateTask(updatedTask)
        _downloadEvents.emit(DownloadEvent.Error(taskId, errorMessage))
    }

    // 通知下载完成
    suspend fun notifyDownloadComplete(taskId: String, filePath: String) {
        _downloadEvents.emit(DownloadEvent.Complete(taskId, filePath))
    }

    // 执行文件下载
    suspend fun performDownload(task: DownloadTask, worker: DownloadWorker): File = withContext(Dispatchers.IO) {
        // 确保目录存在
        val saveDir = File(task.savePath)
        if (!saveDir.exists()) {
            saveDir.mkdirs()
        }

        val file = File(saveDir, task.fileName)
        var totalBytes = task.totalBytes
        var downloadedBytes = task.downloadedBytes

        // 检查文件是否已存在且有部分数据
        if (file.exists() && downloadedBytes > 0) {
            if (file.length() != downloadedBytes) {
                // 文件大小不一致，使用实际文件大小
                downloadedBytes = file.length()
            }
        } else if (downloadedBytes > 0) {
            // 文件不存在但下载记录不为0，重置下载记录
            downloadedBytes = 0
        }

        // 构建请求
        val requestBuilder = Request.Builder()
            .url(task.url)

        // 添加Range头以支持断点续传
        if (downloadedBytes > 0) {
            requestBuilder.addHeader("Range", "bytes=$downloadedBytes-")
        }

        val request = requestBuilder.build()

        // 执行请求
        okHttpClient.newCall(request).execute().use { response ->
            if (!response.isSuccessful) {
                throw IOException("HTTP error: ${response.code}")
            }

            val body = response.body ?: throw IOException("Empty response body")
            val contentLength = body.contentLength()

            // 确定总大小
            if (totalBytes <= 0 && contentLength > 0) {
                totalBytes = when {
                    response.code == 206 -> { // 断点续传
                        val contentRange = response.header("Content-Range")
                        if (contentRange != null) {
                            // 解析形如 "bytes 100-999/1000" 的Content-Range头
                            val rangeMatcher = Regex("bytes \\d+-\\d+/(\\d+)").find(contentRange)
                            rangeMatcher?.groupValues?.get(1)?.toLongOrNull() ?: (downloadedBytes + contentLength)
                        } else {
                            downloadedBytes + contentLength
                        }
                    }
                    else -> contentLength // 完整下载
                }

                // 更新任务总大小
                val updatedTask = task.copy(totalBytes = totalBytes)
                downloadTaskDao.updateTask(updatedTask)
            }

            // 准备输出流
            val outputStream = if (downloadedBytes > 0 && file.exists()) {
                FileOutputStream(file, true) // 断点续传，追加模式
            } else {
                FileOutputStream(file) // 从头下载，覆盖模式
            }

            outputStream.use { output ->
                val buffer = ByteArray(8192)
                val input = body.byteStream()
                var bytesRead: Int
                var lastProgressUpdate = 0L

                while (input.read(buffer).also { bytesRead = it } != -1) {
                    // 检查Worker是否已停止
                    if (worker.isStopped) {
                        throw InterruptedException("下载已停止")
                    }

                    // 检查网络状态
                    if (!networkMonitor.isNetworkAvailable()) {
                        throw IOException("网络连接已断开")
                    }

                    output.write(buffer, 0, bytesRead)
                    downloadedBytes += bytesRead

                    // 更新进度
                    val now = System.currentTimeMillis()
                    if (now - lastProgressUpdate > 500) { // 每500ms更新一次
                        lastProgressUpdate = now

                        val progress = if (totalBytes > 0) {
                            (downloadedBytes * 100 / totalBytes).toInt()
                        } else 0

                        // 更新数据库
                        downloadTaskDao.updateTaskProgress(task.id, downloadedBytes, now)

                        // 发送进度事件
                        _downloadEvents.emit(
                            DownloadEvent.Progress(
                                task.id,
                                progress,
                                downloadedBytes,
                                totalBytes
                            )
                        )

                        // 更新前台服务通知
                        worker.setForeground(
                            worker.createForegroundInfo(
                                "下载: ${task.fileName}",
                                progress
                            )
                        )
                    }
                }
            }
        }

        // 返回下载完成的文件
        file
    }

    // 网络变为可用
    override fun onNetworkAvailable() {
        downloadScope.launch {
            // 恢复所有等待网络的任务
            downloadTaskDao.getTasksByStatus(DownloadStatus.WAITING_FOR_NETWORK).first().forEach { task ->
                resumeDownload(task.id)
            }
        }
    }

    // 网络变为不可用
    override fun onNetworkUnavailable() {
        downloadScope.launch {
            // 暂停所有正在下载的任务
            downloadTaskDao.getTasksByStatuses(
                listOf(DownloadStatus.DOWNLOADING, DownloadStatus.CONNECTING, DownloadStatus.PENDING)
            ).first().forEach { task ->
                // 标记为等待网络
                updateTaskStatus(task.id, DownloadStatus.WAITING_FOR_NETWORK)

                // 取消当前工作
                DownloadWorker.cancelDownload(context, task.id)
            }
        }
    }

    // 应用进入前台
    fun onAppForeground() {
        downloadScope.launch {
            // 检查并恢复可能被系统暂停的任务
            downloadTaskDao.getTasksByStatus(DownloadStatus.PAUSED).first().forEach { task ->
                // 如果任务是因为系统限制被暂停的（而非用户主动暂停），则尝试恢复
                // 这里可以通过某些标记或时间戳来判断
                if (task.errorMessage?.contains("系统限制") == true ||
                    System.currentTimeMillis() - task.lastUpdated > 30000) { // 30秒内未更新

                    if (networkMonitor.isNetworkAvailable()) {
                        resumeDownload(task.id)
                    } else {
                        updateTaskStatus(task.id, DownloadStatus.WAITING_FOR_NETWORK)
                    }
                }
            }
        }
    }

    // 应用进入后台
    fun onAppBackground() {
        // 应用进入后台时，不需要特别处理，
        // 因为我们使用WorkManager来执行下载任务，
        // 这允许任务在后台继续执行
    }

    // 释放资源
    fun release() {
        networkMonitor.removeListener(this)
        networkMonitor.stopMonitoring()
        downloadScope.cancel()
    }
}