package org.webslinger.commons.vfs.handlers.attributes;

 import java.io.IOException;

 import java.util.LinkedHashSet;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystem;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.Selectors;

 import org.webslinger.io.IOUtil;

 import org.webslinger.lang.ConcurrentCache;

 import org.webslinger.util.GeneratedResult;

 import org.webslinger.util.TTLObject;

 import org.webslinger.util.TTLCachedObject;

 import org.webslinger.commons.vfs.VFSUtil;

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

 public abstract class FlatAttributeMapper implements AttributeMapper {

     static {

         TTLObject.setDefaultTTLForClass(Attribute.class, 1000);

     }

     protected class FlatAttributeMapperCache extends ConcurrentCache<String, Attribute> {

         protected FlatAttributeMapperCache(Class<?> owner, String field, String label) {

             super(owner, field, label, ConcurrentCache.HARD);

         }

         public Attribute get(String key, boolean create) throws FileSystemException {

             try {

                 return super.get(key, create);

             } catch (Exception e) {

                 throw VFSUtil.makeFileSystemException(e);

             }

         }

         protected Attribute createValue(String key) throws Exception {

             FileObject attrDir = getAttributeDir();

             FileObject attrFile;

             if (attrDir.getType().hasChildren()) {

                 attrFile = attrDir.getChild(key);

                 if (attrFile == null) attrFile = attrDir.resolveFile(key);

             } else {

                 attrFile = attrDir.resolveFile(key);

             }

             return new Attribute(attrFile);

         }

         protected Attribute findIfExists(String key) throws Exception {

             FileObject attrDir = getAttributeDir();

             if (!attrDir.getType().hasChildren()) return null;

             FileObject attrFile = attrDir.getChild(key);

             if (attrFile != null && attrFile.exists()) return new Attribute(attrFile);

             return null;

         }

     }

     protected final FlatAttributeMapperCache attributes = new FlatAttributeMapperCache(FlatAttributeMapper.class, "attributes", null);

     protected final ExclusionHandler exclusionHandler;

     public FlatAttributeMapper(ExclusionHandler exclusionHandler) throws FileSystemException {

         this.exclusionHandler = exclusionHandler;

     }

     protected abstract FileObject getAttributeDir() throws FileSystemException;

     protected abstract FileObject getAttributeFile(FileName name) throws FileSystemException;

     public void deleteAttributes() throws FileSystemException {

         FileObject attrDir = getAttributeDir();

         attrDir.delete(Selectors.SELECT_CHILDREN);

         attrDir.delete(Selectors.SELECT_SELF);

         attributes.clear();

     }

     public void refresh() throws FileSystemException {

         getAttributeDir().refresh();

         attributes.clear();

     }

     public TTLCachedObject<Object> getAttribute(String name) throws FileSystemException {

         Attribute attribute = attributes.get(name, false);

         return attribute != null ? attribute : null;

     }

     public boolean attributeExists(String name) throws FileSystemException {

         Attribute attribute = attributes.get(name, false);

         return attribute != null ? attribute.exists() : false;

     }

     // Possible TTL?

     public String[] getAttributeNames() throws FileSystemException {

         FileObject attrDir = getAttributeDir();

         attrDir.refresh();

         if (!attrDir.getType().hasChildren()) return new String[0];

         FileObject[] children = getAttributeDir().getChildren();

         if (children == null) return new String[0];

         LinkedHashSet<String> names = new LinkedHashSet<String>(children.length);

         for (FileObject child: children) {

             names.add(child.getName().getBaseName());

         }

         exclusionHandler.excludeNames(names);

         return names.toArray(new String[names.size()]);

     }

     public void setAttribute(String name, Object value) throws FileSystemException {

         if (value == null) {

             removeAttribute(name);

             return;

         }

         attributes.get(name, true).set(value);

     }

     public void removeAttribute(String name) throws FileSystemException {

         attributes.remove(name);

         FileObject attrDir = getAttributeDir();

         FileObject attrFile;

         if (attrDir.getType().hasChildren()) {

             attrFile = attrDir.getChild(name);

             if (attrFile == null) attrFile = attrDir.resolveFile(name);

         } else {

             attrFile = attrDir.resolveFile(name);

         }

         if (!attrFile.exists()) attrFile.refresh();

         attrFile.delete();

     }

     protected class Attribute extends TTLCachedObject<Object> {

         protected final FileObject file;

         protected Attribute(FileObject file) throws FileSystemException {

             this.file = file;

         }

         protected FileObject getFile() throws FileSystemException {

             return file;

         }

         protected boolean exists() throws FileSystemException {

             return getFile().exists();

         }

         protected void set(Object value) throws FileSystemException {

             FileObject file = getFile();

             try {

                 IOUtil.writeObject(file.getContent().getOutputStream(), value);

                 lastModifiedTime = file.getContent().getLastModifiedTime();

                 setObject(value);

             } catch (IOException e) {

                 throw VFSUtil.makeFileSystemException(e);

             }

         }

         protected long getTimestamp(Object old) throws IOException {

             FileObject file = getFile();

             file.refresh();

             return file.exists() ? file.getContent().getLastModifiedTime() : NOT_EXISTANT_TIMESTAMP;

         }

         protected GeneratedResult<Object> generate(Object old) throws IOException {

             FileObject file = getFile();

             file.refresh();

             try {

                 if (file.exists()) return new GeneratedResult<Object>(file.getContent().getLastModifiedTime(), IOUtil.readObject(file.getContent().getInputStream()));

             } catch (Exception e) {

                 return IOUtil.checkException(e);

             }

             return new GeneratedResult<Object>(NOT_EXISTANT_TIMESTAMP, null);

         }

     }

 }