package org.webslinger.commons.vfs.handlers.cow;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.LinkedHashMap;

 import java.util.Map;

 import java.util.Queue;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.atomic.AtomicReference;

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

 import org.webslinger.util.GeneratedResult;

 import org.webslinger.xml.XmlUtil;

 public class COWStateXml {

     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);

         }

     }

     private final FileSystem fileSystem;

     private final FileName fileName;

     private Document doc;

     private final AtomicReference<State> state = new AtomicReference<State>();

     public COWStateXml(FileObject file) throws IOException {

         this.fileName = file.getName();

         this.fileSystem = file.getFileSystem();

         state.set(load(file));

     }

     protected static HashMap<String, Entry> parse(Document doc) {

         HashMap<String, Entry> entries = new HashMap<String, Entry>();

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

         while (node != null) {

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

                 Element entryElement = (Element) node;

                 boolean isDeleted = "true".equals(entryElement.getAttribute("deleted"));

                 LinkedHashMap<String, Element> bases = new LinkedHashMap<String, Element>();

                 Node baseNode = node.getFirstChild();

                 while (baseNode != null) {

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

                         Element baseElement = (Element) baseNode;

                         String base = baseElement.getAttribute("target");

                         Element oldElement = bases.put(base, baseElement);

                         if (oldElement != null) entryElement.removeChild(oldElement);

                     }

                     baseNode = baseNode.getNextSibling();

                 }

                 Entry newEntry = new Entry(entryElement, bases, isDeleted);

                 Entry oldEntry = entries.put(newEntry.element.getAttribute("name"), newEntry);

                 if (oldEntry != null) node.getParentNode().removeChild(oldEntry.element);

             }

             node = node.getNextSibling();

         }

         return entries;

     }

     protected static State load(FileObject file) throws FileSystemException {

         long lastModified;

         HashMap<String, Entry> entries;

         Document doc;

         DocumentBuilder documentBuilder = xmlBuilders.poll();

         try {

             if (!file.exists()) {

                 doc = documentBuilder.newDocument();

                 doc.appendChild(doc.createElement("state"));

                 lastModified = -1;

                 entries = new HashMap<String, Entry>();

             } else {

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

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

                 doc = documentBuilder.parse(in);

                 entries = parse(doc);

                 in.close();

             }

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         } finally {

             xmlBuilders.offer(documentBuilder);

         }

         return new State(doc, entries, lastModified);

     }

     protected static void save(FileObject file, State state) throws FileSystemException {

         DocumentBuilder documentBuilder = xmlBuilders.element();

         try {

             if (!state.entries.isEmpty()) {

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

                 DOMSource source = new DOMSource(state.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();

             } else {

                 file.delete();

             }

         } catch (Exception e) {

             throw VFSUtil.makeFileSystemException(e);

         } finally {

             xmlBuilders.offer(documentBuilder);

         }

     }

     protected FileObject getFile() throws FileSystemException {

         return fileSystem.resolveFile(fileName);

     }

     public void removeDeletedChildren(Collection<String> names) throws FileSystemException {

         state.get().removeDeletedChildren(names);

     }

     public Collection<String> loadData(String name, boolean[] isDeleted) throws FileSystemException {

         return state.get().loadData(name, isDeleted);

     }

     public boolean submitRequests(String name, COWStorageHandler.Request... requests) throws FileSystemException {

         boolean[] saved = new boolean[1];

         State oldState, newState;

         do {

             oldState = state.get();

             newState = oldState.submitRequests(name, requests);

             if (oldState == newState) return false;

             if (newState == null) {

                 Document doc = (Document) oldState.doc.cloneNode(false);

                 doc.appendChild(doc.createElement("state"));

                 newState = new State(doc, new HashMap<String, Entry>(), -1);

             }

         } while (!state.compareAndSet(oldState, newState));

         save(getFile(), newState);

         return true;

     }

     public String toString() {

         return "COWStateXml(" + fileName.toString() + ")";

     }

     protected final static class State {

         protected final Document doc;

         protected final HashMap<String, Entry> entries;

         protected final long lastModified;

         protected State(Document doc, HashMap<String, Entry> entries, long lastModified) {

             this.doc = doc;

             this.entries = entries;

             this.lastModified = lastModified;

         }

         private State copy(boolean doCopy) {

             if (!doCopy) return this;

             Document newDoc = (Document) doc.cloneNode(true);

             State newState = new State(newDoc, parse(newDoc), lastModified);

             return newState;

         }

         private State checkEmpty(String name) {

             Entry entry = entries.get(name);

             if (entry != null && !entry.isDeleted && entry.bases.isEmpty()) {

                 entries.remove(name);

                 entry.element.getParentNode().removeChild(entry.element);

             }

             return entries.isEmpty() ? null : this;

         }

         private Entry newEntry(String name, LinkedHashMap<String, Element> bases, boolean isDeleted) {

             if (".cowstate.xml".equals(name)) new Exception().printStackTrace();

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

             doc.getDocumentElement().appendChild(element);

             Entry entry = new Entry(element, bases, isDeleted);

             element.setAttribute("name", name);

             Entry oldEntry = entries.put(name, entry);

             if (oldEntry != null) oldEntry.element.getParentNode().removeChild(oldEntry.element);

             return entry;

         }

         protected State delete(String name, boolean doCopy) {

             if (!entries.containsKey(name)) return this;

             State newState = copy(doCopy);

             Entry entry = newState.entries.remove(name);

             entry.element.getParentNode().removeChild(entry.element);

             return newState.checkEmpty(name);

         }

         protected State setDeleted(String name, boolean isDeleted, boolean doCopy) {

             Entry entry = entries.get(name);

             if (entry != null) {

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

             } else if (!isDeleted) {

                 return this;

             }

             State newState = copy(doCopy);

             entry = newState.newEntry(name, entry == null ? new LinkedHashMap<String, Element>() : newState.entries.get(name).bases, isDeleted);

             if (isDeleted) {

                 entry.element.setAttribute("deleted", "true");

             } else {

                 entry.element.removeAttribute("deleted");

             }

             return newState.checkEmpty(name);

         }

         protected State addBase(String name, String relative, boolean doCopy) {

             Entry entry = entries.get(name);

             if (entry != null && entry.bases.containsKey(relative)) return this;

             State newState = copy(doCopy);

             LinkedHashMap<String, Element> bases = entry != null ? new LinkedHashMap<String, Element>(entry.bases) : new LinkedHashMap<String, Element>();

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

             base.setAttribute("target", relative);

             bases.put(relative, base);

             newState.newEntry(name, bases, false).element.appendChild(base);

             return newState;

         }

         protected State removeBase(String name, String relative, boolean doCopy) {

             Entry entry = entries.get(name);

             if (entry == null || !entry.bases.containsKey(relative)) return this;

             State newState = copy(doCopy);

             entry = newState.entries.get(name);

             entry.element.removeChild(entry.bases.remove(relative));

             return newState.checkEmpty(name);

         }

         protected void removeDeletedChildren(Collection<String> names) throws FileSystemException {

             for (Entry entry: entries.values()) {

                 if (entry.isDeleted) names.remove(entry.element.getAttribute("name"));

             }

         }

         protected Collection<String> loadData(String name, boolean[] isDeleted) {

             Entry entry = entries.get(name);

             if (entry == null) return null;

             isDeleted[0] = entry.isDeleted;

             return entry.bases.keySet();

         }

         protected State submitRequests(String name, COWStorageHandler.Request... requests) {

             State newState = copy(true);

             int i = 0, j = 0;

             for (COWStorageHandler.Request request: requests) {

                 if (request instanceof COWStorageHandler.ClearRequest) {

                     newState.delete(name, false);

                 } else if (request instanceof COWStorageHandler.SetDeletedRequest) {

                     newState.setDeleted(name, ((COWStorageHandler.SetDeletedRequest) request).deleted, false);

                 } else if (request instanceof COWStorageHandler.AddBaseRequest) {

                     newState.addBase(name, ((COWStorageHandler.AddBaseRequest) request).relative, false);

                 } else if (request instanceof COWStorageHandler.RemoveBaseRequest) {

                     newState.removeBase(name, ((COWStorageHandler.RemoveBaseRequest) request).relative, false);

                 }

             }

             return newState.entries.isEmpty() ? null : newState;

         }

     }

     private final static class Entry {

         protected final Element element;

         protected final LinkedHashMap<String, Element> bases;

         protected final boolean isDeleted;

         protected Entry(Element element, LinkedHashMap<String, Element> bases, boolean isDeleted) {

             this.element = element;

             this.bases = bases;

             this.isDeleted = isDeleted;

         }

     }

 }