package org.webslinger.commons.vfs.cow;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.LinkedHashSet;

 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.FileSystemManager;

 import org.webslinger.collections.CollectionUtil;

 public class COWResolver {

     private final COWFileSystem cfs;

     private LinkedHashSet<COWFileObject> results = new LinkedHashSet<COWFileObject>();

     private HashMap<String, LinkedHashSet<COWFileObject>> linkedParents;

     public COWResolver(COWFileSystem cfs) {

         this(cfs, new HashMap<String, LinkedHashSet<COWFileObject>>());

 //System.err.println("new COWResolver(" + cfs + ")");

     }

     private COWResolver(COWFileSystem cfs, HashMap<String, LinkedHashSet<COWFileObject>> linkedParents) {

         this.cfs = cfs;

         this.linkedParents = linkedParents;

     }

     private void addFile(COWFileObject fo) throws FileSystemException {

 //System.err.println("addFile(" + fo + "), " + fo.exists());

         results.remove(fo);

         results.add(fo);

     }

     private LinkedHashSet<COWFileObject> getPreviousParents(String name) {

         return linkedParents.get(name);

     }

     private void addParentLink(COWFileObject parentFile, String suffixName) {

 //System.err.println("addParentLink(" + parentName + ", " + suffixName + ")");

         LinkedHashSet<COWFileObject> parents = linkedParents.get(suffixName);

         if (parents == null) {

             parents = new LinkedHashSet<COWFileObject>();

             linkedParents.put(suffixName, parents);

         }

         parents.add(parentFile);

     }

     private COWResolver getSubResolver() {

         return new COWResolver(cfs, linkedParents);

     }

     private void mergeIn(COWResolver resolver) {

 //log("::::::::::::::::::::::::::: mergeIn");

 //log("sub results=" + context.results);

 //log("results=" + results);

         if (resolver.results.isEmpty()) return;

         if (results.isEmpty()) {

             results = resolver.results;

             return;

         }

         resolver.results.addAll(results);

         results = resolver.results;

     //    Collections.reverse(results);

     }

     public COWFileObject[] getFiles() {

         return  results.toArray(new COWFileObject[results.size()]);

     }

     public COWEntry[] getCOWEntries() {

         return entries.keySet().toArray(new COWEntry[entries.size()]);

     }

     public int[] getCOWEntrySerials() {

         int[] cowEntrySerials = new int[entries.size()];

         Iterator it = entries.values().iterator();

         int i = 0;

         while (it.hasNext()) {

             Integer serial = (Integer) it.next();

             cowEntrySerials[i++] = serial.intValue();

         }

         return cowEntrySerials;

     }

     private final HashMap<COWEntry, Integer> entries = new HashMap<COWEntry, Integer>();

     private COWEntry getCOWEntry(COWFileObject file) throws FileSystemException {

         COWEntry entry = cfs.getCOWEntry(file, false);

         if (entry == null) return null;

         entries.put(entry, entry.getSerial());

         return entry;

     }

     protected void rerun(String relative, String suffixName) throws FileSystemException {

         //push();

         LinkedHashSet<COWFileObject> previousParents = getPreviousParents(suffixName);

 //System.err.println("rerun(" + relative + ", " + suffixName + ") " + previousParents);

         try {

             COWResolver subResolver = getSubResolver();

             COWFileObject[] parents = new COWFileObject[previousParents.size()];

             previousParents.toArray(parents);

             previousParents.clear();

             FileSystemManager fsm = cfs.getFileSystemManager();

             for (COWFileObject previousParent: parents) {

                 //if (!it.hasNext()) break;

 //log("relative=[" + relative + "]");

                 subResolver.resolve(previousParent.getParent().resolveFile(relative).resolveFile(suffixName));

             }

             mergeIn(subResolver);

         } finally {

             //pop();

         }

     }

     // TODO: check multiple symlinks

     protected void resolve(COWFileObject fo) throws FileSystemException {

         //push();

 //if (name == null) new Exception().printStackTrace();

 //System.err.println("resolve(" + fo + ")");

         try {

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

             FileSystemManager fsm = cfs.getFileSystemManager();

             FileObject root = cfs.getParentLayer();

 //System.err.println("fo=" + fo);

             addFile(fo);

             addParentLink(fo, "");

             COWEntry entry = getCOWEntry(fo);

             if (entry == null) return;

             if (entry.isDeleted()) return;

             String suffixName = CollectionUtil.join(names, "/");

 OUTER:

             while (true) {

 //System.err.println("fo=" + fo);

 //System.err.println("==============[ " + realFile + " ]=============");

 //System.err.println("names=" + names);

 //System.err.println("suffixName[" + suffixName + "]");

                 try {

                     do {

                         String linkTarget = entry.getSymlink();

                         if (linkTarget != null) {

 //log("is a symlink");

 //                            linkedParents.remove(suffixName);

                             results.clear();

                             rerun(linkTarget, suffixName);

 //log("linkName=" + linkName.getPath());

 //log("newName=" + newName.getPath());

                         }

                         Collection<COWFileObject> bases = entry.getBaseFiles();

 //log("cowLinks=" + cowLinks);

                         if (bases != null) {

                             for (COWFileObject base: bases) {

                                 COWFileObject newFile = base.resolveFile(suffixName);

 //System.err.println("baseName=" + baseName.getPath());

 //System.err.println("newName=" + newName.getPath());

                                 //rerun(baseLink, suffixName);

                                 //addParentLink(linkedParents, cowName, suffixName);

                                 resolve(newFile);

                             }

                         }

                     } while (false);

                 } catch (IOException e) {

                     e.printStackTrace();

                 }

                 addParentLink(fo, suffixName);

                 if (fo.getName().getPath().equals("/")) break;

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

                 //parentName = parentName.getParent();

                 fo = fo.getParent();

                 entry = getCOWEntry(fo);

                 if (entry == null) break;

                 suffixName = CollectionUtil.join(names, "/");

             }

             return;

         } finally {

             //pop();

         }

     }

 }