Yattee v2 rewrite

Yattee/Services/Downloads/DownloadManager+Assets.swift

@@ -0,0 +1,377 @@
+//
+//  DownloadManager+Assets.swift
+//  Yattee
+//
+//  Storyboard and thumbnail download operations for DownloadManager.
+//
+
+import Foundation
+
+#if !os(tvOS)
+
+extension DownloadManager {
+    // MARK: - Storyboard Download
+
+    /// Start downloading storyboard sprite sheets sequentially
+    func startStoryboardDownload(downloadID: UUID) {
+        guard let index = activeDownloads.firstIndex(where: { $0.id == downloadID }),
+              let storyboard = activeDownloads[index].storyboard else {
+            return
+        }
+
+        // Cancel any existing storyboard task
+        storyboardTasks[downloadID]?.cancel()
+
+        let download = activeDownloads[index]
+        let videoID = download.videoID.videoID
+            .replacingOccurrences(of: ":", with: "_")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "\\", with: "_")
+
+        let task = Task {
+            // Create storyboard directory
+            let storyboardDirName = "\(videoID)_storyboards"
+            let storyboardDir = downloadsDirectory().appendingPathComponent(storyboardDirName, isDirectory: true)
+
+            do {
+                if !fileManager.fileExists(atPath: storyboardDir.path) {
+                    try fileManager.createDirectory(at: storyboardDir, withIntermediateDirectories: true)
+                }
+            } catch {
+                LoggingService.shared.logDownloadError("Failed to create storyboard directory", error: error)
+                handleStoryboardCompletion(downloadID: downloadID, success: false)
+                return
+            }
+
+            // First, try to get VTT from proxy URL to extract actual image URLs
+            var imageURLs: [URL] = []
+
+            if let proxyUrl = storyboard.proxyUrl {
+                // Construct absolute VTT URL
+                let vttURL: URL?
+                if proxyUrl.hasPrefix("http://") || proxyUrl.hasPrefix("https://") {
+                    // Already an absolute URL
+                    vttURL = URL(string: proxyUrl)
+                } else if let baseURL = storyboard.instanceBaseURL {
+                    // Relative URL - prepend base URL
+                    var baseString = baseURL.absoluteString
+                    if baseString.hasSuffix("/"), proxyUrl.hasPrefix("/") {
+                        baseString = String(baseString.dropLast())
+                    }
+                    vttURL = URL(string: baseString + proxyUrl)
+                } else {
+                    vttURL = nil
+                }
+
+                if let vttURL {
+                    do {
+                        let (vttData, _) = try await URLSession.shared.data(from: vttURL)
+                        imageURLs = parseVTTForImageURLs(vttData, baseURL: vttURL)
+                    } catch {
+                        // VTT fetch failed, will fall back to direct URLs
+                    }
+                }
+            }
+
+            // If VTT parsing failed, fall back to direct URLs (may not work if blocked)
+            if imageURLs.isEmpty {
+                for sheetIndex in 0..<storyboard.storyboardCount {
+                    if let url = storyboard.directSheetURL(for: sheetIndex) {
+                        imageURLs.append(url)
+                    }
+                }
+            }
+
+            let totalSheets = imageURLs.count
+            var completedSheets = 0
+
+            // Download each sprite sheet sequentially
+            for (sheetIndex, sheetURL) in imageURLs.enumerated() {
+                guard !Task.isCancelled else { return }
+
+                let fileName = "sb_\(sheetIndex).jpg"
+                let fileURL = storyboardDir.appendingPathComponent(fileName)
+
+                // Skip if already downloaded
+                if fileManager.fileExists(atPath: fileURL.path) {
+                    completedSheets += 1
+                    updateStoryboardProgress(downloadID: downloadID, completed: completedSheets, total: totalSheets)
+                    continue
+                }
+
+                do {
+                    let (data, response) = try await URLSession.shared.data(from: sheetURL)
+
+                    guard let httpResponse = response as? HTTPURLResponse,
+                          httpResponse.statusCode == 200 else {
+                        continue
+                    }
+
+                    let contentType = httpResponse.value(forHTTPHeaderField: "Content-Type") ?? "unknown"
+
+                    // Verify it's actually an image
+                    guard contentType.contains("image") || data.count > 50000 else {
+                        continue
+                    }
+
+                    try data.write(to: fileURL)
+                    completedSheets += 1
+                    updateStoryboardProgress(downloadID: downloadID, completed: completedSheets, total: totalSheets)
+
+                } catch {
+                    // Continue with next sheet - non-fatal
+                }
+            }
+
+            // Complete storyboard phase
+            let success = completedSheets > 0
+            finalizeStoryboardDownload(
+                downloadID: downloadID,
+                storyboardDirName: storyboardDirName,
+                success: success
+            )
+        }
+
+        storyboardTasks[downloadID] = task
+    }
+
+    /// Parse VTT data to extract unique image URLs
+    /// - Parameters:
+    ///   - data: The VTT file data
+    ///   - baseURL: Base URL for resolving relative image paths
+    func parseVTTForImageURLs(_ data: Data, baseURL: URL) -> [URL] {
+        guard let text = String(data: data, encoding: .utf8) else {
+            return []
+        }
+
+        var uniqueURLs: [URL] = []
+        var seenURLs: Set<String> = []
+        let lines = text.components(separatedBy: .newlines)
+
+        for line in lines {
+            let trimmedLine = line.trimmingCharacters(in: .whitespaces)
+
+            // Skip empty lines, WEBVTT header, and timestamp lines
+            guard !trimmedLine.isEmpty,
+                  !trimmedLine.hasPrefix("WEBVTT"),
+                  !trimmedLine.contains("-->") else {
+                continue
+            }
+
+            // Extract URL part (before #xywh fragment)
+            let urlString = trimmedLine.components(separatedBy: "#").first ?? trimmedLine
+
+            // Resolve the URL (handle both absolute and relative URLs)
+            let resolvedURL: URL?
+            if urlString.hasPrefix("http://") || urlString.hasPrefix("https://") {
+                // Already absolute
+                resolvedURL = URL(string: urlString)
+            } else if urlString.hasPrefix("/") {
+                // Relative to host root - extract scheme and host from baseURL
+                if let scheme = baseURL.scheme, let host = baseURL.host {
+                    let port = baseURL.port.map { ":\($0)" } ?? ""
+                    resolvedURL = URL(string: "\(scheme)://\(host)\(port)\(urlString)")
+                } else {
+                    resolvedURL = nil
+                }
+            } else if !urlString.isEmpty {
+                // Relative to current path
+                resolvedURL = URL(string: urlString, relativeTo: baseURL)?.absoluteURL
+            } else {
+                resolvedURL = nil
+            }
+
+            // Only add unique URLs
+            if let url = resolvedURL, !seenURLs.contains(url.absoluteString) {
+                seenURLs.insert(url.absoluteString)
+                uniqueURLs.append(url)
+            }
+        }
+
+        return uniqueURLs
+    }
+
+    /// Update storyboard download progress
+    func updateStoryboardProgress(downloadID: UUID, completed: Int, total: Int) {
+        guard let index = activeDownloads.firstIndex(where: { $0.id == downloadID }) else {
+            return
+        }
+        activeDownloads[index].storyboardProgress = Double(completed) / Double(total)
+        recalculateOverallProgress(for: index)
+    }
+
+    /// Finalize storyboard download phase
+    func finalizeStoryboardDownload(downloadID: UUID, storyboardDirName: String, success: Bool) {
+        guard let index = activeDownloads.firstIndex(where: { $0.id == downloadID }) else {
+            return
+        }
+
+        if success {
+            activeDownloads[index].localStoryboardPath = storyboardDirName
+            activeDownloads[index].storyboardProgress = 1.0
+
+            // Calculate total storyboard size
+            let storyboardDir = downloadsDirectory().appendingPathComponent(storyboardDirName)
+            activeDownloads[index].storyboardTotalBytes = directorySize(at: storyboardDir)
+
+            LoggingService.shared.logDownload(
+                "Storyboard saved: \(activeDownloads[index].videoID.id)",
+                details: storyboardDirName
+            )
+        } else {
+            // Mark as complete even on failure (non-blocking)
+            activeDownloads[index].storyboardProgress = 1.0
+            LoggingService.shared.logDownload(
+                "Storyboard download failed (non-fatal): \(activeDownloads[index].videoID.id)"
+            )
+        }
+
+        storyboardTasks.removeValue(forKey: downloadID)
+        recalculateOverallProgress(for: index)
+        saveDownloads()
+
+        Task {
+            await checkAndCompleteDownload(downloadID: downloadID)
+        }
+    }
+
+    /// Handle storyboard completion for error cases
+    func handleStoryboardCompletion(downloadID: UUID, success: Bool) {
+        finalizeStoryboardDownload(downloadID: downloadID, storyboardDirName: "", success: success)
+    }
+
+    // MARK: - Thumbnail Download
+
+    /// Downloads video and channel thumbnails for offline Now Playing artwork.
+    /// This is a best-effort operation - failures do not affect download completion.
+    func startThumbnailDownload(downloadID: UUID) {
+        guard let index = activeDownloads.firstIndex(where: { $0.id == downloadID }) else {
+            return
+        }
+
+        // Cancel any existing thumbnail task
+        thumbnailTasks[downloadID]?.cancel()
+
+        let download = activeDownloads[index]
+        activeDownloads[index].downloadPhase = .thumbnail
+
+        let task = Task {
+            let videoID = sanitizedVideoID(download.videoID)
+            var thumbnailPath: String?
+            var channelThumbnailPath: String?
+
+            // Download video thumbnail (best quality) - best-effort, ignore failures
+            if let thumbnailURL = download.thumbnailURL {
+                thumbnailPath = await downloadThumbnail(
+                    from: thumbnailURL,
+                    filename: "\(videoID)_thumbnail.jpg"
+                )
+            }
+
+            // Download channel thumbnail - best-effort, ignore failures
+            if let channelURL = download.channelThumbnailURL {
+                let channelID = download.channelID
+                    .replacingOccurrences(of: ":", with: "_")
+                    .replacingOccurrences(of: "/", with: "_")
+                    .replacingOccurrences(of: "\\", with: "_")
+                channelThumbnailPath = await downloadThumbnail(
+                    from: channelURL,
+                    filename: "\(channelID)_avatar.jpg"
+                )
+            }
+
+            // Always complete, regardless of thumbnail success/failure
+            finalizeThumbnailDownload(
+                downloadID: downloadID,
+                thumbnailPath: thumbnailPath,
+                channelThumbnailPath: channelThumbnailPath
+            )
+        }
+
+        thumbnailTasks[downloadID] = task
+    }
+
+    /// Downloads a single thumbnail image.
+    /// Returns the filename on success, nil on failure. Never throws.
+    func downloadThumbnail(from url: URL, filename: String) async -> String? {
+        let fileURL = downloadsDirectory().appendingPathComponent(filename)
+
+        // Skip if already downloaded
+        if fileManager.fileExists(atPath: fileURL.path) {
+            return filename
+        }
+
+        do {
+            let (data, response) = try await URLSession.shared.data(from: url)
+
+            guard let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200,
+                  !data.isEmpty else {
+                LoggingService.shared.debug(
+                    "[Downloads] Thumbnail download returned non-200 or empty: \(filename)",
+                    category: .downloads
+                )
+                return nil
+            }
+
+            try data.write(to: fileURL, options: .atomic)
+            LoggingService.shared.debug(
+                "[Downloads] Thumbnail saved: \(filename)",
+                category: .downloads
+            )
+            return filename
+        } catch {
+            // Log but don't propagate - thumbnail failure is non-fatal
+            LoggingService.shared.debug(
+                "[Downloads] Thumbnail download failed (non-fatal): \(filename) - \(error.localizedDescription)",
+                category: .downloads
+            )
+            return nil
+        }
+    }
+
+    /// Finalizes thumbnail phase and completes the download.
+    /// Called regardless of whether thumbnails succeeded or failed.
+    func finalizeThumbnailDownload(
+        downloadID: UUID,
+        thumbnailPath: String?,
+        channelThumbnailPath: String?
+    ) {
+        guard let index = activeDownloads.firstIndex(where: { $0.id == downloadID }) else {
+            return
+        }
+
+        // Set paths (will be nil if download failed - that's fine)
+        activeDownloads[index].localThumbnailPath = thumbnailPath
+        activeDownloads[index].localChannelThumbnailPath = channelThumbnailPath
+
+        thumbnailTasks.removeValue(forKey: downloadID)
+
+        if thumbnailPath != nil || channelThumbnailPath != nil {
+            LoggingService.shared.logDownload(
+                "Thumbnails saved: \(activeDownloads[index].videoID.id)",
+                details: "video: \(thumbnailPath ?? "none"), channel: \(channelThumbnailPath ?? "none")"
+            )
+        }
+
+        saveDownloads()
+
+        // Thumbnail phase is complete - finalize the download
+        // (all other phases were already complete when thumbnail download started)
+        Task {
+            await completeMultiFileDownload(downloadID: downloadID)
+        }
+    }
+
+    // MARK: - Helpers
+
+    /// Helper to sanitize video ID for use in filenames
+    func sanitizedVideoID(_ videoID: VideoID) -> String {
+        videoID.videoID
+            .replacingOccurrences(of: ":", with: "_")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "\\", with: "_")
+    }
+}
+
+#endif