/*

  * To change this license header, choose License Headers in Project Properties.

  * To change this template file, choose Tools | Templates

  * and open the template in the editor.

  */

 package org.apidesign.bck2brwsr.dew;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.EnumSet;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.zip.ZipEntry;

 import java.util.zip.ZipFile;

 import javax.tools.FileObject;

 import javax.tools.JavaFileManager;

 import javax.tools.JavaFileObject;

 import javax.tools.StandardLocation;

 /**

  *

  * @author Tomas Zezula

  */

 public class ClassLoaderFileManager implements JavaFileManager {

     private static final Location[] READ_LOCATIONS = {

         StandardLocation.PLATFORM_CLASS_PATH,

         StandardLocation.CLASS_PATH,

         StandardLocation.SOURCE_PATH

     };

     private static final Location[] WRITE_LOCATIONS = {

         StandardLocation.CLASS_OUTPUT,

         StandardLocation.SOURCE_OUTPUT

     };

     private static final Location[] CLASS_LOADER_LOCATIONS = {

         StandardLocation.ANNOTATION_PROCESSOR_PATH

     };

     private Map<Location, Map<String,List<MemoryFileObject>>> generated;

     ClassLoaderFileManager() {

         generated = new HashMap<>();

         for (Location l : WRITE_LOCATIONS) {

             generated.put(l, new HashMap<String, List<MemoryFileObject>>());

         }

     }

     @Override

     public ClassLoader getClassLoader(Location location) {

         if (canClassLoad(location)) {

             return getClass().getClassLoader();

         } else {

             return null;

         }

     }

     @Override

     public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {

         if (canRead(location)) {

             final List<JavaFileObject> res = new ArrayList<JavaFileObject>();

             for (String resource : getResources(convertFQNToResource(packageName))) {

                 final JavaFileObject jfo = new ClassLoaderJavaFileObject(resource);

                 if (kinds.contains(jfo.getKind())) {

                     res.add(jfo);

                 }

             }

             return res;

         } else if (canWrite(location)) {

             Map<String,List<MemoryFileObject>> folders = generated.get(location);

             List<MemoryFileObject> files = folders.get(convertFQNToResource(packageName));

             if (files != null) {

                 final List<JavaFileObject> res = new ArrayList<JavaFileObject>();

                 for (JavaFileObject file : files) {

                     if (kinds.contains(file.getKind()) && file.getLastModified() >= 0) {

                         res.add(file);

                     }

                 }

                 return res;

             }

         }

         return Collections.<JavaFileObject>emptyList();

     }

     @Override

     public String inferBinaryName(Location location, JavaFileObject file) {

         return ((InferableJavaFileObject)file).infer();

     }

     @Override

     public boolean isSameFile(FileObject a, FileObject b) {

         return a.toUri().equals(b.toUri());

     }

     @Override

     public boolean handleOption(String current, Iterator<String> remaining) {

         return false;

     }

     @Override

     public boolean hasLocation(Location location) {

         for (Location l : StandardLocation.values()) {

             if (l.equals(location)) {

                 return true;

             }

         }

         return false;

     }

     @Override

     public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {

         if (canRead(location)) {

             return new ClassLoaderJavaFileObject(convertFQNToResource(className) + kind.extension);

         } else {

             throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N

         }

     }

     @Override

     public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {

         if (canWrite(location)) {

             final String resource = convertFQNToResource(className) + kind.extension;

             final MemoryFileObject res = new MemoryFileObject(resource, null);

             register(location, resource, res);

             return res;

         } else {

             throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N

         }

     }

     @Override

     public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {

         if (canRead(location)) {

             return new ClassLoaderJavaFileObject(convertFQNToResource(packageName) + '/' + relativeName); //NOI18N

         } else {

             throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N

         }

     }

     @Override

     public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {

         if (canWrite(location)) {

             final String resource = convertFQNToResource(packageName) + '/' + relativeName; //NOI18N

             final MemoryFileObject res = new MemoryFileObject(resource, null);

             register(location, resource, res);

             return res;

         } else {

             throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N

         }

     }

     @Override

     public void flush() throws IOException {

     }

     @Override

     public void close() throws IOException {        

     }

     @Override

     public int isSupportedOption(String option) {

         return -1;

     }

 //    private List<String> getResources(String folder) throws IOException {

 //        final List<String> result = new ArrayList<String>();

 //        final BufferedReader in = new BufferedReader(new InputStreamReader(

 //                this.getClass().getClassLoader().getResourceAsStream(String.format("%s/pkg-list", folder.substring(0))),    //NOI18N

 //                "UTF-8"));  //NOI18N

 //        try {

 //            String line;

 //            while ((line = in.readLine()) != null) {

 //                result.add(line);

 //            }

 //        } finally {

 //            in.close();

 //        }

 //        return result;

 //    }

     //MOCK IMPL

     private List<String> getResources(String folder) throws IOException {

         if (classPathContent == null) {

             classPathContent = new HashMap<>();

 //            final String boot = System.getProperty("sun.boot.class.path");  //NOI18N

             final String cp = System.getProperty("java.class.path");

             for (String entry : cp.split(File.pathSeparator)) {

                 File f = new File (entry);

                 if (f.canRead()) {

                     if (f.isFile()) {

                         ZipFile zf = new ZipFile(f);

                         try {

                             Enumeration<? extends ZipEntry> entries = zf.entries();

                             while (entries.hasMoreElements()) {

                                 ZipEntry e = entries.nextElement();

                                 if (e.isDirectory()) {

                                     continue;

                                 }

                                 final String name = String.format("/%s",e.getName());

                                 final String owner = getOwner(name);

                                 List<String> content = classPathContent.get(owner);

                                 if (content == null) {

                                     content = new ArrayList<>();

                                     classPathContent.put(owner, content);

                                 }

                                 content.add(name);

                             }

                         } finally {

                             zf.close();

                         }

                     } else if (f.isDirectory()) {

                         addFiles(f,"/", classPathContent);

                     }

                 }

             }                                    

         }

         List<String> content = classPathContent.get(folder);

         return content == null ? Collections.<String>emptyList() : content;

     }

     private void addFiles(File folder, String path, Map<String,List<String>> into) {

         for (File f : folder.listFiles()) {

             String fname = path + (path.length() == 1 ? "" : "/") +  f.getName();

             if (f.isDirectory()) {

                 addFiles(f, fname, into);

             } else {

                 List<String> content = into.get(path);

                 if (content == null) {

                     content = new ArrayList<>();

                     classPathContent.put(path, content);

                 }

                 content.add(fname);

             }

         }

     }

     private Map<String,List<String>> classPathContent;

     private void register(Location loc, String resource, MemoryFileObject jfo) {

         Map<String,List<MemoryFileObject>> folders = generated.get(loc);

         final String folder = getOwner(resource);

         List<MemoryFileObject> content = folders.get(folder);

         if (content == null) {

             content = new ArrayList<>();

             folders.put(folder, content);

         }

         content.add(jfo);

     }

     private static String getOwner(String resource) {

         int lastSlash = resource.lastIndexOf('/');

         assert lastSlash >= 0;

         return resource.substring(0, lastSlash);

     }

     private static boolean canRead(Location loc) {

         for (Location rl : READ_LOCATIONS) {

             if (rl.equals(loc)) {

                 return true;

             }

         }

         return false;

     }

     private static boolean canWrite(Location loc) {

         for (Location wl : WRITE_LOCATIONS) {

             if (wl.equals(loc)) {

                 return true;

             }

         }

         return false;

     }

     private static boolean canClassLoad(Location loc) {

         for (Location cll : CLASS_LOADER_LOCATIONS) {

             if (cll.equals(loc)) {

                 return true;

             }

         }

         return false;

     }

     static String convertFQNToResource(String fqn) {

         return '/' + fqn.replace('.', '/');   //NOI18N

     }

     static String convertResourceToFQN(String resource) {

         assert resource.startsWith("/");    //NOI18N

         int lastSlash = resource.lastIndexOf('/');  //NOI18N

         int lastDot = resource.lastIndexOf('.');    //NOI18N

         int stop = lastSlash < lastDot ?

             lastDot :

             resource.length();

         return resource.substring(1, stop).replace('/', '.');    //NOI18N

     }

     JavaFileObject createMemoryFileObject (String resourceName, JavaFileObject.Kind kind, byte[] content) {

         final InferableJavaFileObject jfo  = new MemoryFileObject(resourceName, kind, content);

         return jfo;

     }

     Iterable<? extends MemoryFileObject> getGeneratedFiles(JavaFileObject.Kind... kinds) {

         final Set<JavaFileObject.Kind> ks = EnumSet.noneOf(JavaFileObject.Kind.class);

         Collections.addAll(ks, kinds);

         final List<MemoryFileObject> res = new ArrayList<>();

         for (Map<String,List<MemoryFileObject>> folders : generated.values()) {

             for (List<MemoryFileObject> content : folders.values()) {

                 for (MemoryFileObject fo : content) {

                     if (ks.contains(fo.getKind()) && fo.getLastModified() >= 0) {

                         res.add(fo);

                     }

                 }

             }

         }

         return res;

     }

 }