package org.webslinger.commons.vfs.cow;

 import java.io.IOException;

 import java.net.URLStreamHandler;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.concurrent.ConcurrentHashMap;

 import org.apache.commons.vfs.Capability;

 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.provider.DefaultURLStreamHandler;

 import org.webslinger.lang.ConcurrentFreezingCache;

 import org.webslinger.lang.Freezer;

 import static org.webslinger.lang.ClassUtil.NULL;

 import org.webslinger.commons.vfs.FileSet;

 import org.webslinger.commons.vfs.FilteringFileSystem;

 import org.webslinger.commons.vfs.GenerationalFileObject;

 import org.webslinger.commons.vfs.GenerationalFileSystem;

 public class COWFileSystem extends GenerationalFileSystem<FileName, COWFileObject, COWFileSystem.COWResolution, COWFileSystem> {

     protected final COWEntryFactory cowEntryFactory;

     protected HashSet<Capability> caps = new HashSet<Capability>();

     public COWFileSystem(FileName name, FileObject root, FileSystemOptions options) throws FileSystemException {

         super(name, root, options);

         FilteringFileSystem.copyCapabilities(root.getFileSystem(), caps);

         COWEntryFactory cowEntryFactory = COWConfigBuilder.getInstance().getCOWEntryFactory(options);

         if (cowEntryFactory == null) cowEntryFactory = new DefaultCOWEntryFactory();

         this.cowEntryFactory = cowEntryFactory;

     }

     public static final class DefaultCOWEntryFactory implements COWEntryFactory {

         protected final ConcurrentHashMap<FileSystem, ConcurrentFreezingCache<COWFileObject, Object, COWState>> cowStates = new ConcurrentHashMap<FileSystem, ConcurrentFreezingCache<COWFileObject, Object, COWState>>();

         public COWEntry getCOWEntry(COWFileSystem cfs, COWFileObject file, boolean create) throws FileSystemException {

             //if (file.getFileSystem() != cfs) throw new InternalError();

             //if (file == null) return null;

             COWState state = getCOWState(cfs, file.getParent(), create);

             if (state == null) return null;

             return state.getEntry(file.getName().getBaseName(), create);

         }

         public String[] getChildNames(COWFileSystem cfs, COWFileObject parent, boolean create) throws FileSystemException {

             //if (parent.getFileSystem() != cfs) throw new InternalError();

             //if (parent == null) return null;

             COWState state = getCOWState(cfs, parent, create);

             if (state == null) return null;

             return state.getChildNames();

         }

         protected COWState getCOWState(final COWFileSystem cfs, COWFileObject parent, boolean create) throws FileSystemException {

             //if (parent == null) return null;

             ConcurrentFreezingCache<COWFileObject, Object, COWState> cowStatesPerFS = cowStates.get(cfs);

             if (cowStatesPerFS == null && !create) return null;

             if (cowStatesPerFS == null) {

                 cowStatesPerFS = new ConcurrentFreezingCache<COWFileObject, Object, COWState>(COWFileSystem.class, "cowStatsPerFS", cfs.getRoot().getName().toString(), ConcurrentFreezingCache.SOFT, cowStatesPerFSFreezer) {

                     protected COWState createValue(Object id, Object frozen) throws Exception {

                         COWFileObject parent = (COWFileObject) id;

                         if (parent != null) return new COWState(cfs, parent.resolveFile(".cowstate.xml"));

                         return new COWState(cfs, cfs.resolveFile(".cowstate.xml"));

                     }

                 };

                 ConcurrentFreezingCache<COWFileObject, Object, COWState> newCowStatesPerFS = cowStates.putIfAbsent(cfs, cowStatesPerFS);

                 if (newCowStatesPerFS != null) cowStatesPerFS = newCowStatesPerFS;

             }

             try {

                 return cowStatesPerFS.get(parent);

             } catch (FileSystemException e) {

                 throw e;

             } catch (RuntimeException e) {

                 throw e;

             } catch (Exception e) {

                 throw (InternalError) new InternalError("SNO: " + e.getMessage()).initCause(e);

             }

         }

     }

     private static final Freezer<COWFileObject, Object> cowStatesPerFSFreezer = new Freezer<COWFileObject, Object>() {

         public Object freeze(COWFileObject parent) {

             return parent != null ? parent.getName() : NULL;

         }

     };

     public void addCapabilities(Collection caps) {

         caps.addAll(this.caps);

     }

     protected COWFileObject createFile(FileName name) {

         return new COWFileObject(name, this);

     }

     // FIXME: Add listeners to source files, to clear cache

     String[] getChildNames(COWFileObject file, boolean create) throws FileSystemException {

         return cowEntryFactory.getChildNames(this, file, create);

     }

     COWEntry getCOWEntry(COWFileObject file, boolean create) throws FileSystemException {

         return cowEntryFactory.getCOWEntry(this, file, create);

     }

     public COWEntry getCOWEntry(String path) throws FileSystemException {

         return cowEntryFactory.getCOWEntry(this, resolveFile(path), true);

     }

     protected int newGeneration() {

         return super.newGeneration();

     }

     protected COWResolution newResolution(int generation, COWFileObject genFile) throws FileSystemException {

         return new COWResolution(generation, genFile);

     }

     protected COWFileObject[] newArray(int length) {

         return new COWFileObject[length];

     }

     protected FileSet getRealFiles(COWFileObject file) throws FileSystemException {

         return createFileSet(file.getAllFiles(), new FileObject[0]);

     }

     protected class COWResolution extends GenerationalFileSystem.Resolution<FileName, COWFileObject, COWResolution, COWFileSystem> {

         private final COWFileObject[] files;

         private final COWEntry[] cowEntries;

         private final int[] cowEntrySerials;

         protected COWResolution(int generation, COWFileObject genFile) throws FileSystemException {

             super(generation, genFile);

             COWResolver resolver = new COWResolver(COWFileSystem.this);

             resolver.resolve(genFile);

             files = resolver.getFiles();

             for (FileObject file: files) file.refresh();

             cowEntries = resolver.getCOWEntries();

             cowEntrySerials = resolver.getCOWEntrySerials();

         }

         protected boolean refresh() throws FileSystemException {

             int i = files[0] == file ? 1 : 0;

             for (; i < files.length; i++) files[i].refresh();

             return super.refresh();

         }

         FileObject[] getFiles() {

             return files;

         }

         protected boolean isWriteable() {

             return true;

         }

         protected boolean isOutOfDate(boolean create) throws FileSystemException {

             if (create && files.length == 0) return true;

             //System.err.println(this + ".isOutOfDate(" + cowStates.length + "):" + java.util.Arrays.asList(cowStates));

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

                 if (cowEntries[i].checkSerial(cowEntrySerials[i])) return true;

             }

             return false;

         }

         protected FileObject doGetFile(boolean create) throws FileSystemException {

             COWEntry entry = getCOWEntry(file, create);

             if (create) {

                 if (entry == null) System.err.println("null: " + file);

                 entry.setDeleted(false);

                 return files[0].getParentLayerFile();

             }

             //System.err.println(this + ": cowEntry=" + getCOWEntry());

             if (entry != null && entry.isDeleted()) return null;

             for (COWFileObject file: files) {

                 FileObject parentFile = file.getParentLayerFile();

                 if (parentFile.exists()) return parentFile;

             }

             return null;

         }

         protected void doDelete() throws FileSystemException {

             getCOWEntry(file, true).setDeleted(true);

             files[0].getParentLayerFile().delete();

         }

         protected String[] getChildNames() throws FileSystemException {

             //System.err.println(this + ".getChildren(): children=" + children);

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

             for (int i = files.length - 1; i >= 0; i--) {

                 COWFileObject cowFile = files[i];

                 FileObject fo = cowFile.getParentLayerFile();

                 if (fo.getType().hasChildren()) {

                     fo.refresh();

                     COWFileObject parentDir = cowFile.getParent();

                     FileObject[] children = fo.getChildren();

                     for (FileObject child: children) {

                         String name = child.getName().getBaseName();

                         COWEntry childEntry = getCOWEntry(parentDir != null ? parentDir.resolveFile(name) : resolveFile(name), false);

                         if (childEntry != null && childEntry.isDeleted()) {

                             names.remove(name);

                         } else {

                             names.add(name);

                         }

                     }

                 } else if (fo.getType().hasContent()) {

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

                 }

             }

             String[] foundNames = COWFileSystem.this.getChildNames(file, false);

             if (foundNames != null) names.addAll(Arrays.asList(foundNames));

             names.remove(".cowstate.xml");

             Iterator<String> it = names.iterator();

             while (it.hasNext()) {

                 String name = it.next();

                 COWEntry childEntry = getCOWEntry(file.getName().getPath() + '/' + name);

                 if (childEntry.isDeleted()) it.remove();

             }

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

         }

     }

 }