package org.webslinger.modules;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Iterator;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystemManager;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.Selectors;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.commons.vfs.operations.COWStateOperation;

 import org.webslinger.commons.vfs.virtual.VirtualFileSystem;

 public class GenericWorkAreaFactory extends AbstractWorkAreaFactory<GenericWorkAreaFactory.GenericWorkArea> {

     protected final FileObject site;

     protected final VirtualFileSystem vfs;

     protected final FileObject root;

     protected final FileObject cow;

     public GenericWorkAreaFactory(FileObject site, FileObject work) throws IOException {

         super(work);

         this.site = site;

         FileSystemManager fsm = work.getFileSystem().getFileSystemManager();

         FileObject virtual = fsm.createFileSystem("wsvfs", work);

         vfs = (VirtualFileSystem) virtual.getFileSystem();

         virtual.resolveFile("site").createFolder();

         vfs.addJunction("/site", site);

         cow = virtual; //fsm.createFileSystem("cow", virtual);

         root = fsm.createFileSystem("flat", cow.resolveFile("site"));

     }

     public FileObject getRoot() {

         return root;

     }

     public VirtualFileSystem getVirtual() {

         return vfs;

     }

     public FileObject getCOW() {

         return cow;

     }

     protected GenericWorkArea createWorkArea(String name, String location) throws IOException {

         FileObject areaWork = work.resolveFile(location);

         FileObject areaBase = vfs.getRoot().resolveFile("site");

         return new GenericWorkArea(null, name, areaBase, areaWork);

     }

     protected final class GenericWorkArea extends AbstractWorkAreaFactory<GenericWorkArea> implements Comparable<GenericWorkArea>, WorkArea<GenericWorkArea> {

         private final GenericWorkArea parentArea;

         private final String name;

         private final FileObject base;

         private final FileObject changes;

         private final FileObject root;

         protected GenericWorkArea(GenericWorkArea parentArea, String name, FileObject areaBase, FileObject areaWork) throws IOException {

             super(areaWork);

             this.parentArea = parentArea;

             this.name = name;

             this.base = areaBase;

             changes = areaBase.resolveFile("changes");

             changes.createFolder();

             String relativeName = changes.getParent().getName().getRelativeName(areaBase.getName());

             VFSUtil.getOperation(changes, COWStateOperation.class).addBase("..");

             root = areaBase.getFileSystem().getFileSystemManager().createFileSystem("flat", changes);

         }

         protected GenericWorkArea createWorkArea(String name, String location) throws IOException {

             FileObject areaWork = work.resolveFile(location);

             return new GenericWorkArea(this, name, changes, areaWork);

         }

         public void abort() throws IOException {

             close();

         }

         public void commit() throws IOException {

             commit("/", work.resolveFile("changes"), base);

             work.resolveFile("changes").delete(Selectors.SELECT_SELF_AND_CHILDREN);

             close();

         }

         protected void commit(String cowPath, FileObject work, FileObject parent) throws IOException {

             FileType workType = work.getType();

             FileType parentType = parent.getType();

             if (workType.hasChildren()) {

                 if (workType.hasContent()) {

                     // both folder and file, can't handle

                     throw new UnsupportedOperationException();

                 }

                 if (!parent.exists()) {

                     // does not exist

                     parent.copyFrom(work, Selectors.SELECT_CHILDREN);

                 } else if (!parentType.hasChildren()) {

                     // exists, but is a file

                     parent.delete();

                     parent.copyFrom(work, Selectors.SELECT_CHILDREN);

                 } else {

                     for (FileObject child: work.getChildren()) {

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

                         commit(cowPath + FileName.SEPARATOR + baseName, child, parent.resolveFile(baseName));

                     }

                 }

             } else if (workType.hasContent()) {

                 if (!parent.exists()) {

                     // does not exist

                     parent.copyFrom(work, Selectors.SELECT_SELF);

                 } else if (!parentType.hasContent()) {

                     // exists, but is a folder

                     parent.delete();

                     parent.copyFrom(work, Selectors.SELECT_SELF);

                 } else if (VFSUtil.cmp(work, parent)) {

                     parent.copyFrom(work, Selectors.SELECT_SELF);

                 }

             } else {

                 // neither file or folder, nothing to do

                 System.err.println("unknown types");

                 return;

             }

             // FIXME: check attributes

         }

         protected void close() throws IOException {

             root.close();

             FileObject parent = root.getFileSystem().getParentLayer();

             parent.close();

             parent = parent.getFileSystem().getParentLayer();

             parent.close();

         }

         public String getName() {

             return appendName(new StringBuilder()).toString();

         }

         public GenericWorkArea getParentArea() {

             return parentArea;

         }

         public FileObject getRoot() {

             return root;

         }

         public int hashCode() {

             int hashCode = GenericWorkArea.class.hashCode();

             if (getParentArea() != null) hashCode ^= getParentArea().hashCode();

             if (getName() != null) hashCode ^= getName().hashCode();

             return hashCode;

         }

         public boolean equals(Object o) {

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

             GenericWorkArea other = (GenericWorkArea) o;

             if (getParentArea() == null) {

                 if (other.getParentArea() != null) return false;

             } else if (!getParentArea().equals(other.getParentArea())) {

                 return false;

             }

             if (getName() == null) {

                 if (other.getName() != null) return false;

             } else if (!getName().equals(other.getName())) {

                 return false;

             }

             return true;

         }

         public int compareTo(GenericWorkArea other) {

             if (getParentArea() == null) {

                 if (other.getParentArea() != null) return -1;

             } else if (other.getParentArea() == null) {

                 return 1;

             } else {

                 int r = getParentArea().compareTo(other.getParentArea());

                 if (r != 0) return r;

             }

             if (getName() == null) {

                 if (other.getName() != null) return -1;

             } else if (other.getName() == null) {

                 return 1;

             } else {

                 int r = getName().compareTo(other.getName());

                 if (r != 0) return r;

             }

             return 0;

         }

         protected StringBuilder appendName(StringBuilder sb) {

             if (name == null) return sb;

             if (getParentArea() != null) getParentArea().appendName(sb).append('/');

             return sb.append(name);

         }

         public String toString() {

             return getName();

         }

     }

 }