package org.webslinger.container;

 import java.io.InputStream;

 import java.io.IOException;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.atomic.AtomicReference;

 import javax.servlet.ServletException;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileType;

 import static org.webslinger.lang.ClassUtil.NULL;

 import org.webslinger.WebslingerInvoker;

 import org.webslinger.WebslingerServletContext;

 import org.webslinger.io.IOUtil;

 import org.webslinger.lang.ConcurrentFreezableCache;

 import org.webslinger.lang.Freezable;

 import static org.webslinger.lang.ObjectUtil.equalsHelper;

 import static org.webslinger.lang.ObjectUtil.hashCodeHelper;

 import org.webslinger.util.TTLCachedObject;

 import org.webslinger.util.TTLObject;

 import org.webslinger.vfs.VFSDelegate;

 import org.webslinger.vfs.VFSDelegateProxy;

 public abstract class FileInfo extends TTLCachedObject<FileInfo.FileCache> {

     static {

         TTLObject.setDefaultTTLForClass(SplitAttributeTTLObject.class, 1000);

     }

     private final WebslingerContainer container;

     protected final FileObject servletFile;

     protected String type;

     protected FileInfo(WebslingerContainer container, FileObject servletFile) {

         this.container = container;

         this.servletFile = servletFile;

     }

     protected FileCache getInitial() throws IOException {

         return createFileCache(null);

     }

     protected FileCache createFileCache(FileObject defaultsFile) throws IOException {

         return new FileCache(defaultsFile);

     }

     public WebslingerContainer getContainer() {

         return container;

     }

     public FileObject getServletFile() {

         return servletFile;

     }

     public String getType() throws IOException {

         return (String) getAttribute("type");

     }

     public abstract FileObject getFile() throws IOException;

     public abstract boolean exists() throws IOException;

     public abstract String getContentType() throws IOException;

     public boolean attributeExists(String name) throws IOException {

         return getObject().getAttributeInternal(name) != null;

     }

     public Object getAttribute(String name) throws IOException {

         return getObject().getAttributeInternal(name);

     }

     protected Object getAttributeInternal(String name) throws IOException {

         return getObject().getAttributeInternal(name);

     }

     public Map<String, ?> getDefaultAttributes() throws IOException {

         return getObject().getDefaultAttributes();

     }

     public String[] getSplitAttribute(String name) throws IOException {

         return getSplitAttribute(name, null);

     }

     public String[] getSplitAttribute(String name, String def) throws IOException {

         return getObject().getSplitAttribute(name, def);

     }

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

         return getObject().getAttributes();

     }

     public <T> T getCachedItem(Class owner, String name, Creator<T> creator) throws IOException, ServletException {

         try {

             return getObject().getItem(owner, name, creator);

         } catch (RuntimeException e) {

             throw e;

         } catch (IOException e) {

             throw e;

         } catch (ServletException e) {

             throw e;

         } catch (Exception e) {

             throw (ServletException) new ServletException(e.getMessage()).initCause(e);

         }

     }

     public String toString() {

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

     }

     public static abstract class FileInfoVFSDelegate<T extends FileInfo, C> extends VFSDelegateProxy<Object, T, Object, C> {

         protected FileInfoVFSDelegate(VFSDelegate<Object, Object, C> vfsDelegate) {

             super(vfsDelegate, Object.class);

         }

         protected Object getReal(FileInfo fi) throws IOException {

             throw new UnsupportedOperationException(getClass() + "|" + fi);

         }

         public FileInfo getId(FileInfo fi) throws IOException {

             return fi;

         }

         public String getString(FileInfo fi) throws IOException {

             return fi.getContainer().getWebslingerServletContext().getInvoker().convertToString(null, getReal(fi));

         }

         public InputStream getStream(FileInfo fi) throws IOException {

             return fi.getContainer().getWebslingerServletContext().getInvoker().convertToStream(null, getReal(fi));

         }

         public boolean attributeExists(FileInfo fi, String name) throws IOException {

             return fi.attributeExists(name);

         }

         public Object getAttribute(FileInfo fi, String name) throws IOException {

             return fi.getAttribute(name);

         }

     }

     protected class SplitAttributeTTLObject extends TTLObject<String[]> {

         protected final String name;

         protected final String def;

         protected SplitAttributeTTLObject(String name, String def) {

             this.name = name;

             this.def = def;

         }

         protected String[] load(String[] old) throws IOException {

             FileInfo.this.getObject();

             String value = (String) getAttribute(name);

             if (value == null) {

                 if (def == null) return null;

                 value = def;

             }

             return value.split("[, ]");

         }

     }

     protected class FileCache {

         private final ConcurrentHashMap<String, SplitAttributeTTLObject> splitCache = new ConcurrentHashMap<String, SplitAttributeTTLObject>();

         private final ConcurrentFreezableCache<ItemKey, Object> itemCache = new ConcurrentFreezableCache<ItemKey, Object>(FileInfo.class, "cache", null, ConcurrentFreezableCache.HARD) {

             protected Object createValue(Object id, ItemKey key) throws Exception {

                 return ((FreezableItemKey) id).createValue(key);

             }

         };

         public final FileObject defaultsFile;

         protected FileCache(FileObject defaultsFile) {

             this.defaultsFile = defaultsFile;

         }

         protected String[] getSplitAttribute(String name, String def) throws IOException {

             SplitAttributeTTLObject spliter = splitCache.get(name);

             if (spliter == null) {

                 spliter = new SplitAttributeTTLObject(name, def);

                 splitCache.put(name, spliter);

             }

             return spliter.getObject();

         }

         protected <T> T getItem(Class owner, String name, Creator<T> creator) throws Exception {

             return (T) itemCache.get(new FreezableItemKey<T>(owner, name, creator));

         }

         protected Object getAttributeInternal(String name) throws IOException {

             if (defaultsFile != null) {

                 //System.err.println("checking default(" + defaultsFile + ')');

                 if (defaultsFile.exists()) {

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

                 }

                 FileObject parent = defaultsFile.getParent();

                 //System.err.println("checking parent(" + parent + ')');

                 if (parent.exists()) return parent.getContent().getAttribute(name);

             }

             return null;

         }

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

             Map<String, ?> attributes = new HashMap<String, Object>();

             if (defaultsFile != null) {

                 FileObject parent = defaultsFile.getParent();

                 //System.err.println("checking parent(" + parent + ')');

                 if (parent.exists()) attributes.putAll(parent.getContent().getAttributes());

                 //System.err.println("checking default(" + defaultsFile + ')');

                 if (defaultsFile.exists()) attributes.putAll(defaultsFile.getContent().getAttributes());

             }

             return attributes;

         }

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

             return getDefaultAttributes();

         }

     }

     private static final class ItemKey {

         protected final Class owner;

         protected final String name;

         protected ItemKey(Class owner, String name) {

             this.owner = owner;

             this.name = name;

         }

         public int hashCode() {

             return hashCodeHelper(owner) ^ hashCodeHelper(name) ^ ItemKey.class.hashCode();

         }

         public boolean equals(Object o) {

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

             ItemKey other = (ItemKey) o;

             return equalsHelper(owner, other.owner) && equalsHelper(name, other.name);

         }

         public String toString() {

             return "ItemKey(" + owner + ":" + name + ")";

         }

     }

     private final class FreezableItemKey<T> implements Freezable<ItemKey> {

         private final ItemKey ik;

         private final Creator<T> creator;

         protected FreezableItemKey(Class owner, String name, Creator<T> creator) {

             this.ik = new ItemKey(owner, name);

             this.creator = creator;

         }

         public ItemKey freeze() {

             return ik;

         }

         protected T createValue(ItemKey key) throws Exception {

             return creator.createValue(FileInfo.this, ik.name);

         }

     }

     public interface Creator<V> {

         V createValue(FileInfo fi, String name) throws IOException, ServletException;

     }

     public static class ReadObjectCreator implements Creator<Object> {

         private final String typeAttribute;

         private final String defaultType;

         public ReadObjectCreator(String typeAttribute, String defaultType) {

             this.typeAttribute = typeAttribute;

             this.defaultType = defaultType;

         }

         public Object createValue(FileInfo fi, String name) throws IOException {

             String type = (String) fi.getAttribute(typeAttribute);

             if (type == null) type = defaultType;

             return IOUtil.readObject(type, fi.getFile().getContent().getInputStream());

         }

     }

 }