UpdateService

enum UpdateService

static func checkForUpdate() async throws -> GitHubRelease?

// Example from UpdateService.swift:36-50
static func checkForUpdate() async throws -> GitHubRelease? {
    var request = URLRequest(url: apiURL, cachePolicy: .reloadIgnoringLocalCacheData)
    request.setValue("application/vnd.github+json", forHTTPHeaderField: "Accept")

    let (data, _) = try await URLSession.shared.data(for: request)
    let release = try JSONDecoder().decode(GitHubRelease.self, from: data)

    let latestVersion = release.tagName.trimmingCharacters(in: .init(charactersIn: "v"))
    let currentVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0"

    if latestVersion.compare(currentVersion, options: .numeric) == .orderedDescending {
        return release
    }
    return nil
}

private static let apiURL = URL(string: "https://api.github.com/repos/xaif/r2Vault/releases/latest")!

struct GitHubRelease: Decodable {
    let tagName: String
    let htmlUrl: String
    let body: String?
    let assets: [GitHubAsset]
    
    var dmgDownloadURL: URL?
}

var dmgDownloadURL: URL? {
    assets.first(where: { $0.name.hasSuffix(".dmg") }).flatMap { URL(string: $0.browserDownloadUrl) }
}

struct GitHubAsset: Decodable {
    let name: String
    let browserDownloadUrl: String
}

import SwiftUI

struct UpdateCheckView: View {
    @State private var availableUpdate: GitHubRelease?
    @State private var isChecking = false
    @State private var errorMessage: String?
    
    var body: some View {
        VStack {
            if isChecking {
                ProgressView("Checking for updates...")
            } else if let update = availableUpdate {
                Text("Update available: \(update.tagName)")
                if let notes = update.body {
                    Text(notes)
                        .font(.caption)
                }
                Button("Install Update") {
                    AppUpdater.shared.install(release: update)
                }
            } else {
                Text("You're up to date!")
            }
            
            if let error = errorMessage {
                Text("Error: \(error)")
                    .foregroundStyle(.red)
            }
        }
        .task {
            await checkForUpdate()
        }
    }
    
    func checkForUpdate() async {
        isChecking = true
        errorMessage = nil
        defer { isChecking = false }
        
        do {
            availableUpdate = try await UpdateService.checkForUpdate()
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

struct UpdaterView: View {
    @State private var updater = AppUpdater.shared
    
    var body: some View {
        VStack {
            switch updater.state {
            case .idle:
                Text("Ready to update")
                
            case .downloading(let progress):
                ProgressView(value: progress) {
                    Text("Downloading: \(Int(progress * 100))%")
                }
                Button("Cancel") {
                    updater.cancel()
                }
                
            case .downloaded:
                Text("Update ready to install")
                Button("Install Now") {
                    updater.installDownloaded()
                }
                .buttonStyle(.borderedProminent)
                
            case .installing:
                ProgressView("Installing...")
                Text("The app will restart automatically")
                    .font(.caption)
                
            case .failed(let message):
                Text("Update failed: \(message)")
                    .foregroundStyle(.red)
                Button("Try Again") {
                    // Retry logic
                }
            }
        }
        .padding()
    }
}

@main
struct R2VaultApp: App {
    @State private var viewModel = AppViewModel()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .task {
                    // Check for updates on launch
                    await checkForUpdatesOnLaunch()
                }
        }
    }
    
    func checkForUpdatesOnLaunch() async {
        // Wait a bit before checking (don't block app launch)
        try? await Task.sleep(for: .seconds(3))
        
        guard AppUpdater.shared.canSelfUpdate else {
            print("Self-update not available: \(AppUpdater.shared.updateBlockReason ?? "unknown")")
            return
        }
        
        do {
            if let release = try await UpdateService.checkForUpdate() {
                print("Update available: \(release.tagName)")
                // Show update notification or prompt
            }
        } catch {
            print("Update check failed: \(error)")
        }
    }
}