package org.webslinger;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.net.URL;

 import java.net.URLConnection;

 import java.net.URLStreamHandler;

 import java.security.CodeSource;

 import java.security.SecureClassLoader;

 import java.security.cert.Certificate;

 import java.util.jar.Attributes;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.apache.commons.collections.CollectionUtils;

 import org.apache.commons.collections.iterators.IteratorEnumeration;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileSystemManager;

 import org.apache.commons.vfs.FileUtil;

 import org.codehaus.janino.ClassFileIClass;

 import org.codehaus.janino.ClassLoaderIClassLoader;

 import org.codehaus.janino.CompileException;

 import org.codehaus.janino.DebuggingInformation;

 import org.codehaus.janino.Descriptor;

 import org.codehaus.janino.IClass;

 import org.codehaus.janino.IClassLoader;

 import org.codehaus.janino.Java;

 import org.codehaus.janino.JavaSourceIClassLoader;

 import org.codehaus.janino.Parser;

 import org.codehaus.janino.Scanner;

 import org.codehaus.janino.UnitCompiler;

 import org.codehaus.janino.util.ClassFile;

 import org.codehaus.janino.util.enumerator.EnumeratorSet;

 import org.codehaus.janino.util.resource.Resource;

 import org.codehaus.janino.util.resource.ResourceFinder;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.commons.vfs.operations.AllFilesOperation;

 import org.webslinger.launcher.Instrumenter;

 import org.webslinger.launcher.Main;

 public class WebslingerClassLoader extends SecureClassLoader {

     protected EnumeratorSet debuggingInformation = DebuggingInformation.ALL;

     protected final IClassLoader iClassLoader = new WebslingerIClassLoader();

     protected final FileObject root;

     protected final FileObject src;

     protected final FileObject compiled;

     protected final List<FileObject> libs = new ArrayList<FileObject>();

     protected final HashSet<UnitCompiler> unitCompilers = new HashSet<UnitCompiler>();

     protected final Instrumenter instrumenter = Main.getInstrumenter();

     public WebslingerClassLoader(ClassLoader parent, FileObject root) throws IOException {

         super(parent);

         this.root = root;

         FileObject lib = root.resolveFile("Lib");

         libs.add(root.resolveFile("Classes"));

         FileSystemManager fsm = root.getFileSystem().getFileSystemManager();

         if (lib.getType().hasChildren()) {

             FileObject[] children = lib.getChildren();

             if (children != null) {

                 for (FileObject file: children) {

                     if (!JAR_FILTER.accept(lib, file, 0)) continue;

                     String baseName = file.getName().getBaseName();

                     if (baseName.startsWith(".") && file.getType().hasChildren()) continue;

                     if (fsm.canCreateFileSystem(file)) file = fsm.createFileSystem(file);

                     libs.add(file);

                 }

             }

         }

         src = root.resolveFile("Src");

         compiled = root.resolveFile("Var/Compiled");

     }

     protected URL findResource(String name) {

         try {

             FileObject file = findFile(name);

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

         } catch (FileSystemException e) {

             return null;

         }

     }

     protected Enumeration<URL> findResources(String name) {

         try {

             ArrayList<URL> urls = new ArrayList<URL>();

             List<FileObject> files = findFiles(name);

             for (FileObject file: files) {

                 AllFilesOperation op = VFSUtil.getOperation(file, AllFilesOperation.class);

                 if (op == null) {

                     urls.add(file.getURL());

                 } else {

                     urls.addAll(op.getAllURLs());

                 }

             }

             return new IteratorEnumeration(urls.iterator());

         } catch (FileSystemException e) {

             return null;

         }

     }

     protected FileObject resolveFile(FileObject base, String name) throws FileSystemException {

         FileObject file = base.resolveFile(name);

         return !file.exists() ? null : file;

     }

     protected void addFile(FileObject base, String name, List<FileObject> files) throws FileSystemException {

         FileObject file = base.resolveFile(name);

         if (file.exists()) files.add(file);

     }

     protected FileObject findCompiledFile(String name) throws FileSystemException {

         return resolveFile(compiled, name);

     }

     protected void addCompiledFile(String name, List<FileObject> files) throws FileSystemException {

         addFile(compiled, name, files);

     }

     protected FileObject findSrcFile(String name) throws FileSystemException {

         return resolveFile(src, name);

     }

     protected void addSrcFile(String name, List<FileObject> files) throws FileSystemException {

         addFile(src, name, files);

     }

     protected FileObject findLibFile(String name) throws FileSystemException {

         for (FileObject lib: libs) {

             FileObject file = resolveFile(lib, name);

             if (file != null) return file;

         }

         return null;

     }

     protected void addLibFiles(String name, List<FileObject> files) throws FileSystemException {

         for (FileObject lib: libs) {

             addFile(lib, name, files);

         }

     }

     protected FileObject findFile(String name) throws FileSystemException {

         FileObject file = findCompiledFile(name);

         if (file == null) file = findSrcFile(name);

         return file == null ? findLibFile(name) : file;

     }

     protected List<FileObject> findFiles(String name) throws FileSystemException {

         ArrayList<FileObject> files = new ArrayList<FileObject>();

         addCompiledFile(name, files);

         addSrcFile(name, files);

         addLibFiles(name, files);

         return files;

     }

     //protected abstract void findFiles(String name, List files) throws FileSystemException;

     protected FileObject getClassFile(String name, List certs) throws ClassNotFoundException, IOException {

         String baseName = name.replace('.', '/');

         String classFileName = baseName + ".class";

         int dollar = baseName.indexOf('$');

         String srcFileName = (dollar != -1 ? baseName.substring(0, dollar) : baseName) + ".java";

         FileObject certFile;

         FileObject srcFile = certFile = findSrcFile(srcFileName);

         FileObject classFile = findCompiledFile(classFileName);

         if (classFile == null) {

             if (srcFile != null) {

                 compile(name);

                 classFile = findCompiledFile(classFileName);

                 if (classFile == null) throw new ClassNotFoundException(srcFileName + " does not contain " + name);

             }

         } else {

             if (srcFile == null) {

                 classFile.delete();

                 classFile = null;

             } else if (srcFile.getContent().getLastModifiedTime() > classFile.getContent().getLastModifiedTime()) {

                 classFile.delete();

                 compile(name);

                 classFile = findCompiledFile(classFileName);

                 if (classFile == null) throw new ClassNotFoundException(srcFileName + " does not contain " + name);

             }

         }

         if (classFile == null) certFile = classFile = findLibFile(classFileName);

         if (classFile == null) return null;

         CollectionUtils.addAll(certs, certFile.getContent().getCertificates());

         return classFile;

     }

     protected Class findClass(String name) throws ClassNotFoundException {

         try {

             ArrayList<Certificate> certs = new ArrayList<Certificate>();

             FileObject classFile = getClassFile(name, certs);

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

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

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

             FileObject parent = classFile.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);

             }

             // FIXME: how to walk layered files, to find the real one

             FileObject parentLayer = classFile.getFileSystem().getParentLayer();

             CodeSource cs;

             if (parentLayer != null) {

                 cs = new CodeSource(parentLayer.getURL(), certs.toArray(new Certificate[certs.size()]));

             } else {

                 cs = null;

             }

             byte[] bytes = instrument(name, FileUtil.getContent(classFile));

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

         } catch (IOException e) {

             throw new ClassNotFoundException(name, e);

         }

     }

     protected byte[] instrument(String className, byte[] bytes) throws IOException {

         if (instrumenter == null || !className.startsWith("org.webslinger.")) return bytes;

         bytes = instrumenter.instrumentClass(bytes);

         return bytes;

     }

     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 void compile(String className) throws ClassNotFoundException, IOException {

         Map<String, byte[]> bytecodes = generateBytecodes(className);

         if (bytecodes == null) throw new ClassNotFoundException(className);

         for (Map.Entry<String, byte[]> entry: bytecodes.entrySet()) {

             String generatedClassName = entry.getKey();

             byte bytecode[] = entry.getValue();

             String generatedClassFileName = ClassFile.getClassFileResourceName(generatedClassName);

             String sourceName = ClassFile.getSourceResourceName(generatedClassName);

             FileObject tmpFile = compiled.resolveFile(generatedClassFileName);

             //FileObject tmpFile = compiled.resolveFile(generatedClassFileName + ".tmp");

             FileObject srcFile = src.resolveFile(sourceName);

             OutputStream os = null;

             try {

                 os = tmpFile.getContent().getOutputStream();

                 os.write(bytecode);

             } catch (IOException e) {

                 throw new ClassNotFoundException("Writing class file to \"" + generatedClassFileName + "\"", e);

             } finally {

                 if (os != null) { try { os.close(); } catch (IOException e) { } }

             }

             tmpFile.getContent().setLastModifiedTime(srcFile.getContent().getLastModifiedTime());

             //tmpFile.moveTo(compiled.resolveFile(generatedClassFileName));

         }

     }

     protected Map<String, byte[]> generateBytecodes(String name) throws ClassNotFoundException {

         if (iClassLoader.loadIClass(Descriptor.fromClassName(name)) == null) return null;

         Map<String, byte[]> bytecodes = new HashMap<String, byte[]>();

         Set<UnitCompiler> compiledUnitCompilers = new HashSet<UnitCompiler>();

 COMPILE_UNITS:

         for (;;) {

             Iterator<UnitCompiler> it = unitCompilers.iterator();

             while (it.hasNext()) {

                 UnitCompiler uc = it.next();

                 if (compiledUnitCompilers.contains(uc)) continue;

                 ClassFile cfs[];

                 try {

                     cfs = uc.compileUnit(debuggingInformation);

                 } catch (CompileException e) {

                     it.remove();

                     throw new ClassNotFoundException("Compiling unit \"" + uc + "\"", e);

                 }

                 for (ClassFile cf: cfs) {

                     bytecodes.put(cf.getThisClassName(), cf.toByteArray());

                 }

                 compiledUnitCompilers.add(uc);

                 continue COMPILE_UNITS;

             }

             return bytecodes;

         }

     }

     protected Class defineBytecodes(String name, Map<String, byte[]> bytecodes) {

         Class clazz = null;

         for (Map.Entry<String, byte[]> entry: bytecodes.entrySet()) {

             String compiledClassName = entry.getKey();

             byte bytes[] = entry.getValue();

             Class c = defineBytecode(compiledClassName, bytes);

             if (compiledClassName.equals(name)) clazz = c;

         };

         return clazz;

     }

     protected Class defineBytecode(String className, byte bytes[]) {

         try {

             bytes = instrument(className, bytes);

         } catch (IOException e) {

             e.printStackTrace();

             // ignore

         }

         return defineClass(className, bytes, 0, bytes.length);

     }

     protected interface Filter {

         boolean accept(FileObject base, FileObject file, int depth);

     }

     protected static final Filter JAR_FILTER = new Filter() {

         public boolean accept(FileObject base, FileObject file, int depth) {

             try {

                 if (file.getType().hasChildren()) return true;

             } catch (FileSystemException e) {

                 return false;

             }

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

             if (ext == null) return false;

             ext = ext.toLowerCase();

             return "jar".equals(ext) || "zip".equals(ext);

         }

     };

     protected class WebslingerIClassLoader extends IClassLoader {

         protected WebslingerIClassLoader() {

             super(new ClassLoaderIClassLoader(WebslingerClassLoader.this.getParent()));

             postConstruct();

         }

         protected IClass findIClass(String descriptor) throws ClassNotFoundException {

             String className = Descriptor.toClassName(descriptor);

             if (className.startsWith("java.")) return null;

             for (UnitCompiler uc: unitCompilers) {

                 IClass res = uc.findClass(className);

                 if (res == null) continue;

                 defineIClass(res);

                 return res;

             }

             String srcFileName = ClassFile.getSourceResourceName(className);

             try {

                 FileObject srcFile = findSrcFile(srcFileName);

                 if (srcFile != null) return parseSrcFile(srcFile, className);

             } catch (IOException e) {

             }

             String classFileName = ClassFile.getClassFileResourceName(className);

             try {

                 FileObject classFile = findLibFile(classFileName);

                 if (classFile != null) return parseClassFile(classFile);

             } catch (IOException e) {

             }

             return null;

         }

         protected IClass parseClassFile(FileObject classFile) throws ClassNotFoundException {

             // Open the class file resource.

             InputStream in;

             try {

                 in = classFile.getContent().getInputStream();

             } catch (IOException e) {

                 throw new ClassNotFoundException("Opening resource \"" + classFile + "\"", e);

             }

             // Load the IClass from the class file.

             ClassFile cf;

             try {

                 cf = new ClassFile(in);

             } catch (IOException e) {

                 e.printStackTrace();

                 throw new ClassNotFoundException("Reading resource \"" + classFile + "\"", e);

             } finally {

                 try { in.close(); } catch (IOException e) { }

             }

             IClass iClass = new ClassFileIClass(cf, this);

             defineIClass(iClass);

             return iClass;

         }

         protected IClass parseSrcFile(FileObject srcFile, String className) throws ClassNotFoundException {

             try {

                 // Scan and parse the source file.

                 InputStream inputStream = srcFile.getContent().getInputStream();

                 Java.CompilationUnit cu;

                 try {

                     Scanner scanner = new Scanner(srcFile.getName().getPath(), inputStream, null); //this.optionalCharacterEncoding);

                     //scanner.setWarningHandler(this.optionalWarningHandler);

                     Parser parser = new Parser(scanner);

                     //parser.setWarningHandler(this.optionalWarningHandler);

                     cu = parser.parseCompilationUnit();

                 } finally {

                     try { inputStream.close(); } catch (IOException e) { }

                 }

                 UnitCompiler uc = new UnitCompiler(cu, this);

                 //uc.setCompileErrorHandler(this.optionalCompileErrorHandler);

                 //uc.setWarningHandler(this.optionalWarningHandler);

                 // Remember compilation unit for later compilation.

                 unitCompilers.add(uc);

                 // Find the class/interface declaration in the com

                 IClass res = uc.findClass(className);

                 if (res == null) throw new Parser.ParseException("Source file \"" + srcFile.getName() + "\" does not declare class \"" + className + "\"", null);

                 defineIClass(res);

                 return res;

             } catch (CompileException e) {

                 throw new ClassNotFoundException("Parsing compilation unit \"" + srcFile + "\"", e);

             } catch (Scanner.ScanException e) {

                 throw new ClassNotFoundException("Parsing compilation unit \"" + srcFile + "\"", e);

             } catch (Parser.ParseException e) {

                 throw new ClassNotFoundException("Parsing compilation unit \"" + srcFile + "\"", e);

             } catch (IOException e) {

                 throw new ClassNotFoundException("Parsing compilation unit \"" + srcFile + "\"", e);

             }

         }

     }

 }