CoreDataStack.swift

import Foundation
import CoreData

final class CoreDataManager: NSObject {

    //mark:-
    @objc static let sharedInstance = CoreDataManager()

    //mark:- Private helper methods
    private var masterContext: NSManagedObjectContext!
    private(set) var mainContext: NSManagedObjectContext!
    private var persistentStoreCoordinator: NSPersistentStoreCoordinator!
    private var managedObjectModel: NSManagedObjectModel!

    //mark:- Life cycle methods
    private override init() {
        super.init()
        setupStack()
    }

}

private extension CoreDataManager {

    func setupStack() {
        createManagedObjectModel()
        createPersistentStoreCoordinator()
        createContexts()
    }
    
    func createManagedObjectModel() {
        
        if let _ = managedObjectModel {
            return
        }
        
        managedObjectModel = NSManagedObjectModel.mergedModel(from: nil)
    }
    
    func createPersistentStoreCoordinator() {
        
        if let  _ = persistentStoreCoordinator {
            return
        }
        
        persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: managedObjectModel)
        
        let storeUrl = applicationDocumentDirectory().appendingPathComponent("SlideZ.sqlite")
        
        do {
            let _ = try persistentStoreCoordinator.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeUrl, options: nil)
        } catch {
            print("Unresolved error. \(error)")
            abort()
        }
    }
    
    func createContexts() {
        //Creates master context
        masterContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
        masterContext.undoManager = nil
        masterContext.persistentStoreCoordinator = persistentStoreCoordinator
        
        //Creates main context
        mainContext = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
        mainContext.undoManager = nil
        mainContext.parent = masterContext
    }
    
    func saveMasterContext() {
        masterContext.perform { () -> Void in
            do {
                try self.masterContext.save()
            } catch {
                assert(false, "Error saving master context. \(error)")
            }
        }
    }
    
    func applicationDocumentDirectory() -> URL {
        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).last!
    }
}

extension CoreDataManager {

    func temporaryContext() -> NSManagedObjectContext {
        let temporaryContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
        temporaryContext.parent = mainContext
        return temporaryContext
    }
    
    @objc func saveMainContext() {
        mainContext.perform { () -> Void in
            do {
                try self.mainContext.save()
                self.saveMasterContext()
            } catch {
                assert(false, "Error saving master context. \(error)")
            }
        }
    }
    
    func save(context: NSManagedObjectContext) {
        context.perform { () -> Void in
            do {
                try context.save()
                self.saveMainContext()
            } catch {
                assert(false, "Error saving context. \(error)")
            }
        }
    }
    
    func save(context: NSManagedObjectContext, completion: @escaping (Bool) -> Void) {
        context.perform { () -> Void in
            var success = true
            do {
                try context.save()
                self.saveMainContext()
            } catch {
                success = false
                assert(false, "Error saving context. \(error)")
            }
            completion(success)
        }
    }
}