package org.webslinger.commons.vfs;

 import java.io.InputStream;

 import java.io.IOException;

 import java.net.URL;

 import java.security.CodeSource;

 import java.security.Permission;

 import java.security.PermissionCollection;

 import java.security.Permissions;

 import java.security.SecureClassLoader;

 import java.security.cert.Certificate;

 import java.util.Enumeration;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.Map;

 import java.util.Vector;

 import java.util.jar.Attributes;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileUtil;

 public class VFSClassLoader extends SecureClassLoader {

     protected final Map<FileObject, FileObject> files = new LinkedHashMap<FileObject, FileObject>();

     public VFSClassLoader(ClassLoader parent, FileObject file) throws FileSystemException {

         this(parent, new FileObject[] {file});

     }

     public VFSClassLoader(ClassLoader parent, FileObject[] files) throws FileSystemException {

         super(parent);

         addFiles(files);

     }

     protected FileObject createFileSystem(FileObject file) throws FileSystemException {

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

             return file.getFileSystem().getFileSystemManager().createFileSystem(file);

         } else {

             return file.getFileSystem().getFileSystemManager().createFileSystem("jar", file);

         }

     }

     public void addFiles(FileObject[] files) throws FileSystemException {

         synchronized (this.files) {

             for (FileObject file: files) {

                 this.files.put(file, createFileSystem(file));

             }

         }

     }

     public void addFile(FileObject file) throws FileSystemException {

         synchronized (files) {

             files.put(file, createFileSystem(file));

         }

     }

     public void removeFile(FileObject file) throws FileSystemException {

         synchronized (files) {

             files.remove(file);

         }

     }

     protected FileObject findFile(String name) throws FileSystemException {

         synchronized (files) {

             for (FileObject root: files.values()) {

                 FileObject file = root.resolveFile(name);

                 if (file.exists()) return file;

             }

         }

         return null;

     }

     protected void findFiles(String name, FileAcceptor acceptor) throws FileSystemException {

         synchronized (files) {

             for (FileObject root: files.values()) {

                 FileObject file = root.resolveFile(name);

                 if (file.exists() && acceptor.accept(file)) break;

             }

         }

     }

     protected Class findClass(String name) throws ClassNotFoundException {

         String fileName = name.replace('.', '/') + ".class";

         try {

             FileObject file = findFile(fileName);

             if (file == null) throw new ClassNotFoundException(name);

             Certificate[] certs = file.getContent().getCertificates();

             int pos = name.lastIndexOf('.');

             String packageName = pos != -1 ? name.substring(0, pos) : null;

             FileObject parent = file.getParent();

             Package pkg = getPackage(packageName);

             if (pkg != null) {

                 if (pkg.isSealed()) {

                     if (!pkg.isSealed(parent.getURL())) throw new ClassNotFoundException("redefine class in package that is sealed: " + name);

                 } else if (isSealed(parent)) {

                     throw new ClassNotFoundException("redefine sealed class in unsealed package: " + name);

                 }

             } else {

                 definePackage(packageName, parent);

             }

             CodeSource cs = new CodeSource(file.getFileSystem().getParentLayer().getURL(), certs);

             byte[] bytes = FileUtil.getContent(file);

             return defineClass(name, bytes, 0, bytes.length, cs);

         } catch (IOException e) {

             throw (ClassNotFoundException) new ClassNotFoundException(name).initCause(e);

         }

     }

     protected boolean isSealed(FileObject parent) throws FileSystemException {

         return "true".equalsIgnoreCase((String) parent.getContent().getAttribute(Attributes.Name.SEALED.toString()));

     }

     protected Package definePackage(String packageName, FileObject parent) throws FileSystemException {

         FileContent content = parent.getContent();

         String specTitle = (String) content.getAttribute(Attributes.Name.SPECIFICATION_TITLE.toString());

         String specVendor = (String) content.getAttribute(Attributes.Name.SPECIFICATION_VENDOR.toString());

         String specVersion = (String) content.getAttribute(Attributes.Name.SPECIFICATION_VERSION.toString());

         String implTitle = (String) content.getAttribute(Attributes.Name.IMPLEMENTATION_TITLE.toString());

         String implVendor = (String) content.getAttribute(Attributes.Name.IMPLEMENTATION_VENDOR.toString());

         String implVersion = (String) content.getAttribute(Attributes.Name.IMPLEMENTATION_VERSION.toString());

         URL sealBase = isSealed(parent) ? parent.getURL() : null;

         return definePackage(packageName, specTitle, specVersion, specVendor, implTitle, implVersion, implVendor, sealBase);

     }

     protected PermissionCollection getPermissions(CodeSource cs) {

         String url = cs.getLocation().toString();

         FileObject root = null;

         synchronized (files) {

             for (FileObject file: files.values()) {

                 root = file;

                 if (root.getName().getURI().equals(url)) break;

                 root = null;

             }

         }

         if (root == null) return super.getPermissions(cs);

         try {

             FileObject parent = root.getFileSystem().getParentLayer();

             if (parent == null) return super.getPermissions(cs);

             Permissions perms = new Permissions();

             addPermissions(perms, super.getPermissions(cs));

             do {

                 addPermissions(perms, super.getPermissions(new CodeSource(parent.getURL(), parent.getContent().getCertificates())));

                 parent = parent.getFileSystem().getParentLayer();

             } while (parent != null);

             return perms;

         } catch (FileSystemException e) {

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

         }

     }

     protected void addPermissions(PermissionCollection target, PermissionCollection source) {

         Enumeration<Permission> en = source.elements();

         while (en.hasMoreElements()) {

             target.add(en.nextElement());

         }

     }

     protected URL findResource(String name) {

         try {

             FileObject file = findFile(name);

             return file != null ? file.getURL() : null;

         } catch (FileSystemException e) {

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

         }

     }

     protected Enumeration<URL> findResources(String name) throws IOException {

         final Vector<URL> resources = new Vector<URL>();

         findFiles(

             name,

             new FileAcceptor() {

                 public boolean accept(FileObject file) throws FileSystemException {

                     resources.add(file.getURL());

                     return false;

                 }

             }

         );

         return resources.elements();

     }

     public InputStream getResourceAsStream(String name) {

         try {

             FileObject file = findFile(name);

             return file != null ? file.getContent().getInputStream() : null;

         } catch (FileSystemException e) {

             return null;

         }

     }

     protected interface FileAcceptor {

         boolean accept(FileObject file) throws FileSystemException;

     }

 }