Tusker/Tusker/CoreData/MastodonCachePersistentStore.swift

//
//  MastodonCachePersistentStore.swift
//  Tusker
//
//  Created by Shadowfacts on 4/11/20.
//  Copyright © 2020 Shadowfacts. All rights reserved.
//

import Foundation
import CoreData
import Pachyderm
import Combine

class MastodonCachePersistentStore: NSPersistentContainer {
    
    private static let managedObjectModel: NSManagedObjectModel = {
        let url = Bundle.main.url(forResource: "Tusker", withExtension: "momd")!
        return NSManagedObjectModel(contentsOf: url)!
    }()
    
    private(set) lazy var backgroundContext: NSManagedObjectContext = {
        let context = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
        context.parent = self.viewContext
        return context
    }()
    
    let statusSubject = PassthroughSubject<String, Never>()
    let accountSubject = PassthroughSubject<String, Never>()

    init(for accountInfo: LocalData.UserAccountInfo?, transient: Bool = false) {
        if transient {
            super.init(name: "transient_cache", managedObjectModel: MastodonCachePersistentStore.managedObjectModel)
            
            let storeDescription = NSPersistentStoreDescription()
            storeDescription.type = NSInMemoryStoreType
            persistentStoreDescriptions = [storeDescription]
        } else {
            super.init(name: "\(accountInfo!.id)_cache", managedObjectModel: MastodonCachePersistentStore.managedObjectModel)
        }
        
        loadPersistentStores { (description, error) in
            if let error = error {
                fatalError("Unable to load persistent store: \(error)")
            }
        }
    }
    
    func status(for id: String, in context: NSManagedObjectContext? = nil) -> StatusMO? {
        let context = context ?? viewContext
        let request: NSFetchRequest<StatusMO> = StatusMO.fetchRequest()
        request.predicate = NSPredicate(format: "id = %@", id)
        request.fetchLimit = 1
        if let result = try? context.fetch(request), let status = result.first {
            return status
        } else {
            return nil
        }
    }
    
    @discardableResult
    private func upsert(status: Status, incrementReferenceCount: Bool) -> StatusMO {
        if let statusMO = self.status(for: status.id, in: self.backgroundContext) {
            statusMO.updateFrom(apiStatus: status, container: self)
            if incrementReferenceCount {
                statusMO.incrementReferenceCount()
            }
            return statusMO
        } else {
            let statusMO = StatusMO(apiStatus: status, container: self, context: self.backgroundContext)
            if incrementReferenceCount {
                statusMO.incrementReferenceCount()
            }
            return statusMO
        }
    }
    
    func addOrUpdate(status: Status, incrementReferenceCount: Bool, completion: ((StatusMO) -> Void)? = nil) {
        backgroundContext.perform {
            let statusMO = self.upsert(status: status, incrementReferenceCount: incrementReferenceCount)
            if self.backgroundContext.hasChanges {
                try! self.backgroundContext.save()
            }
            completion?(statusMO)
            self.statusSubject.send(status.id)
        }
    }

    func addAll(statuses: [Status], completion: (() -> Void)? = nil) {
        backgroundContext.perform {
            statuses.forEach { self.upsert(status: $0, incrementReferenceCount: true) }
            if self.backgroundContext.hasChanges {
                try! self.backgroundContext.save()
            }
            statuses.forEach { self.statusSubject.send($0.id) }
            completion?()
        }
    }

    func account(for id: String, in context: NSManagedObjectContext? = nil) -> AccountMO? {
        let context = context ?? viewContext
        let request: NSFetchRequest<AccountMO> = AccountMO.fetchRequest()
        request.predicate = NSPredicate(format: "id = %@", id)
        request.fetchLimit = 1
        if let result = try? context.fetch(request), let account = result.first {
            return account
        } else {
            return nil
        }
    }
    
    @discardableResult
    private func upsert(account: Account, incrementReferenceCount: Bool) -> AccountMO {
        if let accountMO = self.account(for: account.id, in: self.backgroundContext) {
            accountMO.updateFrom(apiAccount: account, container: self)
            if incrementReferenceCount {
                accountMO.incrementReferenceCount()
            }
            return accountMO
        } else {
            let accountMO = AccountMO(apiAccount: account, container: self, context: self.backgroundContext)
            if incrementReferenceCount {
                accountMO.incrementReferenceCount()
            }
            return accountMO
        }
    }
    
    func addOrUpdate(account: Account, incrementReferenceCount: Bool, completion: ((AccountMO) -> Void)? = nil) {
        backgroundContext.perform {
            let accountMO = self.upsert(account: account, incrementReferenceCount: incrementReferenceCount)
            if self.backgroundContext.hasChanges {
                try! self.backgroundContext.save()
            }
            completion?(accountMO)
            self.accountSubject.send(account.id)
        }
    }
    
    func addAll(accounts: [Account], completion: (() -> Void)? = nil) {
        backgroundContext.perform {
            accounts.forEach { self.upsert(account: $0, incrementReferenceCount: true) }
            if self.backgroundContext.hasChanges {
                try! self.backgroundContext.save()
            }
            completion?()
            accounts.forEach { self.accountSubject.send($0.id) }
        }
    }

    func addAll(notifications: [Pachyderm.Notification], completion: (() -> Void)? = nil) {
        backgroundContext.perform {
            let statuses = notifications.compactMap { $0.status }
            // filter out mentions, otherwise we would double increment the reference count of those accounts
            // since the status has the same account as the notification
            let accounts = notifications.filter { $0.kind != .mention }.map { $0.account }
            statuses.forEach { self.upsert(status: $0, incrementReferenceCount: true) }
            accounts.forEach { self.upsert(account: $0, incrementReferenceCount: true) }
            if self.backgroundContext.hasChanges {
                try! self.backgroundContext.save()
            }
            completion?()
            statuses.forEach { self.statusSubject.send($0.id) }
            accounts.forEach { self.accountSubject.send($0.id) }
        }
    }
    
    func performBatchUpdates(_ block: @escaping (_ context: NSManagedObjectContext, _ addAccounts: ([Account]) -> Void, _ addStatuses: ([Status]) -> Void) -> Void, completion: (() -> Void)? = nil) {
        backgroundContext.perform {
            var updatedAccounts = [String]()
            var updatedStatuses = [String]()
            
            block(self.backgroundContext, { (accounts) in
                accounts.forEach { self.upsert(account: $0, incrementReferenceCount: true) }
                updatedAccounts.append(contentsOf: accounts.map { $0.id })
            }, { (statuses) in
                statuses.forEach { self.upsert(status: $0, incrementReferenceCount: true) }
                updatedStatuses.append(contentsOf: statuses.map { $0.id })
            })

            updatedAccounts.forEach(self.accountSubject.send)
            updatedStatuses.forEach(self.statusSubject.send)
            
            if self.backgroundContext.hasChanges {
                try! self.backgroundContext.save()
            }
            completion?()
        }
    }
    
}