MangaReader/CHANGES.md

VPS Integration - Code Changes Reference

File: VPSAPIClient.swift (NEW FILE)

Created a complete API client with these sections:

1. Configuration & Initialization

   • Singleton pattern
   • URLSession setup with appropriate timeouts
   • Base URL configuration

2. Health Check

   func checkHealth() async throws -> Bool
   

3. Download Operations

   func downloadChapter(...) async throws -> VPSDownloadResult
   

   • Progress tracking via @Published properties
   • Active download tracking

4. Status Checking

   func getChapterManifest(...) async throws -> VPSChapterManifest?
   func listDownloadedChapters(...) async throws -> [VPSChapterInfo]
   

5. Image URLs

   func getImageURL(...) -> String
   

6. Management

   func deleteChapter(...) async throws -> Bool
   func getStorageStats() async throws -> VPSStorageStats
   

---

File: MangaDetailView.swift

Change 1: Import VPS Client

// Added to MangaDetailView struct
@StateObject private var vpsClient = VPSAPIClient.shared

Change 2: Add VPS Download Button to Toolbar

// In toolbar
Button {
    viewModel.showingVPSDownloadAll = true
} label: {
    Image(systemName: "icloud.and.arrow.down")
}
.disabled(viewModel.chapters.isEmpty)

Change 3: Add VPS Download Alert

.alert("Descargar a VPS", isPresented: $viewModel.showingVPSDownloadAll) {
    Button("Cancelar", role: .cancel) { }
    Button("Últimos 10 a VPS") {
        Task {
            await viewModel.downloadLastChaptersToVPS(count: 10)
        }
    }
    Button("Todos a VPS") {
        Task {
            await viewModel.downloadAllChaptersToVPS()
        }
    }
} message: {
    Text("¿Cuántos capítulos quieres descargar al servidor VPS?")
}

Change 4: Update ChapterRowView

struct ChapterRowView: View {
    // Added:
    let onVPSDownloadToggle: () async -> Void
    @ObservedObject var vpsClient = VPSAPIClient.shared
    @State private var isVPSDownloaded = false
    @State private var isVPSChecked = false

Change 5: Add VPS Status Indicator in ChapterRowView Body

// VPS Download Button / Status
if isVPSChecked {
    if isVPSDownloaded {
        Image(systemName: "icloud.fill")
            .foregroundColor(.blue)
    } else {
        Button {
            Task {
                await onVPSDownloadToggle()
            }
        } label: {
            Image(systemName: "icloud.and.arrow.up")
                .foregroundColor(.blue)
        }
        .buttonStyle(.plain)
    }
}

Change 6: Add VPS Progress Display

// Mostrar progreso de descarga VPS
if vpsClient.activeDownloads.contains("\(mangaSlug)-\(chapter.number)"), 
   let progress = vpsClient.downloadProgress["\(mangaSlug)-\(chapter.number)"] {
    HStack {
        Image(systemName: "icloud.and.arrow.down")
            .font(.caption2)
            .foregroundColor(.blue)
        
        ProgressView(value: progress)
            .progressViewStyle(.linear)
            .frame(maxWidth: 100)
        
        Text("VPS \(Int(progress * 100))%")
            .font(.caption2)
            .foregroundColor(.blue)
    }
}

Change 7: Add VPS Status Check Function

private func checkVPSStatus() async {
    do {
        let manifest = try await vpsClient.getChapterManifest(
            mangaSlug: mangaSlug,
            chapterNumber: chapter.number
        )
        isVPSDownloaded = manifest != nil
        isVPSChecked = true
    } catch {
        isVPSDownloaded = false
        isVPSChecked = true
    }
}

Change 8: Update chaptersList to Pass VPS Callback

ChapterRowView(
    chapter: chapter,
    mangaSlug: manga.slug,
    onTap: {
        viewModel.selectedChapter = chapter
    },
    onDownloadToggle: {
        await viewModel.downloadChapter(chapter)
    },
    onVPSDownloadToggle: {  // NEW
        await viewModel.downloadChapterToVPS(chapter)
    }
)

Change 9: ViewModel Additions

// New Published Property
@Published var showingVPSDownloadAll = false

// New Dependency
private let vpsClient = VPSAPIClient.shared

// New Methods
func downloadChapterToVPS(_ chapter: Chapter) async {
    do {
        let imageUrls = try await scraper.scrapeChapterImages(chapterSlug: chapter.slug)
        let result = try await vpsClient.downloadChapter(
            mangaSlug: manga.slug,
            chapterNumber: chapter.number,
            chapterSlug: chapter.slug,
            imageUrls: imageUrls
        )
        // Handle result and show notification
    } catch {
        // Handle error
    }
}

func downloadAllChaptersToVPS() async { /* ... */ }
func downloadLastChaptersToVPS(count: Int) async { /* ... */ }

---

File: ReaderView.swift

Change 1: Add VPS Client

// Added to ReaderView struct
@ObservedObject private var vpsClient = VPSAPIClient.shared

Change 2: Update PageView for VPS Support

struct PageView: View {
    // Added:
    @ObservedObject var vpsClient = VPSAPIClient.shared
    @State private var useVPS = false
    
    var body: some View {
        // ...
        if let localURL = StorageService.shared.getImageURL(...) {
            // Load from local cache
        } else if useVPS {
            // Load from VPS
            let vpsImageURL = vpsClient.getImageURL(
                mangaSlug: mangaSlug,
                chapterNumber: chapterNumber,
                pageIndex: page.index + 1
            )
            AsyncImage(url: URL(string: vpsImageURL)) { /* ... */ }
        } else {
            // Load from original URL
            fallbackImage
        }
        // ...
        .task {
            // Check if VPS has this chapter
            if let manifest = try? await vpsClient.getChapterManifest(...) {
                useVPS = true
            }
        }
    }
    
    private var fallbackImage: some View { /* ... */ }
}

Change 3: Update ReaderViewModel

// New Published Property
@Published var isVPSDownloaded = false

// New Dependency
private let vpsClient = VPSAPIClient.shared

// Updated loadPages()
func loadPages() async {
    // 1. Check VPS first
    if let vpsManifest = try await vpsClient.getChapterManifest(...) {
        // Load from VPS
        isVPSDownloaded = true
    }
    // 2. Then local storage
    else if let downloadedChapter = storage.getDownloadedChapter(...) {
        // Load from local
        isDownloaded = true
    }
    // 3. Finally scrape
    else {
        // Scrape from original
    }
}

Change 4: Update Reader Footer

// Page indicator section
if viewModel.isVPSDownloaded {
    Label("VPS", systemImage: "icloud.fill")
        .font(.caption)
        .foregroundColor(.blue)
}

if viewModel.isDownloaded {
    Label("Local", systemImage: "checkmark.circle.fill")
        .font(.caption)
        .foregroundColor(.green)
}

---

Data Models (in VPSAPIClient.swift)

VPSDownloadResult

struct VPSDownloadResult {
    let success: Bool
    let alreadyDownloaded: Bool
    let manifest: VPSChapterManifest?
    let downloaded: Int?
    let failed: Int?
}

VPSChapterManifest

struct VPSChapterManifest: Codable {
    let mangaSlug: String
    let chapterNumber: Int
    let totalPages: Int
    let downloadedPages: Int
    let failedPages: Int
    let downloadDate: String
    let totalSize: Int
    let images: [VPSImageInfo]
}

VPSChapterInfo

struct VPSChapterInfo: Codable {
    let chapterNumber: Int
    let downloadDate: String
    let totalPages: Int
    let downloadedPages: Int
    let totalSize: Int
    let totalSizeMB: String
}

VPSStorageStats

struct VPSStorageStats: Codable {
    let totalMangas: Int
    let totalChapters: Int
    let totalSize: Int
    let totalSizeMB: String
    let totalSizeFormatted: String
    let mangaDetails: [VPSMangaDetail]
}

---

Priority Order for Image Loading

1. Local Device Storage (fastest, offline)
2. VPS Storage (fast, online)
3. Original URL (slowest, may fail)

This ensures best performance and reliability.

---

Error Handling Pattern

All VPS operations follow this pattern:

do {
    let result = try await vpsClient.someMethod(...)
    // Handle success
} catch {
    // Handle error - show user notification
    notificationMessage = "Error: \(error.localizedDescription)"
    showDownloadNotification = true
}

---

Progress Tracking Pattern

For downloads:

// Track active downloads
vpsClient.activeDownloads.contains("downloadId")

// Get progress
vpsClient.downloadProgress["downloadId"]

// Display in UI
ProgressView(value: progress)
Text("\(Int(progress * 100))%")