Persistence Setup

import Foundation
import SwiftData
import CloudKit

/// CloudKit configuration for iCloud sync.
///
/// Prerequisites:
/// 1. Enable iCloud capability in Xcode
/// 2. Check "CloudKit" service
/// 3. Add container identifier
/// 4. Add required entitlements
///
/// Usage:
/// ```swift
/// let container = try CloudKitConfiguration.createContainer(
///     for: [Item.self],
///     containerIdentifier: "iCloud.com.yourcompany.yourapp"
/// )
/// ```
enum CloudKitConfiguration {

    // MARK: - Container Identifier

    /// Your CloudKit container identifier.
    /// Format: iCloud.com.yourcompany.yourapp
    ///
    /// Must match:
    /// - Xcode capability configuration
    /// - Entitlements file
    /// - CloudKit Dashboard
    static let containerIdentifier = "iCloud.com.yourcompany.yourapp"

    // MARK: - Container Creation

    /// Create a ModelContainer with CloudKit sync enabled.
    @MainActor
    static func createContainer(
        for modelTypes: [any PersistentModel.Type],
        containerIdentifier: String = CloudKitConfiguration.containerIdentifier
    ) throws -> ModelContainer {
        let schema = Schema(modelTypes)

        let configuration = ModelConfiguration(
            schema: schema,
            cloudKitDatabase: .private(containerIdentifier)
        )

        return try ModelContainer(
            for: schema,
            configurations: configuration
        )
    }

    /// Create a ModelContainer with automatic CloudKit database selection.
    /// Uses private database for user-specific data.
    @MainActor
    static func createAutoContainer(
        for modelTypes: [any PersistentModel.Type]
    ) throws -> ModelContainer {
        let schema = Schema(modelTypes)

        let configuration = ModelConfiguration(
            schema: schema,
            cloudKitDatabase: .automatic
        )

        return try ModelContainer(
            for: schema,
            configurations: configuration
        )
    }

    // MARK: - Account Status

    /// Check if the user is signed into iCloud.
    static func checkAccountStatus() async throws -> CKAccountStatus {
        try await CKContainer.default().accountStatus()
    }

    /// Check if CloudKit is available for this user.
    static func isCloudKitAvailable() async -> Bool {
        do {
            let status = try await checkAccountStatus()
            return status == .available
        } catch {
            return false
        }
    }
}

// MARK: - Container Identifier Validation

extension CloudKitConfiguration {

    /// Validate that the container identifier is properly formatted.
    static func validateContainerIdentifier(_ identifier: String) -> Bool {
        // Must start with "iCloud."
        guard identifier.hasPrefix("iCloud.") else { return false }

        // Must have a valid bundle ID format after "iCloud."
        let bundleIDPart = String(identifier.dropFirst("iCloud.".count))
        let bundleIDRegex = #"^[a-zA-Z][a-zA-Z0-9\-\.]*[a-zA-Z0-9]$"#

        return bundleIDPart.range(of: bundleIDRegex, options: .regularExpression) != nil
    }
}

// MARK: - Entitlements Reference

/*
 Required entitlements for iCloud sync:

 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
     <key>com.apple.developer.icloud-container-identifiers</key>
     <array>
         <string>iCloud.com.yourcompany.yourapp</string>
     </array>
     <key>com.apple.developer.icloud-services</key>
     <array>
         <string>CloudKit</string>
     </array>
 </dict>
 </plist>
 ```

 For background sync, also add to Info.plist:
 ```xml
 <key>UIBackgroundModes</key>
 <array>
     <string>remote-notification</string>
 </array>
 ```
 */

import Foundation
import SwiftData

/// Example SwiftData model.
///
/// This demonstrates common patterns for SwiftData models.
/// Replace or extend with your own models.
///
/// Usage:
/// ```swift
/// let item = Item(title: "Buy groceries")
/// item.isCompleted = true
/// ```
@Model
final class Item {

    // MARK: - Stored Properties

    /// Unique identifier for the item.
    @Attribute(.unique)
    var id: UUID

    /// The item's title.
    var title: String

    /// When the item was created.
    var createdAt: Date

    /// When the item was last modified.
    var modifiedAt: Date

    /// Whether the item is completed.
    var isCompleted: Bool

    /// Optional notes for the item.
    var notes: String?

    /// Priority level (0 = none, 1 = low, 2 = medium, 3 = high).
    var priority: Int

    // MARK: - Transient Properties (Not Persisted)

    /// UI selection state (not saved to database).
    @Transient
    var isSelected: Bool = false

    // MARK: - Relationships

    // Example: Uncomment to add a relationship to a Project model
    // @Relationship(inverse: \Project.items)
    // var project: Project?

    // Example: Tags relationship
    // @Relationship(deleteRule: .nullify)
    // var tags: [Tag] = []

    // MARK: - Initialization

    init(
        title: String,
        notes: String? = nil,
        priority: Int = 0,
        isCompleted: Bool = false
    ) {
        self.id = UUID()
        self.title = title
        self.createdAt = .now
        self.modifiedAt = .now
        self.isCompleted = isCompleted
        self.notes = notes
        self.priority = priority
    }

    // MARK: - Methods

    /// Mark the item as completed.
    func complete() {
        isCompleted = true
        modifiedAt = .now
    }

    /// Mark the item as not completed.
    func uncomplete() {
        isCompleted = false
        modifiedAt = .now
    }

    /// Toggle completion status.
    func toggleCompletion() {
        isCompleted.toggle()
        modifiedAt = .now
    }

    /// Update the title.
    func updateTitle(_ newTitle: String) {
        title = newTitle
        modifiedAt = .now
    }
}

// MARK: - Convenience Extensions

extension Item {

    /// Priority level as human-readable string.
    var priorityLabel: String {
        switch priority {
        case 0: return "None"
        case 1: return "Low"
        case 2: return "Medium"
        case 3: return "High"
        default: return "Unknown"
        }
    }

    /// Whether this is a high-priority item.
    var isHighPriority: Bool {
        priority >= 3
    }
}

// MARK: - Sample Data

extension Item {

    /// Sample items for previews and testing.
    static var sampleItems: [Item] {
        [
            Item(title: "Complete project proposal", priority: 3),
            Item(title: "Review pull request", priority: 2),
            Item(title: "Update documentation", priority: 1),
            Item(title: "Schedule team meeting", notes: "Discuss Q4 goals"),
            Item(title: "Buy coffee", isCompleted: true),
        ]
    }
}

import Foundation
import SwiftData

/// Central persistence controller managing the SwiftData container.
///
/// Usage:
/// ```swift
/// @main
/// struct MyApp: App {
///     var body: some Scene {
///         WindowGroup {
///             ContentView()
///                 .modelContainer(PersistenceController.shared.container)
///         }
///     }
/// }
/// ```
@MainActor
final class PersistenceController: Sendable {

    // MARK: - Singleton

    static let shared = PersistenceController()

    // MARK: - Container

    /// The main model container.
    let container: ModelContainer

    // MARK: - Initialization

    private init() {
        // Define schema with all model types
        let schema = Schema([
            Item.self,
            // Add more models here as your app grows
        ])

        // Configure storage
        // For iCloud sync, use CloudKitConfiguration instead
        let configuration = ModelConfiguration(
            schema: schema,
            isStoredInMemoryOnly: false,
            allowsSave: true
        )

        do {
            container = try ModelContainer(
                for: schema,
                configurations: configuration
            )
        } catch {
            fatalError("Failed to create ModelContainer: \(error)")
        }
    }

    // MARK: - Preview Container

    /// In-memory container for SwiftUI previews.
    static var preview: ModelContainer {
        let schema = Schema([Item.self])
        let configuration = ModelConfiguration(
            schema: schema,
            isStoredInMemoryOnly: true
        )

        do {
            let container = try ModelContainer(
                for: schema,
                configurations: configuration
            )

            // Add sample data for previews
            let context = container.mainContext
            let sampleItems = [
                Item(title: "First Item"),
                Item(title: "Second Item"),
                Item(title: "Third Item"),
            ]
            for item in sampleItems {
                context.insert(item)
            }
            try context.save()

            return container
        } catch {
            fatalError("Failed to create preview container: \(error)")
        }
    }
}

// MARK: - Convenience Extensions

extension PersistenceController {

    /// Main context for UI operations.
    var mainContext: ModelContext {
        container.mainContext
    }

    /// Create a new background context for heavy operations.
    func newBackgroundContext() -> ModelContext {
        ModelContext(container)
    }
}

import Foundation
import SwiftData

/// Generic repository protocol for data access.
///
/// Provides abstraction over SwiftData for:
/// - Testability (mock implementations)
/// - Separation of concerns
/// - Consistent data access patterns
///
/// Usage:
/// ```swift
/// let repository: any Repository<Item> = SwiftDataRepository(modelContext: context)
/// let items = try await repository.fetch(sortBy: [SortDescriptor(\.timestamp)])
/// ```
protocol Repository<T>: Sendable {
    associatedtype T: PersistentModel

    /// Fetch all items matching the predicate.
    func fetch(
        predicate: Predicate<T>?,
        sortBy: [SortDescriptor<T>]
    ) async throws -> [T]

    /// Fetch a single item matching the predicate.
    func fetchOne(predicate: Predicate<T>) async throws -> T?

    /// Count items matching the predicate.
    func count(predicate: Predicate<T>?) async throws -> Int

    /// Insert a new item.
    func insert(_ item: T) async throws

    /// Delete an item.
    func delete(_ item: T) async throws

    /// Delete all items matching the predicate.
    func deleteAll(predicate: Predicate<T>?) async throws

    /// Save pending changes.
    func save() async throws
}

// MARK: - Default Implementations

extension Repository {

    /// Fetch all items with default sorting.
    func fetch(sortBy: [SortDescriptor<T>] = []) async throws -> [T] {
        try await fetch(predicate: nil, sortBy: sortBy)
    }

    /// Fetch all items.
    func fetchAll() async throws -> [T] {
        try await fetch(predicate: nil, sortBy: [])
    }

    /// Count all items.
    func countAll() async throws -> Int {
        try await count(predicate: nil)
    }

    /// Delete all items.
    func deleteAll() async throws {
        try await deleteAll(predicate: nil)
    }
}

// MARK: - Repository Error

/// Errors that can occur during repository operations.
enum RepositoryError: Error, LocalizedError {
    case fetchFailed(Error)
    case insertFailed(Error)
    case deleteFailed(Error)
    case saveFailed(Error)
    case notFound

    var errorDescription: String? {
        switch self {
        case .fetchFailed(let error):
            return "Failed to fetch data: \(error.localizedDescription)"
        case .insertFailed(let error):
            return "Failed to insert data: \(error.localizedDescription)"
        case .deleteFailed(let error):
            return "Failed to delete data: \(error.localizedDescription)"
        case .saveFailed(let error):
            return "Failed to save data: \(error.localizedDescription)"
        case .notFound:
            return "Item not found"
        }
    }
}

import Foundation
import SwiftData

/// SwiftData implementation of the Repository protocol.
///
/// Usage:
/// ```swift
/// let context = PersistenceController.shared.mainContext
/// let repository = SwiftDataRepository<Item>(modelContext: context)
///
/// // Fetch items
/// let items = try await repository.fetch(
///     predicate: #Predicate { $0.isCompleted == false },
///     sortBy: [SortDescriptor(\.timestamp, order: .reverse)]
/// )
///
/// // Insert
/// let newItem = Item(title: "New Task")
/// try await repository.insert(newItem)
/// ```
@MainActor
final class SwiftDataRepository<T: PersistentModel>: Repository {

    // MARK: - Properties

    private let modelContext: ModelContext

    // MARK: - Initialization

    init(modelContext: ModelContext) {
        self.modelContext = modelContext
    }

    // MARK: - Fetch

    func fetch(
        predicate: Predicate<T>? = nil,
        sortBy: [SortDescriptor<T>] = []
    ) async throws -> [T] {
        let descriptor = FetchDescriptor<T>(
            predicate: predicate,
            sortBy: sortBy
        )

        do {
            return try modelContext.fetch(descriptor)
        } catch {
            throw RepositoryError.fetchFailed(error)
        }
    }

    func fetchOne(predicate: Predicate<T>) async throws -> T? {
        var descriptor = FetchDescriptor<T>(predicate: predicate)
        descriptor.fetchLimit = 1

        do {
            return try modelContext.fetch(descriptor).first
        } catch {
            throw RepositoryError.fetchFailed(error)
        }
    }

    // MARK: - Count

    func count(predicate: Predicate<T>? = nil) async throws -> Int {
        let descriptor = FetchDescriptor<T>(predicate: predicate)

        do {
            return try modelContext.fetchCount(descriptor)
        } catch {
            throw RepositoryError.fetchFailed(error)
        }
    }

    // MARK: - Insert

    func insert(_ item: T) async throws {
        modelContext.insert(item)
        try await save()
    }

    // MARK: - Delete

    func delete(_ item: T) async throws {
        modelContext.delete(item)
        try await save()
    }

    func deleteAll(predicate: Predicate<T>? = nil) async throws {
        do {
            try modelContext.delete(model: T.self, where: predicate)
            try await save()
        } catch {
            throw RepositoryError.deleteFailed(error)
        }
    }

    // MARK: - Save

    func save() async throws {
        guard modelContext.hasChanges else { return }

        do {
            try modelContext.save()
        } catch {
            throw RepositoryError.saveFailed(error)
        }
    }
}

// MARK: - Pagination Support

extension SwiftDataRepository {

    /// Fetch items with pagination.
    func fetchPage(
        page: Int,
        pageSize: Int,
        predicate: Predicate<T>? = nil,
        sortBy: [SortDescriptor<T>] = []
    ) async throws -> [T] {
        var descriptor = FetchDescriptor<T>(
            predicate: predicate,
            sortBy: sortBy
        )
        descriptor.fetchOffset = page * pageSize
        descriptor.fetchLimit = pageSize

        do {
            return try modelContext.fetch(descriptor)
        } catch {
            throw RepositoryError.fetchFailed(error)
        }
    }
}

// MARK: - Batch Operations

extension SwiftDataRepository {

    /// Insert multiple items efficiently.
    func insertBatch(_ items: [T]) async throws {
        for item in items {
            modelContext.insert(item)
        }
        try await save()
    }

    /// Update items matching predicate using a transform.
    func updateBatch(
        predicate: Predicate<T>? = nil,
        transform: (T) -> Void
    ) async throws {
        let items = try await fetch(predicate: predicate, sortBy: [])
        for item in items {
            transform(item)
        }
        try await save()
    }
}

import Foundation
import SwiftUI
import CloudKit

/// Monitors iCloud sync status for UI feedback.
///
/// Usage:
/// ```swift
/// struct ContentView: View {
///     @Environment(SyncStatus.self) var syncStatus
///
///     var body: some View {
///         VStack {
///             if syncStatus.isSyncing {
///                 ProgressView("Syncing...")
///             }
///
///             if let error = syncStatus.error {
///                 Text("Sync error: \(error.localizedDescription)")
///             }
///         }
///     }
/// }
/// ```
@MainActor
@Observable
final class SyncStatus {

    // MARK: - Singleton

    static let shared = SyncStatus()

    // MARK: - State

    /// Whether a sync operation is in progress.
    private(set) var isSyncing = false

    /// The last time sync completed successfully.
    private(set) var lastSyncDate: Date?

    /// Current iCloud account status.
    private(set) var accountStatus: CKAccountStatus = .couldNotDetermine

    /// Any error from the last sync attempt.
    private(set) var error: SyncError?

    /// Whether iCloud is available for this user.
    var isCloudAvailable: Bool {
        accountStatus == .available
    }

    /// Human-readable status description.
    var statusDescription: String {
        if let error {
            return error.localizedDescription
        }

        switch accountStatus {
        case .available:
            if isSyncing {
                return "Syncing..."
            } else if let lastSync = lastSyncDate {
                return "Last synced: \(lastSync.formatted(.relative(presentation: .named)))"
            } else {
                return "iCloud connected"
            }
        case .noAccount:
            return "Sign in to iCloud to sync"
        case .restricted:
            return "iCloud access restricted"
        case .couldNotDetermine:
            return "Checking iCloud status..."
        case .temporarilyUnavailable:
            return "iCloud temporarily unavailable"
        @unknown default:
            return "Unknown status"
        }
    }

    // MARK: - Initialization

    private init() {
        startMonitoring()
    }

    // MARK: - Monitoring

    private func startMonitoring() {
        // Check initial status
        Task {
            await checkAccountStatus()
        }

        // Monitor account changes
        NotificationCenter.default.addObserver(
            forName: .CKAccountChanged,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor in
                await self?.checkAccountStatus()
            }
        }
    }

    /// Check the current iCloud account status.
    func checkAccountStatus() async {
        do {
            accountStatus = try await CKContainer.default().accountStatus()
            error = nil
        } catch {
            self.error = .accountCheckFailed(error)
        }
    }

    // MARK: - Sync Operations

    /// Mark sync as started.
    func syncStarted() {
        isSyncing = true
        error = nil
    }

    /// Mark sync as completed successfully.
    func syncCompleted() {
        isSyncing = false
        lastSyncDate = .now
        error = nil
    }

    /// Mark sync as failed.
    func syncFailed(_ error: Error) {
        isSyncing = false
        self.error = .syncFailed(error)
    }
}

// MARK: - Sync Error

/// Errors related to iCloud sync.
enum SyncError: Error, LocalizedError {
    case accountCheckFailed(Error)
    case syncFailed(Error)
    case networkUnavailable
    case quotaExceeded

    var errorDescription: String? {
        switch self {
        case .accountCheckFailed(let error):
            return "Could not check iCloud status: \(error.localizedDescription)"
        case .syncFailed(let error):
            return "Sync failed: \(error.localizedDescription)"
        case .networkUnavailable:
            return "Network unavailable. Changes will sync when connected."
        case .quotaExceeded:
            return "iCloud storage quota exceeded"
        }
    }
}

// MARK: - Environment Key

private struct SyncStatusKey: EnvironmentKey {
    @MainActor
    static let defaultValue = SyncStatus.shared
}

extension EnvironmentValues {
    var syncStatus: SyncStatus {
        get { self[SyncStatusKey.self] }
        set { self[SyncStatusKey.self] = newValue }
    }
}

// MARK: - SwiftUI View Extension

extension View {

    /// Add a sync status indicator to the view.
    func syncStatusIndicator() -> some View {
        modifier(SyncStatusIndicatorModifier())
    }
}

private struct SyncStatusIndicatorModifier: ViewModifier {
    @Environment(SyncStatus.self) private var syncStatus

    func body(content: Content) -> some View {
        content
            .overlay(alignment: .topTrailing) {
                if syncStatus.isSyncing {
                    ProgressView()
                        .padding(8)
                }
            }
    }
}

// MARK: - Preview

#Preview {
    VStack(spacing: 20) {
        Text("Sync Status Demo")
            .font(.headline)

        Text(SyncStatus.shared.statusDescription)
            .foregroundStyle(.secondary)

        if SyncStatus.shared.isSyncing {
            ProgressView("Syncing...")
        }

        Button("Check Status") {
            Task {
                await SyncStatus.shared.checkAccountStatus()
            }
        }
    }
    .padding()
}