package org.webslinger.commons.vfs.flat;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Map;

 import org.apache.commons.vfs.Capability;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileSystemManager;

 import org.apache.commons.vfs.FileSystemOptions;

 import org.webslinger.commons.vfs.FileSet;

 import org.webslinger.commons.vfs.FilteringFileSystem;

 import org.webslinger.commons.vfs.handlers.ExclusionHandler;

 import org.webslinger.commons.vfs.handlers.HandlerFactory;

 import org.webslinger.commons.vfs.handlers.attributes.AttributeMapperHandler;

 import org.webslinger.commons.vfs.handlers.attributes.DefaultAttributeMapperHandler;

 public class FlatFileSystem extends FilteringFileSystem<FileName, FlatFileObject, FlatFileSystem> implements ExclusionHandler {

     // deleted token:

     //     path/to/file/$parent/.meta/deleted/file

     //     path/to/dir/.meta/self/deleted

     // operations(supports dirs and files), does the Flat magic:

     //     path/to/file/$parent/.meta/operations/file

     //     path/to/dir/.meta/self/operations

     // .meta/deleted and .meta/operations are local, not managed with Flat symantics

     // Should files be converted to dirs when a child is added: yes

     // path/to/dir/.meta/link

     // path/to/dir/.meta/self/content

     // attributes:

     //     path/to/file/$parent/.meta/attributes/file/$attrName

     //     path/to/dir/.meta/self/attributes/$attrName

     // How to handle removing content in Flat, but not the children?  Using

     // the deleted token on the item won't work, as that may cause

     // recursion to not work.

     private final FileObject root;

     private AttributeMapperHandler attributeHandler;

     private ExclusionHandler exclusionHandler;

     public FlatFileSystem(FileName name, FileObject root, FileSystemOptions options) throws FileSystemException {

         super(name, root, options);

         this.root = root;

     }

     public FlatFileObject createFile(FileName name) throws FileSystemException {

 //log("createFile(" + name.getClass() + "->" + name + ")");

         return new FlatFileObject(name, this, root.resolveFile(name.getPath().substring(1)));

     }

     // operations(supports dirs and files), filees the Flat magic:

     //     path/to/file/$parent/.meta/operations/file

     //     path/to/dir/.meta/self/operations

     // .meta/deleted and .meta/operations are local, not managed with Flat symantics

     // Should files be converted to dirs when a child is added: yes

     // content:

     //     path/to/file

     //     path/to/dir/.meta/self/content

     // attributes:

     //     path/to/file/$parent/.meta/attributes/file/$attrName

     //     path/to/dir/.meta/self/attributes/$attrName

     // FlatFileObject interface

     protected AttributeMapperHandler getAttributeHandler() throws FileSystemException {

         if (attributeHandler != null) return attributeHandler;

         HandlerFactory<AttributeMapperHandler, FlatFileSystem> factory = FlatConfigBuilder.getInstance().getAttributeMapperHandlerFactory(getFileSystemOptions());

         if (factory != null) attributeHandler = factory.getHandler(this, AttributeMapperHandler.class);

         if (attributeHandler == null) attributeHandler = new StandardFlatAttributeMapperHandler(this);

         return attributeHandler;

     }

     protected ExclusionHandler getExclusionHandler() throws FileSystemException {

         if (exclusionHandler != null) return exclusionHandler;

         HandlerFactory<ExclusionHandler, FlatFileSystem> factory = FlatConfigBuilder.getInstance().getExclusionHandlerFactory(getFileSystemOptions());

         if (factory != null) exclusionHandler = factory.getHandler(this, ExclusionHandler.class);

         if (exclusionHandler == null) exclusionHandler = new ExclusionHandler.NullHandler();

         return exclusionHandler;

     }

     protected FileSet getRealFiles(FlatFileObject file) throws FileSystemException {

         return createFileSet(new FileObject[] {file.getRealFile()}, new FileObject[0]);

     }

     protected FlatFileObject[] newArray(int length) {

         return new FlatFileObject[length];

     }

     public void excludeNames(Collection<String> names) throws FileSystemException {

         getAttributeHandler().excludeNames(names);

         ExclusionHandler exclusionHandler = getExclusionHandler();

         if (exclusionHandler == null) return;

         exclusionHandler.excludeNames(names);

     }

 }