package org.webslinger.commons.vfs;

 import java.io.Closeable;

 import java.io.FilterInputStream;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.net.MalformedURLException;

 import java.net.URL;

 import java.security.AccessController;

 import java.security.PrivilegedActionException;

 import java.security.PrivilegedExceptionAction;

 import java.security.cert.Certificate;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Set;

 import java.util.List;

 import java.util.concurrent.atomic.AtomicReference;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileContentInfo;

 import org.apache.commons.vfs.FileContentInfoFactory;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.FileSelector;

 import org.apache.commons.vfs.FileSystem;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileUtil;

 import org.apache.commons.vfs.NameScope;

 import org.apache.commons.vfs.RandomAccessContent;

 import org.apache.commons.vfs.Selectors;

 import org.apache.commons.vfs.operations.DefaultFileOperations;

 import org.apache.commons.vfs.operations.FileOperations;

 import org.apache.commons.vfs.provider.AbstractFileSystem;

 import org.apache.commons.vfs.provider.DefaultFileSelectorInfo;

 import org.apache.commons.vfs.provider.DefaultURLStreamHandler;

 import org.apache.commons.vfs.provider.UriParser;

 import org.apache.commons.vfs.util.MonitorInputStream;

 import org.apache.commons.vfs.util.MonitorOutputStream;

 import org.apache.commons.vfs.util.RandomAccessMode;

 import org.webslinger.lang.AtomicCollection;

 import org.webslinger.commons.vfs.util.Walker;

 public abstract class AbstractGenerifiedFileObject<N extends FileName, F extends AbstractGenerifiedFileObject<N, F, S>, S extends AbstractGenerifiedFileSystem<N, F, S>> implements FileObject, GenerifiedFileObject<N, F, S>  {

     protected final S fs;

     protected final N name;

     protected final DefaultFileContent content = new DefaultFileContent();

     protected final AtomicReference<FileType> type = new AtomicReference<FileType>(null);

     protected final AtomicReference<F[]> children = new AtomicReference<F[]>(null);

     protected FileOperations operations;

     public AbstractGenerifiedFileObject(N name, S fs) {

         this.name = name;

         this.fs = fs;

     }

     protected void injectType(FileType newType) throws FileSystemException {

         type.set(newType);

         F parent = getParent();

         if (parent == null) return;

         parent.childChanged((F) this, newType);

     }

     protected void childChanged(F child, FileType newType) throws FileSystemException {

         children.set(null);

     }

     public N getName() {

         return name;

     }

     public URL getURL() throws FileSystemException {

         final StringBuffer buf = new StringBuffer();

         try {

             return AccessController.doPrivileged(

                 new PrivilegedExceptionAction<URL>() {

                     public URL run() throws MalformedURLException {

                         return new URL(UriParser.extractScheme(name.getURI(), buf), "", -1, buf.toString(), fs.getStreamHandler());

                     }

                 }

             );

         } catch (final PrivilegedActionException e) {

             throw new FileSystemException("vfs.provider/get-url.error", name, e.getException());

         }

     }

     public FileType getType() throws FileSystemException {

         FileType type;

         do {

             type = this.type.get();

             if (type != null) return type;

             type = doGetType();

         } while (!this.type.compareAndSet(null, type));

         return type;

     }

     public boolean exists() throws FileSystemException {

         return getType() != FileType.IMAGINARY;

     }

     public boolean isHidden() throws FileSystemException {

         return false;

     }

     public boolean isReadable() throws FileSystemException {

         return true;

     }

     public boolean isWriteable() throws FileSystemException {

         return false;

     }

     public F getParent() throws FileSystemException {

         if (this == fs.getRoot()) {

             return null;

         }

         return fs.resolveFile(name.getParent());

     }

     public S getFileSystem() {

         return fs;

     }

     public FileObject[] getChildren() throws FileSystemException {

         F[] newChildren = null;

 OUTER:

         do {

             F[] children = this.children.get();

             if (children != null) return children;

             newChildren = buildChildren();

         } while (!children.compareAndSet(null, newChildren));

         return newChildren;

     }

     private F[] buildChildren() throws FileSystemException {

         String[] names = doListChildren();

         F[] children = getFileSystem().newArray(names.length);

         for (int i = 0; i < names.length; i++) {

             children[i] = resolveFile(names[i]);

         }

         return children;

     }

     public F getChild(String name) throws FileSystemException {

         for (FileObject child: getChildren()) {

             if (child.getName().getBaseName().equals(name)) return (F) child;

         }

         return null;

     }

     public F resolveFile(String name, NameScope scope) throws FileSystemException {

         return fs.resolveFile(fs.getFileSystemManager().resolveName(this.name, name, scope));

     }

     public F resolveFile(String name) throws FileSystemException {

         return resolveFile(name, NameScope.FILE_SYSTEM);

     }

     public F[] findFiles(FileSelector selector) throws FileSystemException {

         if (!exists()) return null;

         ArrayList<LayeredFileObject> list = new ArrayList<LayeredFileObject>();

         findFiles(selector, true, list);

         return list.toArray(getFileSystem().newArray(list.size()));

     }

     public void findFiles(FileSelector selector, boolean depthwise, List selected) throws FileSystemException {

         Walker.walk(this, selector, depthwise, selected);

     }

     public boolean delete() throws FileSystemException {

         return delete(Selectors.SELECT_SELF) > 0;

     }

     public int delete(FileSelector selector) throws FileSystemException {

         if (getType() == FileType.IMAGINARY) return 0;

         int deleted = 0;

         for (F file: findFiles(selector)) {

             if (file.getType().hasChildren()) {

                 if (file.getChildren().length != 0) {

                     continue;

                 }

             }

             try {

                 file.doDelete();

             } catch (Throwable t) {

                 throw VFSUtil.makeFileSystemException(t);

             }

             deleted++;

         }

         return deleted;

     }

     protected void createParentFolder() throws FileSystemException {

         F parent = getParent();

         if (parent == null) return;

         parent.createFolder();

     }

     public void createFolder() throws FileSystemException {

         createParentFolder();

         doCreateFolder();

         injectType(FileType.FOLDER);

     }

     public void createFile() throws FileSystemException {

         createParentFolder();

         doCreateFile();

         injectType(FileType.FILE);

     }

     protected void doCopyFile(FileObject src) throws FileSystemException {

         try {

             FileUtil.copyContent(src, this);

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         }

     }

     protected void doCopyFolder(FileObject src) throws FileSystemException {

         createFolder();

     }

     protected void doCopyMetaData(FileObject src) throws FileSystemException {

         getContent().setLastModifiedTime(src.getContent().getLastModifiedTime());

     }

     private final void doCopy(FileObject src) throws FileSystemException {

         FileType destType = getType();

         FileType srcType = src.getType();

         if (destType != FileType.IMAGINARY && destType != srcType) delete(Selectors.SELECT_ALL);

         if (srcType.hasContent()) doCopyFile(src);

         if (srcType.hasChildren()) doCopyFolder(src);

         doCopyMetaData(src);

     }

     public void copyFrom(FileObject src, FileSelector selector) throws FileSystemException {

         if (src == this) return;

         for (FileObject file: src.findFiles(selector)) {

             if (file == src) {

                 doCopy(src);

             } else {

                 FileObject destChild = resolveFile(src.getName().getRelativeName(file.getName()), NameScope.DESCENDENT_OR_SELF);

                 destChild.copyFrom(file, Selectors.SELECT_SELF);

             }

         }

     }

     public void moveTo(FileObject dest) throws FileSystemException {

         if (dest == this) return;

         dest.copyFrom(this, Selectors.SELECT_ALL);

         for (FileObject file: findFiles(Selectors.SELECT_ALL)) {

             file.delete();

         }

     }

     public boolean canRenameTo(FileObject target) {

         return false;

     }

     public FileContent getContent() {

         return content;

     }

     public void close() throws FileSystemException {

         getContent().close();

         refresh();

     }

     public void refresh() throws FileSystemException {

         children.set(null);

         type.set(null);

     }

     public boolean isAttached() {

         return true;

     }

     public boolean isContentOpen() {

         return getContent().isOpen();

     }

     public FileOperations getFileOperations() throws FileSystemException {

         if (operations == null) operations = new DefaultFileOperations(this);

         return operations;

     }

     public String toString() {

         return getName().toString();

     }

     protected abstract FileType doGetType() throws FileSystemException;

     protected abstract String[] doListChildren() throws FileSystemException;

     protected abstract void doDelete() throws FileSystemException;

     protected abstract void doCreateFolder() throws FileSystemException;

     protected abstract void doCreateFile() throws FileSystemException;

     protected abstract long doGetSize() throws FileSystemException;

     protected abstract long doGetLastModifiedTime() throws FileSystemException;

     protected abstract void doSetLastModifiedTime(long lastModifiedTime) throws FileSystemException;

     protected abstract boolean doAttributeExists(String name) throws FileSystemException;

     protected abstract Map<String, Object> doGetAttributes() throws FileSystemException;

     protected abstract String[] doGetAttributeNames() throws FileSystemException;

     protected abstract Object doGetAttribute(String name) throws FileSystemException;

     protected abstract void doRemoveAttribute(String name) throws FileSystemException;

     protected abstract void doSetAttribute(String name, Object value) throws FileSystemException;

     protected abstract Certificate[] doGetCertificates() throws FileSystemException;

     protected abstract InputStream doGetInputStream() throws FileSystemException;

     protected abstract OutputStream doGetOutputStream(boolean append) throws FileSystemException;

     protected abstract RandomAccessContent doGetRandomAccessContent(RandomAccessMode mode) throws FileSystemException;

     protected FileContentInfoFactory getFileContentInfoFactory() {

         return getFileSystem().getFileSystemManager().getFileContentInfoFactory();

     }

     protected FileContentInfo doGetContentInfo() throws FileSystemException {

         return getFileContentInfoFactory().create(getContent());

     }

     protected class DefaultFileContent implements FileContent {

         protected AtomicCollection<Closeable> streams = new AtomicCollection<Closeable>(new HashSet<Closeable>()) {

             protected Collection<Closeable> copyCollection(Collection<Closeable> old) {

                 return new HashSet<Closeable>(old);

             }

         };

         public F getFile() {

             return (F) AbstractGenerifiedFileObject.this;

         }

         public long getSize() throws FileSystemException {

             return doGetSize();

         }

         public long getLastModifiedTime() throws FileSystemException {

             return doGetLastModifiedTime();

         }

         public void setLastModifiedTime(long lastModifiedTime) throws FileSystemException {

             doSetLastModifiedTime(lastModifiedTime);

         }

         public boolean attributeExists(String name) throws FileSystemException {

             return doAttributeExists(name);

         }

         public Map<String, ?> getAttributes() throws FileSystemException {

             return doGetAttributes();

         }

         public String[] getAttributeNames() throws FileSystemException {

             return doGetAttributeNames();

         }

         public Object getAttribute(String name) throws FileSystemException {

             return doGetAttribute(name);

         }

         public void removeAttribute(String name) throws FileSystemException {

             doRemoveAttribute(name);

         }

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

             doSetAttribute(name, value);

         }

         public Certificate[] getCertificates() throws FileSystemException {

             return doGetCertificates();

         }

         public InputStream getInputStream() throws FileSystemException {

             return openStream(new MonitorInputStream(doGetInputStream()) {

                 protected void onClose() throws IOException {

                     try {

                         super.onClose();

                     } finally {

                         closeStream(this);

                     }

                 }

             });

         }

         public OutputStream getOutputStream() throws FileSystemException {

             return getOutputStream(false);

         }

         public OutputStream getOutputStream(boolean append) throws FileSystemException {

             createParentFolder();

             OutputStream realOutputStream = doGetOutputStream(append);

             injectType(FileType.FILE);

             return openStream(new MonitorOutputStream(realOutputStream) {

                 protected void onClose() throws IOException {

                     try {

                         super.onClose();

                     } finally {

                         closeStream(this);

                     }

                 }

             });

         }

         public RandomAccessContent getRandomAccessContent(RandomAccessMode mode) throws FileSystemException {

             //System.err.println("getRandomAccessContent(" + mode + "): realFile=" + realFile);

             RandomAccessContent realRandomAccessContent = doGetRandomAccessContent(mode);

             if (mode.requestWrite()) injectType(FileType.FILE);

             return openStream(new MonitorRandomAccessContent(realRandomAccessContent) {

                 protected void onClose() throws IOException {

                     try {

                         super.onClose();

                     } finally {

                         closeStream(this);

                     }

                 }

             });

         }

         public FileContentInfo getContentInfo() throws FileSystemException {

             return doGetContentInfo();

         }

         protected <T extends Closeable> T openStream(T in) {

             streams.add(in);

             return in;

         }

         protected <T extends Closeable> void closeStream(T in) {

             streams.remove(in);

         }

         public boolean isOpen() {

             return !streams.collection().isEmpty();

         }

         public void close() throws FileSystemException {

             try {

                 for (Closeable stream: this.streams.collection()) {

                     stream.close();

                 }

             } catch (Throwable t) {

                 throw VFSUtil.makeFileSystemException(t);

             }

         }

     }

 }