package org.webslinger.vfs;

 import java.io.File;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Map;

 import org.apache.commons.vfs.FileObject;

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

 import org.webslinger.lang.AtomicMap;

 public class TypeVFSDelegate extends VFSDelegate<Object, Object, Object> {

     public static final TypeVFSDelegate DEFAULT = new TypeVFSDelegate();

     protected final AtomicMap<Class<?>, VFSDelegate<?, ?, ?>> delegates = new AtomicMap<Class<?>, VFSDelegate<?, ?, ?>>();

     protected final Resolver resolver;

     public TypeVFSDelegate() {

         this(null);

     }

     public TypeVFSDelegate(Resolver resolver) {

         this.resolver = resolver;

         addVFSDelegate(File.class, new FileVFSDelegate());

         addVFSDelegate(String.class, new StringVFSDelegate());

         CommonsVfsFileObjectVFSDelegate vfsVFSDelegate = new CommonsVfsFileObjectVFSDelegate();

         addVFSDelegate(FileObject.class, vfsVFSDelegate);

         addVFSDelegate(DelegateFileObject.class, vfsVFSDelegate);

     }

     public Resolver getResolver() {

         return resolver;

     }

     public <T> void addVFSDelegate(Class<T> type, VFSDelegate<?, ? super T, ?> delegate) {

         delegates.put(type, delegate);

     }

     public void removeVFSDelegate(Class<?> type) {

         delegates.remove(type);

     }

     public <T> VFSDelegate<?, T, ?> getVFSDelegate(Class<? extends T> type) throws IOException {

         VFSDelegate<?, T, ?> delegate = getVFSDelegateInternal(delegates.map(), type);

         //System.err.println("getVFSDelegate(" + type + ")=" + delegate);

         if (delegate != null) return delegate;

         throw new IOException("no delegate for: " + type + " -> " + delegates.map().keySet());

     }

     private <T> VFSDelegate<?, T, ?> getVFSDelegateInternal(Map<Class<?>, VFSDelegate<?, ?, ?>> delegates, Class<? extends T> type) throws IOException {

         if (type == null) return null;

         VFSDelegate delegate = delegates.get(type);

         if (delegate == null) {

             delegate = getVFSDelegateInternal(delegates, type.getSuperclass());

             if (delegate == null) {

                 for (Class<?> intf: type.getInterfaces()) {

                     delegate = getVFSDelegateInternal(delegates, intf);

                     if (delegate != null) break;

                 }

             }

         }

         return delegate;

     }

     public Object getId(Object id) throws IOException {

         return doGetId(id.getClass(), id);

     }

     private <T> Object doGetId(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getId(type.cast(id));

     }

     public Type getType(Object id) throws IOException {

         return doGetType(id.getClass(), id);

     }

     private <T> Type doGetType(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getType(type.cast(id));

     }

     public long getLastModifiedTime(Object id) throws IOException {

         return doGetLastModifiedTime(id.getClass(), id);

     }

     private <T> long doGetLastModifiedTime(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getLastModifiedTime(type.cast(id));

     }

     public Collection<Permission> getPermissions(Object id) throws IOException {

         return doGetPermissions(id.getClass(), id);

     }

     private <T> Collection<Permission> doGetPermissions(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getPermissions(type.cast(id));

     }

     public String absolutePath(Object id) throws IOException {

         return doAbsolutePath(id.getClass(), id);

     }

     private <T> String doAbsolutePath(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).absolutePath(type.cast(id));

     }

     public String getBaseName(Object id) throws IOException {

         return doGetBaseName(id.getClass(), id);

     }

     private <T> String doGetBaseName(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getBaseName(type.cast(id));

     }

     public Object getParent(Object id) throws IOException {

         return doGetParent(id.getClass(), id);

     }

     private <T> Object doGetParent(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getParent(type.cast(id));

     }

     public Object resolve(Object id, String name) throws IOException {

         return doResolve(id.getClass(), id, name);

     }

     private <T> Object doResolve(Class<T> type, Object id, String name) throws IOException {

         VFSDelegate<?, T, ?> delegate = id != null ? getVFSDelegate(type) : null;

         if (delegate != null) return delegate.resolve(type.cast(id), name);

         Resolver resolver = getResolver();

         return resolver != null ? resolver.resolve(name) : null;

     }

     public Object[] getChildren(Object id) throws IOException {

         return doGetChildren(id.getClass(), id);

     }

     private <T> Object[] doGetChildren(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getChildren(type.cast(id));

     }

     public boolean attributeExists(Object id, String name) throws IOException {

         return doAttributeExists(id.getClass(), id, name);

     }

     private <T> boolean doAttributeExists(Class<T> type, Object id, String name) throws IOException {

         return getVFSDelegate(type).attributeExists(type.cast(id), name);

     }

     public Object getAttribute(Object id, String name) throws IOException {

         return doGetAttribute(id.getClass(), id, name);

     }

     private <T> Object doGetAttribute(Class<T> type, Object id, String name) throws IOException {

         return getVFSDelegate(type).getAttribute(type.cast(id), name);

     }

     public String getContentType(Object id) throws IOException {

         return doGetContentType(id.getClass(), id);

     }

     private <T> String doGetContentType(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getContentType(type.cast(id));

     }

     public long getLength(Object id) throws IOException {

         return doGetLength(id.getClass(), id);

     }

     private <T> long doGetLength(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getLength(type.cast(id));

     }

     public String getString(Object id) throws IOException {

         return doGetString(id.getClass(), id);

     }

     private <T> String doGetString(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).getString(type.cast(id));

     }

     public InputStream openInput(Object id) throws IOException {

         return doOpenInput(id.getClass(), id);

     }

     private <T> InputStream doOpenInput(Class<T> type, Object id) throws IOException {

         return getVFSDelegate(type).openInput(type.cast(id));

     }

     public OutputStream openOutput(Object id, boolean append) throws IOException {

         return doOpenOutput(id.getClass(), id, append);

     }

     private <T> OutputStream doOpenOutput(Class<T> type, Object id, boolean append) throws IOException {

         return getVFSDelegate(type).openOutput(type.cast(id), append);

     }

     public RandomAccess openRandom(Object id, boolean read) throws IOException {

         return doOpenRandom(id.getClass(), id, read);

     }

     private <T> RandomAccess doOpenRandom(Class<T> type, Object id, boolean read) throws IOException {

         return getVFSDelegate(type).openRandom(type.cast(id), read);

     }

     public interface Resolver {

         Object resolve(String name) throws IOException;

     }

 }