package org.webslinger.container;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.HashMap;

 import java.util.Map;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileType;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.util.GeneratedResult;

 import org.webslinger.util.TTLObject;

 import org.webslinger.vfs.VFSDelegate;

 import org.webslinger.vfs.VFSDelegateProxy;

 public class CommonsVfsFileInfo extends FileInfo {

     static {

         TTLObject.setDefaultTTLForClass(CommonsVfsFileInfo.class, 1000);

     }

     public CommonsVfsFileInfo(WebslingerContainer container, FileObject servletFile) {

         super(container, servletFile);

     }

     protected FileCache createFileCache(FileObject defaultsFile) throws IOException {

         return createFileCache(defaultsFile, null);

     }

     public String getContentType() throws IOException {

         return ((CommonsVfsFileCache) getObject()).contentType;

     }

     protected long getTimestamp(FileCache old) throws IOException {

         FileObject file = findFile();

         if (old == null) return file.exists() ? file.getContent().getLastModifiedTime() : NOT_EXISTANT_TIMESTAMP;

         if (((CommonsVfsFileCache) old).file.equals(file)) return file.exists() ? file.getContent().getLastModifiedTime() : NOT_EXISTANT_TIMESTAMP;

         return FORCE_REGEN;

     }

     protected FileCache createFileCache(FileObject defaultsFile, String contentType) throws IOException {

         FileObject file = findFile();

         String newContentType;

         if (file.exists()) {

             newContentType = file.getContent().getContentInfo().getContentType();

             if (newContentType == null) {

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

                     newContentType = "inode/directory";

                 } else {

                     String extension = file.getName().getExtension();

                     newContentType = getContainer().getMimeType(extension);

                     if (newContentType == null) newContentType = getContainer().getDefaultMimeType();

                 }

             }

         } else {

             String extension = file.getName().getExtension();

             newContentType = getContainer().getMimeType(extension);

             if (newContentType == null) newContentType = getContainer().getDefaultMimeType();

         }

         //System.err.println("newContentType[" + newContentType + "]");

         if (contentType != null && contentType.equals(newContentType)) {

             // old and new contentType the same

         } else if (contentType == null && newContentType == null) {

             // old and new contentType the same

         } else {

             // old and new are different, or new is not null, force a lookup

             defaultsFile = null;

         }

         contentType = newContentType;

         //System.err.println("contentType[" + contentType + "]");

         if (contentType != null && defaultsFile == null) {

             defaultsFile = getContainer().getWWW().resolveFile("/WEB-INF/DefaultMimeAttributes/" + contentType);

         }

         //System.err.println("defaultsFile=" + defaultsFile);

         return new CommonsVfsFileCache(file, contentType, defaultsFile);

     }

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

         CommonsVfsFileCache cache = (CommonsVfsFileCache) createFileCache(old != null ? old.defaultsFile : null, old != null ? ((CommonsVfsFileCache) old).contentType : null);

         return new GeneratedResult<FileCache>(cache.file.exists() ? cache.file.getContent().getLastModifiedTime() : NOT_EXISTANT_TIMESTAMP, cache);

     }

     public FileObject getFile() throws IOException {

         return ((CommonsVfsFileCache) getObject()).file;

     }

     public boolean exists() throws IOException {

         return getFile().exists();

     }

     public boolean equals(Object o) {

         if (!(o instanceof CommonsVfsFileInfo)) return false;

         CommonsVfsFileInfo other = (CommonsVfsFileInfo) o;

         return getServletFile().equals(other.getServletFile());

     }

     public int hashCode() {

         return servletFile.hashCode();

     }

     protected FileObject findFile() throws IOException {

         FileType type = servletFile.getType();

         VFSUtil.refresh(servletFile);

         //System.err.println("findFile(" + servletFile + "), type=" + type + ", exists=" + servletFile.exists());

         if (servletFile.exists() && !type.hasChildren()) return servletFile;

         String[] extensions = (String[]) getContainer().getExtensionList();

         //System.err.println("extensions=" + extensions);

         if (extensions == null || extensions.length == 0) return servletFile;

         FileObject base;

         String name;

         if (type.hasChildren()) {

             if (servletFile.getContent().getAttribute("type") instanceof String) return servletFile;

             base = servletFile;

             name = "index";

             String defaultIndex = (String) servletFile.getContent().getAttribute("default-index");

             if (defaultIndex != null) {

                 FileObject sub = getContainer().parse(servletFile, servletFile, defaultIndex, true).getFile();

                 if (sub.exists()) return sub;

                 name = defaultIndex;

             }

         } else {

             base = servletFile.getParent();

             name = servletFile.getName().getBaseName();

             VFSUtil.refresh(base);

         }

         if (!base.exists()) return servletFile;

         FileObject[] children = base.getChildren();

         if (children != null) for (String extension: extensions) {

             String toMatch = name + extension;

             for (FileObject child: children) {

                 if (child.getName().getBaseName().equals(toMatch)) {

                     VFSUtil.refresh(child);

                     if (!child.getType().hasChildren()) return child;

                 }

             }

         }

         if (type.hasChildren()) {

             if ("true".equals(base.getContent().getAttribute("allow-listing"))) return base;

             return base.resolveFile(name);

         }

         //System.err.println("returning default=" + servletFile);

         return servletFile;

     }

     public String toString() {

         return "FI<" + servletFile + '>';

     }

     public static class CommonsVfsFileInfoVFSDelegate<C> extends FileInfoVFSDelegate<CommonsVfsFileInfo, C> {

         public CommonsVfsFileInfoVFSDelegate(VFSDelegate<Object, Object, C> vfsDelegate) {

             super(vfsDelegate);

         }

         protected Object getReal(FileInfo fi) throws IOException {

             return ((CommonsVfsFileInfo) fi).getFile();

         }

     }

     protected class CommonsVfsFileCache extends FileCache {

         public final FileObject file;

         public final String contentType;

             //super(contentType != null ? getContainer().getWWW().resolveFile("/WEB-INF/DefaultMimeAttributes/" + contentType) : null);

         protected CommonsVfsFileCache(FileObject file, String contentType, FileObject defaultsFile) {

             super(defaultsFile);

             this.file = file;

             this.contentType = contentType;

         }

         protected Object getAttributeInternal(String name) throws IOException {

             if (file != null && file.exists()) {

                 if (file.getContent().attributeExists(name)) return file.getContent().getAttribute(name);

             }

             return super.getAttributeInternal(name);

         }

         protected Map<String, ?> getAttributes() throws IOException {

             Map<String, ?> attributes = super.getAttributes();

             if (file != null && file.exists()) attributes.putAll(file.getContent().getAttributes());

             return attributes;

         }

     }

 }