package org.webslinger.commons.vfs;

 import java.util.HashSet;

 import java.util.Set;

 import java.util.SortedMap;

 import java.util.concurrent.ConcurrentMap;

 import java.util.concurrent.atomic.AtomicReference;

 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.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.lang.ConcurrentUtil;

 public abstract class LayeredFileSystem<N extends FileName, F extends LayeredFileObject<N, F, S>, S extends LayeredFileSystem<N, F, S>> extends AbstractGenerifiedFileSystem<N, F, S> {

     protected final SortedMap<String, LayeredFileListener> listeners = ConcurrentUtil.createSortedMap();

     public LayeredFileSystem(N name, FileObject root, FileSystemOptions options) throws FileSystemException {

         super(name, root, options);

     }

     protected abstract F[] newArray(int length);

     public void addListener(F file, FileListener listener) {

         //System.err.println("addListener(" + file + ", " + listener + ")");

         try {

             LayeredFileListener chain = listeners.get(file.getName().getPath());

             if (chain == null) {

                 chain = new LayeredFileListener(file);

                 listeners.put(file.getName().getPath(), chain);

             }

             chain.addListener(listener);

         } catch (FileSystemException e) {

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

         }

     }

     public void removeListener(F file, FileListener listener) {

         try {

             LayeredFileListener chain = listeners.get(file.getName().getPath());

             if (chain == null) return;

             switch (chain.removeListener(listener)) {

                 case 0:

                     break;

                 case 1:

                     listeners.remove(file.getName().getPath());

                     break;

                 case 2:

             }

         } catch (FileSystemException e) {

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

         }

     }

     protected void updateListeners(FileName name) throws FileSystemException {

         String startsWith = name.getPath() + "/";

         for (LayeredFileListener chain: listeners.tailMap(startsWith).values()) {

             if (!chain.path.startsWith(startsWith)) break;

             F nestedFile = resolveFile(chain.path);

             FileObject realFile = nestedFile.getFile(false);

             chain.checkFileChanged(realFile);

         }

     }

     protected abstract FileSet getRealFiles(F file) throws FileSystemException;

     protected FileSet createFileSet(FileObject[] contentFiles, FileObject[] existantFiles) {

         return new FileSet(contentFiles, existantFiles);

     }

     protected class LayeredFileListener implements FileListener {

         protected String path;

         protected AtomicReference<FileSet> fileSet = new AtomicReference<FileSet>();;

         protected AtomicReference<HashSet<FileListener>> listeners = new AtomicReference<HashSet<FileListener>>(new HashSet<FileListener>());

         protected LayeredFileListener(FileObject fo) throws FileSystemException {

             path = fo.getName().getPath();

             fetchFiles();

         }

         protected void fetchFiles() throws FileSystemException {

             fileSet.set(getRealFiles(resolveFile(path)));

         }

         protected void addAllListeners() throws FileSystemException {

             FileSet fileSet = this.fileSet.get();

             addAllListenersSet(fileSet.contentFiles);

             addAllListenersSet(fileSet.existantFiles);

         }

         protected void addAllListenersSet(Set<FileSystemAndNameKey> set) throws FileSystemException {

             for (FileSystemAndNameKey key: set) {

                 key.getFileSystem().addListener(key.getFileSystem().resolveFile(key.getName()), this);

             }

         }

         protected void removeAllListeners() throws FileSystemException {

             FileSet fileSet = this.fileSet.get();

             removeAllListenersSet(fileSet.contentFiles);

             removeAllListenersSet(fileSet.existantFiles);

         }

         protected void removeAllListenersSet(Set<FileSystemAndNameKey> set) throws FileSystemException {

             for (FileSystemAndNameKey key: set) {

                 key.getFileSystem().removeListener(key.getFileSystem().resolveFile(key.getName()), this);

             }

         }

         protected void checkFileChanged(FileObject newFile) throws FileSystemException {

             if (!listeners.get().isEmpty()) {

                 removeAllListeners();

                 fetchFiles();

                 addAllListeners();

             }

         }

         protected FileObject getFile() throws Exception {

             return resolveFile(path);

         }

         // no need for locking, protected by the global lock on VirtualFileSystem.listeners

         protected boolean addListener(FileListener listener) throws FileSystemException {

             HashSet<FileListener> oldListeners, newListeners;

             do {

                 oldListeners = listeners.get();

                 if (oldListeners.contains(listener)) return false;

                 newListeners = new HashSet<FileListener>(oldListeners);

                 newListeners.add(listener);

             } while (!listeners.compareAndSet(oldListeners, newListeners));

             if (newListeners.size() == 1) addAllListeners();

             return true;

         }

         protected int removeListener(FileListener listener) throws FileSystemException {

             HashSet<FileListener> oldListeners, newListeners;

             do {

                 oldListeners = listeners.get();

                 if (!oldListeners.contains(listener)) return 0;

                 newListeners = new HashSet<FileListener>(oldListeners);

                 newListeners.remove(listener);

             } while (!listeners.compareAndSet(oldListeners, newListeners));

             if (newListeners.size() == 0) {

                 removeAllListeners();

                 return 1;

             }

             return 2;

         }

         public void fileChanged(FileChangeEvent event) throws Exception {

             if (!fileSet.get().contentFiles.contains(event.getFile())) return;

             fireEvent(new ChangedEvent(getFile()));

         }

         public void fileCreated(FileChangeEvent event) throws Exception {

             if (!fileSet.get().existantFiles.contains(event.getFile())) return;

             fireEvent(new CreateEvent(getFile()));

         }

         public void fileDeleted(FileChangeEvent event) throws Exception {

             if (!fileSet.get().existantFiles.contains(event.getFile())) return;

             fireEvent(new DeleteEvent(getFile()));

         }

         protected void fireEvent(AbstractFileChangeEvent event) throws Exception {

             for (FileListener listener: listeners.get()) {

                 event.notify(listener);

             }

         }

     }

 }