import Tracing

// MARK: - Storable

protocol Storable: class {
    static var entityName: String { get }
}

// MARK: - NSManagedObject

extension Storable where Self: NSManagedObject {
    
    static var entityName: String {
        return NSStringFromClass(self).components(separatedBy: ".").last ?? ""
    }
    
    init(in context: NSManagedObjectContext) {
        
        guard let entity = NSEntityDescription.entity(forEntityName: Self.entityName, in: context) else {
            fatalError("Cannot create entity for entity name: \(Self.entityName)")
        }
        
        self.init(entity: entity, insertInto: context)
    }
}

// MARK: - CategoryModelObject

class CategoryModelObject: NSManagedObject, Storable {
    
    @NSManaged var id: Int64
    @NSManaged var name: String
    @NSManaged var positions: NSSet
}

// MARK: - PositionModelObject

class PositionModelObject: NSManagedObject, Storable {
    
    @NSManaged var id: Int64
    @NSManaged var name: String
    @NSManaged var price: Double
    @NSManaged var category: CategoryModelObject?
}

// MARK: - CategoryPlainObject

class CategoryPlainObject: Mappable {
    
    let id: Int64
    let name: String
    
    var positions: [PositionPlainObject] = [] // Array of objects
    
    required init(with resolver: Resolver) throws {
        
        self.id        = try resolver.value("id")
        self.name      = try resolver.value("name")
        self.positions = (try? resolver.value("positions")) ?? []
    }
}

// MARK: - CategoryPlainObject

class PositionPlainObject: Mappable {
    
    let id: Int64
    let name: String
    let price: Double
    
    var category: CategoryPlainObject? = nil // Nested object
    
    required init(with resolver: Resolver) throws {
        
        self.id       = try  resolver.value("id")
        self.name     = try  resolver.value("name")
        self.price    = try  resolver.value("price")
        self.category = try? resolver.value("category")
    }
}

/// Create request for cache
let request = CacheRequest(entityName: CategoryModelObject.entityName)
        
/// Create tracker that tracks changes with CategoryModelObject (Your NSManagedObject)
/// and notify you about this with CategoryPlainObject (Your plain object)
let tracker = Tracing.coreTracker(cacheType: CategoryModelObject.self, plainType: CategoryPlainObject.self)

/// Setup the tracker
tracker.setup(with: request, context: context) { transactionBatch in
    
    /// Transactions with inserted objects
    transactionBatch.insertedTransactions
    
    /// Transactions with updated objects
    transactionBatch.updatedTransactions
    
    /// Transactions with removed objects
    transactionBatch.removedTransactions
    
    /// Transactions with moved objects  
    transactionBatch.movedTansactions
    
    /// Checking for empty
    transactionBatch.isEmpty
    
    /// Or you can get inserted/updated/removed/moved objects
    for category in transactionBatch.insertedObjects {
        
        /// CategoryPlainObject
        category
        
        /// Use category's simple properties
        category.id
        category.name
        
        /// And nested objects
        category.positions
    }
}

class CategoryMapper: CacheMapper {
    
    typealias CacheType = CategoryModelObject
    typealias PlainType = CategoryPlainObject
    
    func map(from cacheObject: CategoryModelObject) throws -> CategoryPlainObject {
        
        /// Map CategoryModelObject to CategoryPlainObject
    }
}

/// And use it

let mapper  = CategoryMapper()
let tracker = Tracing.coreTracker(with: mapper)

let name = CategoryModelObject.entityName
let filter = "id > 5"
let sortDesriptor = SortDescriptor(withKey: "name", ascending: true)

let request = CacheRequest(entityName: name, predicate: filter, sortDescriptors: [sortDesriptor])