package org.webslinger.commons.vfs.cow;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Map;

 import java.util.Queue;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.OutputKeys;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.dom.DOMSource;

 import javax.xml.transform.stream.StreamResult;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.Node;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 import org.apache.commons.collections.CollectionUtils;

 import org.apache.commons.vfs.FileChangeEvent;

 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.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.lang.AtomicMap;

 import org.webslinger.lang.ConcurrentCache;

 import org.webslinger.util.GeneratedResult;

 import org.webslinger.util.TTLCachedObject;

 import org.webslinger.util.TTLObject;

 import org.webslinger.xml.XmlUtil;

 public class COWState extends TTLCachedObject<COWState.COWEntryCache> {

     private static final Queue<DocumentBuilder> xmlBuilders;

     static {

         DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();

         builderFactory.setCoalescing(true);

         builderFactory.setExpandEntityReferences(true);

         builderFactory.setIgnoringComments(true);

         builderFactory.setIgnoringElementContentWhitespace(true);

         builderFactory.setNamespaceAware(false);

         builderFactory.setValidating(false);

         //builderFactory.setXIncludeAware(false);

         try {

             xmlBuilders = XmlUtil.createPool(builderFactory, 20);

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (InternalError) new InternalError("loading xmlBuilders").initCause(e);

         }

         TTLObject.setDefaultTTLForClass(COWState.class, 1000);

     }

     private final COWFileSystem cfs;

     private final FileSystem fileSystem;

     private final FileName fileName;

     private final COWFileObject dir;

     private long lastModified;

     public COWState(COWFileSystem cfs, COWFileObject cowFile) throws IOException {

         this.cfs = cfs;

         FileObject file = cowFile.getParentLayerFile();

         fileName = file.getName();

         fileSystem = file.getFileSystem();

         dir = cowFile.getParent();

     }

     public COWState(FileObject file) throws IOException {

         cfs = null;

         this.fileName = file.getName();

         this.fileSystem = file.getFileSystem();

         dir = null;

     }

     protected COWFileObject getDir() throws FileSystemException {

         return dir;

     }

     protected COWEntryCache getInitial() {

         return new COWEntryCache();

     }

     COWFileSystem getCOWFileSystem() {

         return cfs;

     }

     public FileName getFileName() {

         return fileName;

     }

     public void clear() {

         try {

             getObject().clear();

         } catch (IOException e) {

         }

     }

     public COWEntry getEntry(String name, boolean create) throws FileSystemException {

         try {

             COWEntryCache cache = super.getObject();

             return cache != null ? cache.get(name) : null;

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         }

     }

     private COWEntryCache getCache() throws FileSystemException {

         try {

             return super.getObject();

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         }

     }

     public String[] getChildNames() throws FileSystemException {

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

         COWEntryCache cache = getCache();

         for (String name: cache.keys()) {

             try {

                 COWEntryImpl entry = cache.get(name);

                 if (entry.isEmpty()) continue;

                 names.add(name);

             } catch (Exception e) {

                 throw VFSUtil.makeFileSystemException(e);

             }

         }

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

     }

     public String[] getDeletedEntries() throws FileSystemException {

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

         COWEntryCache cache = getCache();

         for (String name: cache.keys()) {

             try {

                 COWEntryImpl entry = cache.get(name);

                 if (!entry.isDeleted()) continue;

                 deleted.add(name);

             } catch (Exception e) {

                 throw VFSUtil.makeFileSystemException(e);

             }

         }

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

     }

     protected void onChange() {

         // if local per-entry caching was occuring, this would update such code

     }

     public FileObject getFile() throws FileSystemException {

         return fileSystem.resolveFile(fileName);

     }

     protected long getTimestamp(COWEntryCache old) throws FileSystemException {

         FileObject file = getFile();

         return file.exists() ? file.getContent().getLastModifiedTime() : NOT_EXISTANT_TIMESTAMP;

     }

     protected GeneratedResult<COWEntryCache> generate(COWEntryCache old) throws FileSystemException {

         FileObject file = getFile();

         DocumentBuilder documentBuilder = xmlBuilders.poll();

         try {

             InputStream in = file.getContent().getInputStream();

             long lastModified = file.getContent().getLastModifiedTime();

             Document doc = documentBuilder.parse(in);

             in.close();

             Node node = doc.getDocumentElement().getFirstChild();

             COWEntryCache newEntries = new COWEntryCache();

             while (node != null) {

                 if (node.getNodeType() == Node.ELEMENT_NODE && "item".equals(node.getNodeName())) {

                     Element element = (Element) node;

                     String name = element.getAttribute("name");

                     boolean deleted = "true".equals(element.getAttribute("deleted"));

                     String symlink = element.hasAttribute("symlink") ? element.getAttribute("symlink") : null;

                     Node baseNode = element.getFirstChild();

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

                     while (baseNode != null) {

                         if (baseNode.getNodeType() == Node.ELEMENT_NODE && "base".equals(baseNode.getNodeName())) {

                             String base = ((Element) baseNode).getAttribute("target");

                             if (base != null && base.length() > 0) bases.add(base);

                         }

                         baseNode = baseNode.getNextSibling();

                     }

                     COWEntryImpl entry = newEntries.get(name);

                     entry.absorb(deleted, symlink, bases);

                 }

                 node = node.getNextSibling();

             }

             if (newEntries.isEmpty()) file.delete();

             return new GeneratedResult<COWEntryCache>(lastModified, newEntries);

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         } finally {

             xmlBuilders.offer(documentBuilder);

         }

     }

     public synchronized void save() throws FileSystemException {

         DocumentBuilder documentBuilder = xmlBuilders.element();

         try {

             Document doc = documentBuilder.newDocument();

             boolean itemsAdded = false;

             Element stateElement = doc.createElement("state");

             doc.appendChild(stateElement);

             COWEntryCache cache = getObject();

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

             tmpNames.addAll(cache.keys());

             String[] names = tmpNames.toArray(new String[tmpNames.size()]);

             Arrays.sort(names);

             for (String name: names) {

                 COWEntry entry = cache.get(name);

                 boolean deleted = entry.isDeleted();

                 String symlink = entry.getSymlink();

                 if (entry.isEmpty()) continue;

                 itemsAdded = true;

                 Element itemElement = doc.createElement("item");

                 itemElement.setAttribute("name", name);

                 if (deleted) itemElement.setAttribute("deleted", "true");

                 if (symlink != null) itemElement.setAttribute("symlink", symlink);

                 ArrayList<String> list = new ArrayList<String>(entry.getBases());

                 String[] basePaths = list.toArray(new String[list.size()]);

                 Arrays.sort(basePaths);

                 for (String basePath: basePaths) {

                     Element baseElement = doc.createElement("base");

                     baseElement.setAttribute("target", basePath);

                     itemElement.appendChild(baseElement);

                 }

                 stateElement.appendChild(itemElement);

             }

             if (itemsAdded) {

                 OutputStream out = getFile().getContent().getOutputStream();

                 DOMSource source = new DOMSource(doc);

                 StreamResult result = new StreamResult(out);

                 TransformerFactory factory = TransformerFactory.newInstance();

                 Transformer transformer = factory.newTransformer();

                 transformer.setOutputProperty(OutputKeys.INDENT, "yes");

                 transformer.transform(source, result);

                 out.close();

                 lastModifiedTime = getFile().getContent().getLastModifiedTime();

             } else {

                 getFile().delete();

                 lastModified = NOT_EXISTANT_TIMESTAMP;

             }

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         } finally {

             xmlBuilders.offer(documentBuilder);

         }

     }

     public boolean equals(Object o) {

         if (!(o instanceof COWState)) return false;

         COWState cs = (COWState) o;

         return fileSystem.equals(cs.fileSystem) && fileName.equals(cs.fileName);

     }

     public int hashCode() {

         return fileSystem.hashCode() ^ fileName.hashCode();

     }

     class COWEntryCache extends ConcurrentCache<String, COWEntryImpl> {

         COWEntryCache() {

             super(COWState.class, "entries", fileName.toString(), ConcurrentCache.HARD);

         }

         protected COWEntryImpl createValue(String name) {

             return new COWEntryImpl(COWState.this, name);

         }

     }

 }