gramora/gramora/Services/HistoryStorageService.swift

import Foundation
import os

extension Notification.Name {
    static let historyDidChange = Notification.Name("historyDidChange")
}

protocol HistoryStoring {
    func loadEntries() -> [HistoryEntry]
    func save(_ entry: HistoryEntry)
    func delete(id: UUID)
    func clearAll()
}

final class HistoryStorageService: HistoryStoring {
    static let shared = HistoryStorageService()

    private let defaults: UserDefaults
    private let storageKey = "gramora.history.entries"
    private let maxEntries = 100
    private let queue = DispatchQueue(label: "com.gramora.history.storage")
    private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.Gramora", category: "HistoryStorage")

    init(defaults: UserDefaults = .standard) {
        self.defaults = defaults
    }

    func loadEntries() -> [HistoryEntry] {
        queue.sync {
            loadEntriesUnlocked()
        }
    }

    func save(_ entry: HistoryEntry) {
        queue.sync {
            var entries = loadEntriesUnlocked()
            entries.removeAll { $0.id == entry.id }
            entries.insert(entry, at: 0)
            entries = Array(entries.prefix(maxEntries))
            persistUnlocked(entries)
        }
    }

    func delete(id: UUID) {
        queue.sync {
            var entries = loadEntriesUnlocked()
            entries.removeAll { $0.id == id }
            persistUnlocked(entries)
        }
    }

    func clearAll() {
        queue.sync {
            persistUnlocked([])
        }
    }

    private func loadEntriesUnlocked() -> [HistoryEntry] {
        guard let data = defaults.data(forKey: storageKey) else {
            return []
        }

        do {
            let entries = try JSONDecoder().decode([HistoryEntry].self, from: data)
            return entries.sorted { $0.createdAt > $1.createdAt }
        } catch {
            logger.error("Failed to decode history entries: \(error.localizedDescription, privacy: .public)")
            return []
        }
    }

    private func persistUnlocked(_ entries: [HistoryEntry]) {
        do {
            let data = try JSONEncoder().encode(entries)
            defaults.set(data, forKey: storageKey)
            DispatchQueue.main.async {
                NotificationCenter.default.post(name: .historyDidChange, object: nil)
            }
        } catch {
            logger.error("Failed to persist history entries: \(error.localizedDescription, privacy: .public)")
        }
    }
}