package org.webslinger.commons.vfs.virtual;

 import java.io.FileNotFoundException;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.LinkedHashSet;

 import java.util.Map;

 import java.util.Set;

 import java.util.SortedMap;

 import java.util.TreeMap;

 import java.util.concurrent.ConcurrentMap;

 import java.util.concurrent.atomic.AtomicReference;

 import org.apache.commons.vfs.Capability;

 import org.apache.commons.vfs.FileChangeEvent;

 import org.apache.commons.vfs.FileListener;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystem;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileSystemOptions;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.NameScope;

 import org.apache.commons.vfs.events.AbstractFileChangeEvent;

 import org.apache.commons.vfs.events.ChangedEvent;

 import org.apache.commons.vfs.events.CreateEvent;

 import org.apache.commons.vfs.events.DeleteEvent;

 import org.webslinger.commons.vfs.FileSet;

 import org.webslinger.commons.vfs.FileSystemAndNameKey;

 import org.webslinger.commons.vfs.GenerationalFileObject;

 import org.webslinger.commons.vfs.GenerationalFileSystem;

 import org.webslinger.commons.vfs.handlers.HandlerFactory;

 import org.webslinger.commons.vfs.handlers.cow.COWStorageHandler;

 import org.webslinger.lang.ConcurrentUtil;

 public class VirtualFileSystem extends GenerationalFileSystem<FileName, VirtualFileObject, VirtualFileSystem.VirtualResolution, VirtualFileSystem> {

     private final static Collection<Capability> capabilities = Collections.unmodifiableCollection(

         Arrays.asList(

             new Capability[] {

                 Capability.READ_CONTENT,

                 Capability.WRITE_CONTENT,

                 Capability.RANDOM_ACCESS_READ,

                 Capability.RANDOM_ACCESS_WRITE,

                 Capability.APPEND_CONTENT,

                 Capability.LAST_MODIFIED,

                 Capability.GET_LAST_MODIFIED,

                 Capability.SET_LAST_MODIFIED_FILE,

                 Capability.SET_LAST_MODIFIED_FOLDER,

                 // last modified?

                 Capability.CREATE,

                 Capability.DELETE,

                 Capability.RENAME,

                 Capability.LIST_CHILDREN,

                 Capability.DISPATCHER,

                 Capability.JUNCTIONS,

             }

         )

     );

     protected final SortedMap<FileName, MountPoint> mounts = ConcurrentUtil.createSortedMap();

     protected COWStorageHandler storageHandler;

     public VirtualFileSystem(FileName name, FileSystemOptions options) throws FileSystemException {

         super(name, null, options);

         newGeneration();

     }

     protected int newGeneration() {

         return super.newGeneration();

     }

     protected COWStorageHandler getStorageHandler() throws FileSystemException {

         if (storageHandler != null) return storageHandler;

         HandlerFactory<COWStorageHandler, VirtualFileSystem> factory = VirtualConfigBuilder.getInstance().getStorageHandlerFactory(getFileSystemOptions());

         if (factory != null) storageHandler = factory.getHandler(this, COWStorageHandler.class);

         if (storageHandler == null) storageHandler = COWStorageHandler.EmptyStorageHandler;

         return storageHandler;

     }

     public void addCapabilities(Collection caps) {

         caps.addAll(capabilities);

     }

     public FileObject createFile(FileName name) throws FileSystemException {

         return new VirtualFileObject(name, this);

     }

     public boolean clear(FileName name) throws FileSystemException {

         getStorageHandler().submitRequests(name, new COWStorageHandler.ClearRequest());

         MountPoint oldPoint, newPoint;

 OUTER:

         do {

             oldPoint = mounts.get(name);

             if (oldPoint == null) return false;

             newPoint = oldPoint.clear();

             if (newPoint == null) {

                 if (((ConcurrentMap) mounts).remove(name, oldPoint)) break;

                 continue OUTER;

             } else if (newPoint == oldPoint) {

                 return false;

             }

         } while (!((ConcurrentMap) mounts).replace(name, oldPoint, newPoint));

         newGeneration();

         updateListeners(name);

         return true;

     }

     public void addJunction(String path, FileObject file) throws FileSystemException {

         FileName name = resolveFile(path).getName();

         MountPoint oldPoint, newPoint;

 OUTER:

         do {

             oldPoint = mounts.get(name);

             if (oldPoint == null) {

                 newPoint = newMountPoint(name, file, null);

                 if (((ConcurrentMap) mounts).putIfAbsent(name, newPoint) == null) break;

                 continue OUTER;

             } else {

                 newPoint = oldPoint.setMount(file);

             }

         } while (!((ConcurrentMap) mounts).replace(name, oldPoint, newPoint));

         newGeneration();

         updateListeners(name);

     }

     public boolean addBase(FileName name, String relative) throws FileSystemException {

         VirtualFileObject file = resolveFile(getFileSystemManager().resolveName(name.getParent(), relative));

         relative = name.getParent().getRelativeName(file.getName());

         getStorageHandler().submitRequests(name, new COWStorageHandler.AddBaseRequest(relative));

         MountPoint oldPoint, newPoint;

 OUTER:

         do {

             oldPoint = mounts.get(name);

             if (oldPoint == null) {

                 newPoint = newMountPoint(name, null, file);

                 if (((ConcurrentMap) mounts).putIfAbsent(name, newPoint) == null) break;

                 continue OUTER;

             } else {

                 newPoint = oldPoint.addBase(file);

             }

         } while (!((ConcurrentMap) mounts).replace(name, oldPoint, newPoint));

         newGeneration();

         updateListeners(name);

         return true;

     }

     public void removeJunction(String path) throws FileSystemException {

         FileName name = resolveFile(path).getName();

         TreeMap<String, FileObject> oldMounts, newMounts;

         MountPoint oldPoint, newPoint;

         do {

             oldPoint = mounts.get(name);

             if (oldPoint == null || oldPoint.mount == null) return;

             newPoint = oldPoint.removeMount();

         } while (!((ConcurrentMap) mounts).replace(name, oldPoint, newPoint));

         newGeneration();

         updateListeners(name);

     }

     public boolean removeBase(FileName name, String relative) throws FileSystemException {

         VirtualFileObject file = resolveFile(getFileSystemManager().resolveName(name.getParent(), relative));

         relative = name.getParent().getRelativeName(file.getName());

         getStorageHandler().submitRequests(name, new COWStorageHandler.RemoveBaseRequest(relative));

         MountPoint oldPoint, newPoint;

         do {

             oldPoint = mounts.get(name);

             if (oldPoint == null) return false;

             newPoint = oldPoint.removeBase(file);

             if (newPoint == null) return false;

         } while (!((ConcurrentMap) mounts).replace(name, oldPoint, newPoint));

         newGeneration();

         updateListeners(name);

         return true;

     }

     protected MountPoint setDeleted(FileName name, boolean isDeleted, boolean newGeneration) throws FileSystemException {

         getStorageHandler().submitRequests(name, new COWStorageHandler.SetDeletedRequest(isDeleted));

         MountPoint oldPoint, newPoint;

 OUTER:

         do {

             oldPoint = mounts.get(name);

             if (oldPoint == null) {

                 if (!isDeleted) return null;

                 newPoint = newMountPoint(name, isDeleted, null);

                 if (((ConcurrentMap) mounts).putIfAbsent(name, newPoint) == null) break;

                 continue OUTER;

             } else {

                 newPoint = oldPoint.setDeleted(isDeleted);

             }

         } while (!((ConcurrentMap) mounts).replace(name, oldPoint, newPoint));

         if (oldPoint != null) oldPoint.valid = false;

         if (newGeneration) newGeneration();

         updateListeners(name);

         return newPoint;

     }

     protected VirtualResolution newResolution(int generation, VirtualFileObject genFile) throws FileSystemException {

         VirtualFileObject ptr = genFile;

         ArrayList<FileLookup> resolvedFiles = new ArrayList<FileLookup>();

         FileObject foundJunction = null;

         MountPoint foundFiles = getMounts(ptr.getName());

         boolean isDeleted = foundFiles != null && foundFiles.isDeleted;

         do {

             if (foundFiles != null) {

                 resolvedFiles.addAll(Arrays.asList(foundFiles.bases));

                 if (foundFiles.mount != null) foundJunction = foundFiles.mount;

             }

             String namePart = ptr.getName().getBaseName();

             if (namePart.equals("/")) break;

             ptr = ptr.getParent();

             if (ptr == null) break;

             VirtualResolution resolution = ptr.getResolution();

             if (foundJunction == null && resolution.mount != null) foundJunction = resolution.mount.resolveFile(namePart);

             for (FileLookup base: resolution.bases) {

                 resolvedFiles.add(new ChildFileLookup(base, namePart));

             }

         } while (false);

         Collections.reverse(resolvedFiles);

         return new VirtualResolution(generation, resolvedFiles.toArray(new FileLookup[resolvedFiles.size()]), genFile, foundJunction, foundFiles);

     }

     protected FileObject findMounted(FileName dir, String name) throws FileSystemException {

         FileName tmpName = getFileSystemManager().resolveName(dir, name, NameScope.CHILD);

         MountPoint tmpPoint = mounts.get(tmpName);

         if (tmpPoint != null) return tmpPoint.mount;

         return resolveFile(dir).getResolution().mount.resolveFile(name);

     }

     protected VirtualFileObject[] newArray(int length) {

         return new VirtualFileObject[length];

     }

     protected MountPoint getMounts(FileName name) throws FileSystemException {

         while (true) {

             MountPoint point = mounts.get(name);

             if (point != null) return point;

             boolean[] isDeleted = new boolean[1];

             StandardFileLookup[] bases = loadData(name, null, isDeleted);

             if (bases == null) return null;

             MountPoint newPoint = new MountPoint(name, null, isDeleted[0], bases);

             if (((ConcurrentMap) mounts).putIfAbsent(name, newPoint) == null) return newPoint;

         }

     }

     protected int addMountedChildren(FileName startName, Collection<String> names) throws FileSystemException {

         String start = startName.getPath();

         int prefixLength = start.length();

         while (prefixLength > 0 && start.charAt(prefixLength - 1) == FileName.SEPARATOR_CHAR) prefixLength--;

         int nameStart = prefixLength + 1;

         int count = 0;

         for (Map.Entry<FileName, MountPoint> entry: mounts.tailMap(startName).entrySet()) {

             FileName name = entry.getKey();

             MountPoint point = entry.getValue();

             String path = name.getPath();

             //System.err.println("[" + start + "](" + prefixLength + "." + nameStart + ") [" + path + "]." + path.length());

             if (!path.startsWith(start) || path.length() < prefixLength) break;

             if (path.length() <= nameStart) continue;

             if (path.charAt(prefixLength) != FileName.SEPARATOR_CHAR) continue;

             if (point.isDeleted) continue;

             // Means no virtual access

             if (point.mount == null && point.bases.length == 0) continue;

             int slash = path.indexOf(FileName.SEPARATOR_CHAR, nameStart);

             if (slash == -1) {

                 names.add(path.substring(nameStart));

             } else {

                 names.add(path.substring(nameStart, slash));

             }

             count++;

         }

         return count;

     }

     protected FileSet getRealFiles(VirtualFileObject file) throws FileSystemException {

         return createFileSet(new FileObject[] {file.getFile()}, new FileObject[0]);

     }

     protected interface FileLookup {

         VirtualFileObject lookupFile() throws FileSystemException;

         void refresh() throws FileSystemException;

     }

     protected static class StandardFileLookup implements FileLookup {

         protected final VirtualFileObject file;

         protected StandardFileLookup(VirtualFileObject file) {

             this.file = file;

         }

         public VirtualFileObject lookupFile() throws FileSystemException {

             return file;

         }

         public void refresh() throws FileSystemException {

             VirtualFileObject file = lookupFile();

             if (file != null) file.refresh();

         }

     }

     protected static class ChildFileLookup implements FileLookup {

         protected final FileLookup lookup;

         protected final String childName;

         protected ChildFileLookup(FileLookup lookup, String childName) {

             this.lookup = lookup;

             this.childName = childName;

         }

         public VirtualFileObject lookupFile() throws FileSystemException {

             VirtualFileObject base = lookup.lookupFile();

             if (base == null) return null;

             return base.getChild(childName);

         }

         public void refresh() throws FileSystemException {

             VirtualFileObject base = lookup.lookupFile();

             if (base == null) return;

             VirtualFileObject file = base.getChild(childName);

             (file != null ? file : base).refresh();

         }

     }

     protected StandardFileLookup[] loadData(FileName name, VirtualFileObject givenBase, boolean[] isDeleted) throws FileSystemException {

         ArrayList<StandardFileLookup> lookups = new ArrayList<StandardFileLookup>();

         boolean foundGivenBase = false;

         Collection<String> bases = getStorageHandler().loadData(name, isDeleted);

         if (bases == null) return null;

         for (String relative: bases) {

             VirtualFileObject base = resolveFile(getFileSystemManager().resolveName(name.getParent(), relative));

             if (base == givenBase) foundGivenBase = true;

             lookups.add(new StandardFileLookup(base));

         }

         if (!foundGivenBase && givenBase != null) lookups.add(new StandardFileLookup(givenBase));

         if (lookups.isEmpty() && !isDeleted[0]) return null;

         return lookups.toArray(new StandardFileLookup[lookups.size()]);

     }

     protected MountPoint newMountPoint(FileName name, FileObject mount, VirtualFileObject givenBase) throws FileSystemException {

         boolean[] isDeleted = new boolean[1];

         StandardFileLookup[] bases = loadData(name, givenBase, isDeleted);

         return new MountPoint(name, mount, isDeleted[0], bases != null ? bases : new StandardFileLookup[0]);

     }

     protected MountPoint newMountPoint(FileName name, boolean isDeleted, VirtualFileObject givenBase) throws FileSystemException {

         boolean[] isDeletedLoad = new boolean[1];

         StandardFileLookup[] bases = loadData(name, givenBase, isDeletedLoad);

         return new MountPoint(name, null, isDeleted, bases != null ? bases : new StandardFileLookup[0]);

     }

     private static final void addChildNames(Collection<String> names, FileObject[] children) {

         if (children == null) return;

         for (FileObject child: children) {

             names.add(child.getName().getBaseName());

         }

     }

     protected final static class MountPoint {

         protected final FileName name;

         protected boolean isDeleted;

         protected final FileObject mount;

         protected final StandardFileLookup[] bases;

         protected boolean valid = true;

         protected MountPoint(FileName name, FileObject mount, boolean isDeleted, StandardFileLookup[] bases) {

             this.name = name;

             this.mount = mount;

             this.isDeleted = isDeleted;

             this.bases = bases;

         }

         protected MountPoint setMount(FileObject mount) throws FileSystemException {

             if (this.mount != null) throw new FileSystemException("Already mounted(" + name + ")");

             return new MountPoint(name, mount, isDeleted, bases);

         }

         protected MountPoint removeMount() {

             if (mount == null) return null;

             return new MountPoint(name, null, isDeleted, bases);

         }

         protected MountPoint setDeleted(boolean isDeleted) {

             if (this.isDeleted == isDeleted) return this;

             return new MountPoint(name, mount, isDeleted, bases);

         }

         protected MountPoint addBase(VirtualFileObject base) {

             if (bases == null) return new MountPoint(name, mount, isDeleted, new StandardFileLookup[] {new StandardFileLookup(base)});

             StandardFileLookup[] bases = new StandardFileLookup[this.bases.length + 1];

             System.arraycopy(this.bases, 0, bases, 0, this.bases.length);

             bases[this.bases.length] = new StandardFileLookup(base);

             return new MountPoint(name, mount, isDeleted, bases);

         }

         protected MountPoint removeBase(VirtualFileObject base) {

             for (int i = 0; i < bases.length; i++) {

                 if (bases[i].file.equals(base)) {

                     StandardFileLookup[] bases = new StandardFileLookup[this.bases.length - 1];

                     System.arraycopy(this.bases, 0, bases, 0, i);

                     System.arraycopy(this.bases, i + 1, bases, 0, bases.length - i);

                     return new MountPoint(name, mount, isDeleted, bases);

                 }

             }

             return null;

         }

         protected MountPoint clear() {

             if (mount == null) return null;

             if (!isDeleted && bases.length == 0) return this;

             return new MountPoint(name, mount, false, new StandardFileLookup[0]);

         }

     }

     public class VirtualResolution extends GenerationalFileSystem.Resolution<FileName, VirtualFileObject, VirtualResolution, VirtualFileSystem> {

         public final FileLookup[] bases;

         public final FileObject mount;

         protected MountPoint point;

         protected VirtualResolution(int generation, FileLookup[] bases, VirtualFileObject owner, FileObject mount, MountPoint point) throws FileSystemException {

             super(generation, owner);

             this.bases = bases;

             this.mount = mount;

             for (FileLookup base: bases) base.refresh();

             if (mount != null) mount.refresh();

             this.point = point;

         }

         protected boolean isDeleted() throws FileSystemException {

             if (point == null) return false;

             if (!point.valid) point = getMounts(file.getName());

             return point.isDeleted;

         }

         protected boolean isWriteable() {

             return mount != null;

         }

         protected boolean refresh() throws FileSystemException {

             for (FileLookup base: bases) base.refresh();

             if (mount != null) mount.refresh();

             return super.refresh();

         }

         protected boolean isOutOfDate(boolean create) throws FileSystemException {

             return false;

         }

         protected FileObject doGetFile(boolean create) throws FileSystemException {

             if (create) {

                 if (mount == null) throw new IllegalArgumentException("No mount found for " + file.getName());

                 if (isDeleted()) point = setDeleted(file.getName(), false, false);

                 return mount;

             }

             if (isDeleted()) return null;

             if (mount != null && mount.exists()) return mount;

             for (FileLookup lookup: bases) {

                 VirtualFileObject base = lookup.lookupFile();

                 if (base == null) continue;

                 if (getResolution(base, false).isDeleted()) return null;

                 if (base.exists()) return base;

             }

             return mount != null ? mount : null;

         }

         protected Collection<URL> getAllURLs() throws FileSystemException {

             Collection<URL> urls = new ArrayList<URL>(bases.length + 1);

             if (mount != null && mount.exists()) urls.add(mount.getURL());

             for (FileLookup lookup: bases) {

                 VirtualFileObject base = lookup.lookupFile();

                 if (base == null || !base.exists()) continue;

                 urls.add(base.getURL());

             }

             return urls;

         }

         protected void doDelete() throws FileSystemException {

             point = setDeleted(file.getName(), true, false);

             if (mount != null) mount.delete();

         }

         protected void injectType(FileType newType) throws FileSystemException {

             if (newType == null) {

                 // called when the system wants to do a new scan

             } else {

                 if (isDeleted()) {

                     if (!FileType.IMAGINARY.equals(newType)) point = setDeleted(file.getName(), false, false);

                 } else {

                     if (FileType.IMAGINARY.equals(newType)) {

                         throw new InternalError();

                     }

                 }

             }

             super.injectType(newType);

         }

         protected String[] getChildNames() throws FileSystemException {

             LinkedHashSet<String> names = new LinkedHashSet<String>();

 OUTER:

             do {

                 if (mount != null) {

                     if (isDeleted()) break OUTER;

                     if (mount.exists()) {

                         if (mount.getType().hasChildren()) {

                             addChildNames(names, mount.getChildren());

                         } else {

                             throw new FileSystemException("Found file/directory overlap");

                         }

                     }

                 }

                 for (FileLookup lookup: bases) {

                     VirtualFileObject base = lookup.lookupFile();

                     if (base == null) continue;

                     if (getResolution(base, false).isDeleted()) break OUTER;

                     if (!base.getType().hasChildren()) continue;

                     addChildNames(names, base.getChildren());

                 }

             } while (false);

             names.remove(".svn");

             addMountedChildren(file.getName(), names);

             getStorageHandler().removeDeletedChildren(file.getName(), names);

             getStorageHandler().excludeNames(names);

             return names.toArray(new String[names.size()]);

         }

     }

 }