@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/ios/MediaTemplate/MediaTemplate/Data/LocalStorage/LocalStorageProvider.swift

@@ -0,0 +1,393 @@
+import CoreData
+import Foundation
+
+/// Core Data–backed implementation of DataRepository.
+/// Stores media items, categories, playlists, episodes, and playback history in a local SQLite database.
+/// Pre-seeds default data on first launch (empty database).
+///
+/// Usage: LocalStorageProvider.shared (singleton, like MockDataProvider)
+final class LocalStorageProvider: ObservableObject, DataRepository {
+    static let shared = LocalStorageProvider()
+
+    @Published var categories: [MediaCategory] = []
+    @Published var mediaItems: [MediaItem] = []
+    @Published var playlists: [Playlist] = []
+    @Published var episodes: [Episode] = []
+    @Published var playbackHistory: [PlaybackHistoryItem] = []
+    @Published var favorites: Set<String> = []
+
+    private let stack: CoreDataStack
+    private var context: NSManagedObjectContext { stack.viewContext }
+
+    private init(stack: CoreDataStack = .shared) {
+        self.stack = stack
+        loadData()
+    }
+
+    // MARK: - Data Loading
+
+    func loadData() {
+        fetchCategories()
+        fetchMediaItems()
+        fetchPlaylists()
+        fetchEpisodes()
+        fetchPlaybackHistory()
+        loadFavorites()
+
+        // Pre-seed from AppConfig categories on first launch (empty DB)
+        if categories.isEmpty {
+            seedDefaultCategories()
+            fetchCategories()
+        }
+        if mediaItems.isEmpty {
+            seedDefaultMediaItems()
+            fetchMediaItems()
+        }
+        if playlists.isEmpty {
+            seedDefaultPlaylists()
+            fetchPlaylists()
+        }
+        if episodes.isEmpty {
+            seedDefaultEpisodes()
+            fetchEpisodes()
+        }
+    }
+
+    // MARK: - CRUD Operations - Playlists
+
+    func addPlaylist(_ playlist: Playlist) {
+        let entity = PlaylistEntity(context: context)
+        entity.update(from: playlist)
+        stack.save()
+        fetchPlaylists()
+    }
+
+    func updatePlaylist(_ playlist: Playlist) {
+        guard let entity = fetchPlaylistEntity(byId: playlist.id) else { return }
+        entity.update(from: playlist)
+        stack.save()
+        fetchPlaylists()
+    }
+
+    func deletePlaylist(_ id: String) {
+        guard let entity = fetchPlaylistEntity(byId: id) else { return }
+        context.delete(entity)
+        stack.save()
+        fetchPlaylists()
+    }
+
+    func addToPlaylist(playlistId: String, item: MediaItem) {
+        guard let entity = fetchPlaylistEntity(byId: playlistId) else { return }
+        var itemIds = decodeItemIds(from: entity.itemsJSON)
+        if !itemIds.contains(item.id) {
+            itemIds.append(item.id)
+            entity.itemsJSON = encodeItemIds(itemIds)
+            stack.save()
+            fetchPlaylists()
+        }
+    }
+
+    func removeFromPlaylist(playlistId: String, itemId: String) {
+        guard let entity = fetchPlaylistEntity(byId: playlistId) else { return }
+        var itemIds = decodeItemIds(from: entity.itemsJSON)
+        itemIds.removeAll { $0 == itemId }
+        entity.itemsJSON = encodeItemIds(itemIds)
+        entity.updatedAt = Date()
+        stack.save()
+        fetchPlaylists()
+    }
+
+    func reorderPlaylist(playlistId: String, from: Int, to: Int) {
+        guard let entity = fetchPlaylistEntity(byId: playlistId) else { return }
+        var itemIds = decodeItemIds(from: entity.itemsJSON)
+        guard from < itemIds.count && to < itemIds.count else { return }
+        let item = itemIds.remove(at: from)
+        itemIds.insert(item, at: to)
+        entity.itemsJSON = encodeItemIds(itemIds)
+        entity.updatedAt = Date()
+        stack.save()
+        fetchPlaylists()
+    }
+
+    // MARK: - CRUD Operations - Favorites
+
+    func toggleFavorite(_ itemId: String) {
+        if favorites.contains(itemId) {
+            favorites.remove(itemId)
+        } else {
+            favorites.insert(itemId)
+        }
+        saveFavorites()
+
+        if let entity = fetchMediaItemEntity(byId: itemId) {
+            entity.isFavorite.toggle()
+            stack.save()
+            fetchMediaItems()
+        }
+    }
+
+    func isFavorite(_ itemId: String) -> Bool {
+        favorites.contains(itemId)
+    }
+
+    // MARK: - CRUD Operations - History
+
+    func addToHistory(_ item: MediaItem, progress: TimeInterval) {
+        // Remove existing history for this item
+        let request = NSFetchRequest<PlaybackHistoryEntity>(entityName: "PlaybackHistoryEntity")
+        request.predicate = NSPredicate(format: "mediaItemJSON CONTAINS %@", "\"id\":\"\(item.id)\"")
+        if let existing = try? context.fetch(request).first {
+            context.delete(existing)
+        }
+
+        let entity = PlaybackHistoryEntity(context: context)
+        let historyItem = PlaybackHistoryItem(
+            id: UUID().uuidString,
+            mediaItem: item,
+            lastPlayedAt: Date(),
+            progress: progress,
+            completed: progress >= item.duration * 0.9
+        )
+        entity.update(from: historyItem)
+        stack.save()
+        fetchPlaybackHistory()
+    }
+
+    func updateHistoryProgress(_ itemId: String, progress: TimeInterval) {
+        let request = NSFetchRequest<PlaybackHistoryEntity>(entityName: "PlaybackHistoryEntity")
+        request.predicate = NSPredicate(format: "mediaItemJSON CONTAINS %@", "\"id\":\"\(itemId)\"")
+        guard let entity = try? context.fetch(request).first,
+              let historyItem = entity.toPlaybackHistoryItem() else { return }
+        let updated = PlaybackHistoryItem(
+            id: historyItem.id,
+            mediaItem: historyItem.mediaItem,
+            lastPlayedAt: Date(),
+            progress: progress,
+            completed: progress >= historyItem.mediaItem.duration * 0.9
+        )
+        entity.update(from: updated)
+        stack.save()
+        fetchPlaybackHistory()
+    }
+
+    // MARK: - Query Methods
+
+    func mediaItem(by id: String) -> MediaItem? {
+        mediaItems.first { $0.id == id }
+    }
+
+    func mediaItems(for category: MediaCategory) -> [MediaItem] {
+        mediaItems.filter { $0.category.id == category.id }
+    }
+
+    func searchMediaItems(query: String) -> [MediaItem] {
+        guard !query.isEmpty else { return mediaItems }
+        let lowerQuery = query.lowercased()
+        return mediaItems.filter {
+            $0.title.lowercased().contains(lowerQuery) ||
+            $0.artist.lowercased().contains(lowerQuery) ||
+            $0.description.lowercased().contains(lowerQuery) ||
+            ($0.tags?.contains { $0.lowercased().contains(lowerQuery) } ?? false)
+        }
+    }
+
+    func featuredItems() -> [MediaItem] {
+        Array(mediaItems.filter { ($0.rating ?? 0) >= 4.5 }.prefix(10))
+    }
+
+    func recentlyPlayed() -> [MediaItem] {
+        Array(playbackHistory.prefix(10).map { $0.mediaItem })
+    }
+
+    func popularPlaylists() -> [Playlist] {
+        Array(playlists.sorted { $0.playCount > $1.playCount }.prefix(5))
+    }
+
+    func playlist(by id: String) -> Playlist? {
+        playlists.first { $0.id == id }
+    }
+
+    func episode(by id: String) -> Episode? {
+        episodes.first { $0.id == id }
+    }
+
+    func episodes(for seriesId: String) -> [Episode] {
+        episodes.filter { $0.seriesId == seriesId }.sorted { $0.releaseDate > $1.releaseDate }
+    }
+
+    // MARK: - Reset
+
+    func reset() {
+        // Delete all entities
+        let requests: [NSFetchRequest<NSFetchRequestResult>] = [
+            NSFetchRequest(entityName: "MediaCategoryEntity"),
+            NSFetchRequest(entityName: "MediaItemEntity"),
+            NSFetchRequest(entityName: "PlaylistEntity"),
+            NSFetchRequest(entityName: "EpisodeEntity"),
+            NSFetchRequest(entityName: "PlaybackHistoryEntity")
+        ]
+        for request in requests {
+            let deleteRequest = NSBatchDeleteRequest(fetchRequest: request)
+            _ = try? context.execute(deleteRequest)
+        }
+        stack.save()
+
+        seedDefaultCategories()
+        seedDefaultMediaItems()
+        seedDefaultPlaylists()
+        seedDefaultEpisodes()
+        favorites = []
+        saveFavorites()
+
+        fetchCategories()
+        fetchMediaItems()
+        fetchPlaylists()
+        fetchEpisodes()
+        fetchPlaybackHistory()
+    }
+
+    // MARK: - Private Fetch Helpers
+
+    private func fetchCategories() {
+        let request = NSFetchRequest<MediaCategoryEntity>(entityName: "MediaCategoryEntity")
+        request.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
+        do {
+            let entities = try context.fetch(request)
+            categories = entities.map { $0.toMediaCategory() }
+        } catch {
+            print("[LocalStorageProvider] Failed to fetch categories: \(error.localizedDescription)")
+        }
+    }
+
+    private func fetchMediaItems() {
+        let request = NSFetchRequest<MediaItemEntity>(entityName: "MediaItemEntity")
+        request.sortDescriptors = [NSSortDescriptor(key: "title", ascending: true)]
+        do {
+            let entities = try context.fetch(request)
+            mediaItems = entities.compactMap { entity in
+                guard let category = categories.first(where: { $0.id == entity.categoryId }) else {
+                    return nil
+                }
+                return entity.toMediaItem(category: category)
+            }
+        } catch {
+            print("[LocalStorageProvider] Failed to fetch media items: \(error.localizedDescription)")
+        }
+    }
+
+    private func fetchPlaylists() {
+        let request = NSFetchRequest<PlaylistEntity>(entityName: "PlaylistEntity")
+        request.sortDescriptors = [NSSortDescriptor(key: "updatedAt", ascending: false)]
+        do {
+            let entities = try context.fetch(request)
+            playlists = entities.map { $0.toPlaylist(mediaItems: mediaItems) }
+        } catch {
+            print("[LocalStorageProvider] Failed to fetch playlists: \(error.localizedDescription)")
+        }
+    }
+
+    private func fetchEpisodes() {
+        let request = NSFetchRequest<EpisodeEntity>(entityName: "EpisodeEntity")
+        request.sortDescriptors = [NSSortDescriptor(key: "releaseDate", ascending: false)]
+        do {
+            let entities = try context.fetch(request)
+            episodes = entities.map { $0.toEpisode() }
+        } catch {
+            print("[LocalStorageProvider] Failed to fetch episodes: \(error.localizedDescription)")
+        }
+    }
+
+    private func fetchPlaybackHistory() {
+        let request = NSFetchRequest<PlaybackHistoryEntity>(entityName: "PlaybackHistoryEntity")
+        request.sortDescriptors = [NSSortDescriptor(key: "lastPlayedAt", ascending: false)]
+        request.fetchLimit = 50
+        do {
+            let entities = try context.fetch(request)
+            playbackHistory = entities.compactMap { $0.toPlaybackHistoryItem() }
+        } catch {
+            print("[LocalStorageProvider] Failed to fetch playback history: \(error.localizedDescription)")
+        }
+    }
+
+    private func fetchMediaItemEntity(byId id: String) -> MediaItemEntity? {
+        let request = NSFetchRequest<MediaItemEntity>(entityName: "MediaItemEntity")
+        request.predicate = NSPredicate(format: "id == %@", id)
+        request.fetchLimit = 1
+        return try? context.fetch(request).first
+    }
+
+    private func fetchPlaylistEntity(byId id: String) -> PlaylistEntity? {
+        let request = NSFetchRequest<PlaylistEntity>(entityName: "PlaylistEntity")
+        request.predicate = NSPredicate(format: "id == %@", id)
+        request.fetchLimit = 1
+        return try? context.fetch(request).first
+    }
+
+    // MARK: - Seeding
+
+    private func seedDefaultCategories() {
+        for category in MockDataProvider.defaultCategories {
+            let entity = MediaCategoryEntity(context: context)
+            entity.update(from: category)
+        }
+        stack.save()
+    }
+
+    private func seedDefaultMediaItems() {
+        let defaultItems = MockDataProvider.makeDefaultMediaItems(categories: categories)
+        for item in defaultItems {
+            let entity = MediaItemEntity(context: context)
+            entity.update(from: item)
+        }
+        stack.save()
+    }
+
+    private func seedDefaultPlaylists() {
+        let defaultPlaylists = MockDataProvider.makeDefaultPlaylists(mediaItems: mediaItems)
+        for playlist in defaultPlaylists {
+            let entity = PlaylistEntity(context: context)
+            entity.update(from: playlist)
+        }
+        stack.save()
+    }
+
+    private func seedDefaultEpisodes() {
+        let defaultEpisodes = MockDataProvider.makeDefaultEpisodes()
+        for episode in defaultEpisodes {
+            let entity = EpisodeEntity(context: context)
+            entity.update(from: episode)
+        }
+        stack.save()
+    }
+
+    private func loadFavorites() {
+        if let data = UserDefaults.standard.data(forKey: "favorites"),
+           let favoritesSet = try? JSONDecoder().decode(Set<String>.self, from: data) {
+            favorites = favoritesSet
+        }
+    }
+
+    private func saveFavorites() {
+        if let data = try? JSONEncoder().encode(favorites) {
+            UserDefaults.standard.set(data, forKey: "favorites")
+        }
+    }
+
+    // MARK: - JSON helpers
+
+    private func decodeItemIds(from json: String) -> [String] {
+        guard let data = json.data(using: .utf8),
+              let array = try? JSONDecoder().decode([String].self, from: data) else {
+            return []
+        }
+        return array
+    }
+
+    private func encodeItemIds(_ ids: [String]) -> String {
+        guard let data = try? JSONEncoder().encode(ids),
+              let json = String(data: data, encoding: .utf8) else {
+            return "[]"
+        }
+        return json
+    }
+}

package/templates/ios/MediaTemplate/MediaTemplate/Data/LocalStorage/MediaCategoryEntity.swift

@@ -0,0 +1,36 @@
+import CoreData
+import Foundation
+
+/// Core Data managed object for MediaCategory persistence.
+@objc(MediaCategoryEntity)
+final class MediaCategoryEntity: NSManagedObject {
+    @NSManaged var id: String
+    @NSManaged var name: String
+    @NSManaged var icon: String
+    @NSManaged var image: String?
+    @NSManaged var parentId: String?
+    @NSManaged var itemCount: NSNumber?
+
+    // MARK: - Conversion
+
+    func toMediaCategory() -> MediaCategory {
+        MediaCategory(
+            id: id,
+            name: name,
+            icon: icon,
+            image: image,
+            parentId: parentId,
+            subcategories: nil,
+            itemCount: itemCount.map { Int(truncating: $0) }
+        )
+    }
+
+    func update(from category: MediaCategory) {
+        id = category.id
+        name = category.name
+        icon = category.icon
+        image = category.image
+        parentId = category.parentId
+        itemCount = category.itemCount.map { NSNumber(value: $0) }
+    }
+}

package/templates/ios/MediaTemplate/MediaTemplate/Data/LocalStorage/MediaItemEntity.swift

@@ -0,0 +1,82 @@
+import CoreData
+import Foundation
+
+/// Core Data managed object for MediaItem persistence.
+@objc(MediaItemEntity)
+final class MediaItemEntity: NSManagedObject {
+    @NSManaged var id: String
+    @NSManaged var title: String
+    @NSManaged var artist: String
+    @NSManaged var itemDescription: String
+    @NSManaged var duration: Double
+    @NSManaged var artworkURL: String?
+    @NSManaged var mediaURL: String
+    @NSManaged var type: String
+    @NSManaged var categoryId: String
+    @NSManaged var releaseDate: Date?
+    @NSManaged var tagsJSON: String?
+    @NSManaged var rating: NSNumber?
+    @NSManaged var playCount: Int32
+    @NSManaged var isFavorite: Bool
+    @NSManaged var isDownloaded: Bool
+
+    // MARK: - Conversion
+
+    func toMediaItem(category: MediaCategory) -> MediaItem {
+        MediaItem(
+            id: id,
+            title: title,
+            artist: artist,
+            description: itemDescription,
+            duration: duration,
+            artworkURL: artworkURL,
+            mediaURL: mediaURL,
+            type: MediaType(rawValue: type) ?? .audio,
+            category: category,
+            releaseDate: releaseDate,
+            tags: decodeTags(),
+            rating: rating.map { $0.doubleValue },
+            playCount: Int(playCount),
+            isFavorite: isFavorite,
+            isDownloaded: isDownloaded
+        )
+    }
+
+    func update(from item: MediaItem) {
+        id = item.id
+        title = item.title
+        artist = item.artist
+        itemDescription = item.description
+        duration = item.duration
+        artworkURL = item.artworkURL
+        mediaURL = item.mediaURL
+        type = item.type.rawValue
+        categoryId = item.category.id
+        releaseDate = item.releaseDate
+        tagsJSON = encodeTags(item.tags)
+        rating = item.rating.map { NSNumber(value: $0) }
+        playCount = Int32(item.playCount)
+        isFavorite = item.isFavorite
+        isDownloaded = item.isDownloaded
+    }
+
+    // MARK: - JSON helpers
+
+    private func decodeTags() -> [String]? {
+        guard let json = tagsJSON,
+              let data = json.data(using: .utf8),
+              let tags = try? JSONDecoder().decode([String].self, from: data) else {
+            return nil
+        }
+        return tags.isEmpty ? nil : tags
+    }
+
+    private func encodeTags(_ tags: [String]?) -> String? {
+        guard let tags = tags, !tags.isEmpty else { return nil }
+        guard let data = try? JSONEncoder().encode(tags),
+              let json = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+        return json
+    }
+}

package/templates/ios/MediaTemplate/MediaTemplate/Data/LocalStorage/PlaybackHistoryEntity.swift

@@ -0,0 +1,51 @@
+import CoreData
+import Foundation
+
+/// Core Data managed object for PlaybackHistoryItem persistence.
+@objc(PlaybackHistoryEntity)
+final class PlaybackHistoryEntity: NSManagedObject {
+    @NSManaged var id: String
+    @NSManaged var mediaItemJSON: String
+    @NSManaged var lastPlayedAt: Date
+    @NSManaged var progress: Double
+    @NSManaged var completed: Bool
+
+    // MARK: - Conversion
+
+    func toPlaybackHistoryItem() -> PlaybackHistoryItem? {
+        guard let item = decodeMediaItem() else { return nil }
+        return PlaybackHistoryItem(
+            id: id,
+            mediaItem: item,
+            lastPlayedAt: lastPlayedAt,
+            progress: progress,
+            completed: completed
+        )
+    }
+
+    func update(from historyItem: PlaybackHistoryItem) {
+        id = historyItem.id
+        mediaItemJSON = encodeMediaItem(historyItem.mediaItem)
+        lastPlayedAt = historyItem.lastPlayedAt
+        progress = historyItem.progress
+        completed = historyItem.completed
+    }
+
+    // MARK: - JSON helpers
+
+    private func decodeMediaItem() -> MediaItem? {
+        guard let data = mediaItemJSON.data(using: .utf8),
+              let item = try? JSONDecoder().decode(MediaItem.self, from: data) else {
+            return nil
+        }
+        return item
+    }
+
+    private func encodeMediaItem(_ item: MediaItem) -> String {
+        guard let data = try? JSONEncoder().encode(item),
+              let json = String(data: data, encoding: .utf8) else {
+            return "{}"
+        }
+        return json
+    }
+}

package/templates/ios/MediaTemplate/MediaTemplate/Data/LocalStorage/PlaylistEntity.swift

@@ -0,0 +1,66 @@
+import CoreData
+import Foundation
+
+/// Core Data managed object for Playlist persistence.
+@objc(PlaylistEntity)
+final class PlaylistEntity: NSManagedObject {
+    @NSManaged var id: String
+    @NSManaged var name: String
+    @NSManaged var playlistDescription: String?
+    @NSManaged var artworkURL: String?
+    @NSManaged var itemsJSON: String
+    @NSManaged var createdAt: Date
+    @NSManaged var updatedAt: Date
+    @NSManaged var isPublic: Bool
+    @NSManaged var playCount: Int32
+
+    // MARK: - Conversion
+
+    func toPlaylist(mediaItems: [MediaItem]) -> Playlist {
+        let itemIds = decodeItemIds()
+        let items = itemIds.compactMap { itemId in
+            mediaItems.first { $0.id == itemId }
+        }
+        return Playlist(
+            id: id,
+            name: name,
+            description: playlistDescription,
+            artworkURL: artworkURL,
+            items: items,
+            createdAt: createdAt,
+            updatedAt: updatedAt,
+            isPublic: isPublic,
+            playCount: Int(playCount)
+        )
+    }
+
+    func update(from playlist: Playlist) {
+        id = playlist.id
+        name = playlist.name
+        playlistDescription = playlist.description
+        artworkURL = playlist.artworkURL
+        itemsJSON = encodeItemIds(playlist.items.map { $0.id })
+        createdAt = playlist.createdAt
+        updatedAt = playlist.updatedAt
+        isPublic = playlist.isPublic
+        playCount = Int32(playlist.playCount)
+    }
+
+    // MARK: - JSON helpers
+
+    private func decodeItemIds() -> [String] {
+        guard let data = itemsJSON.data(using: .utf8),
+              let array = try? JSONDecoder().decode([String].self, from: data) else {
+            return []
+        }
+        return array
+    }
+
+    private func encodeItemIds(_ ids: [String]) -> String {
+        guard let data = try? JSONEncoder().encode(ids),
+              let json = String(data: data, encoding: .utf8) else {
+            return "[]"
+        }
+        return json
+    }
+}

package/templates/ios/MediaTemplate/MediaTemplate/Features/Browse/BrowseView.swift

@@ -1,4 +1,5 @@
 import SwiftUI
+// EmptyStateView is in Core/Components/EmptyStateView.swift
 
 // MARK: - Browse View
 struct BrowseView: View {
@@ -48,7 +49,8 @@ class BrowseViewModel: ObservableObject {
     @Published var selectedCategory: MediaCategory?
     
     func loadData() {
-        categories = MockDataProvider.shared.categories
+        let repository = DataSourceResolver.repository
+        categories = repository.categories
     }
 }
 
@@ -69,11 +71,15 @@ struct CategoryDetailView: View {
                 GridItem(.flexible()),
                 GridItem(.flexible())
             ], spacing: AppConfig.Theme.Spacing.md) {
-                ForEach(Array(viewModel.items.enumerated()), id: \.element.id) { index, item in
+                if viewModel.items.isEmpty {
+                    EmptyStateView(config: .noItems(message: "No items in this category."))
+                } else {
+                    ForEach(Array(viewModel.items.enumerated()), id: \.element.id) { index, item in
                     NavigationLink(destination: DetailView(item: item)) {
                         MediaCard(item: item)
                     }
                     .accessibilityIdentifier("category_detail_item_\(index)_card")
+                    }
                 }
             }
             .padding()
@@ -95,7 +101,8 @@ class CategoryDetailViewModel: ObservableObject {
     }
     
     func loadItems() {
-        items = MockDataProvider.shared.mediaItems(for: category)
+        let repository = DataSourceResolver.repository
+        items = repository.mediaItems(for: category)
     }
 }