     ///   - destinationPath: the relative path
     ///   - handler: the completion hanlder
     public func copy(node:Node,to destinationPath:String)->(){
-
-
         _boxDelegate?.copyIsReady(node: node, to: destinationPath, proceed: {
             // TODO implement
         })

    ///   - relativePath: the relative Path of the Node
    ///   - authorized: the User UIDS or "*" if public
    ///   - deleteOriginal: should we delete the original?
    ///   - zipped: should we zip the node
    ///   - crypted: should we encrypt the node
    ///   - priority: synchronization priority (higher == will be synchronized before the other nodes)
    /// - Returns: the node
    public func add(original absolutePath:String, relativePath:String,authorized:[String],deleteOriginal:Bool=false,zipped:Bool=false,crypted:Bool=true,priority:Int=0)throws->Node{
        return Node()
    }


                        failure("\(error)")
                    }
                }
            }else{
                Async.main{
                    failure("Unable to create file Handle at: \(path)")
                }
            }

        }

    }


    /// Joins the chunks to form a file
    /// - The hard stuff is done Asynchronously on a the Utility queue
    /// - we use an Autorelease pool to lower the memory foot print
    ///
    /// - Parameters:
    ///   - paths: the chunks absolute paths
    ///   - destinationFilePath: the joined file destination
    ///   - decompress: should we decompress using LZ4
    ///   - decrypt: should we decrypt usign AES256
    ///   - success: the success closure
    ///   - failure: the failure closure
    public func joinChunks (   from paths:[String],
                              to destinationFilePath:String,
                              decompress:Bool,
                              decrypt:Bool,
                              success:@escaping ()->(),
                              failure:@escaping (String)->()){

        // Don't block the main thread with those intensive IO  processing
        Async.utility {

            do{

                let folderPath=(destinationFilePath as NSString).deletingLastPathComponent
                try FileManager.default.createDirectory(atPath: folderPath, withIntermediateDirectories: true, attributes: nil)
                FileManager.default.createFile(atPath: destinationFilePath, contents: nil, attributes: nil)

                // Assemble
                if let writeFileHande = FileHandle(forWritingAtPath:destinationFilePath ){
                    writeFileHande.seek(toFileOffset: 0)

                    for source in paths{
                        try autoreleasepool(invoking: { () -> Void in
                            let url=URL(fileURLWithPath: source)
                            var data = try Data(contentsOf:url)
                            if decrypt{
                                data = try Bartleby.cryptoDelegate.decryptData(data)
                            }
                            if decompress{
                                data = try data.decompress(algorithm: .lz4)
                            }
                            writeFileHande.write(data)
                        })
                    }
                    Async.main{
                        success()
                    }
                    
                }else{
                    Async.main{
                        failure("Unable to create file Handle at: \(destinationFilePath)")
                    }
                }
            }catch{
                Async.main{
                    failure("\(error)")
                }
            }
        }
    }

    
}
