package org.webslinger.ext.support;

 import java.io.IOException;

 import java.sql.Timestamp;

 import java.text.DateFormat;

 import java.util.ArrayList;

 import java.util.Comparator;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.TreeSet;

 import java.util.Set;

 import java.util.StringTokenizer;

 import javax.servlet.ServletException;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.commons.collections.Transformer;

 import org.apache.commons.collections.map.AbstractReferenceMap;

 import org.apache.commons.collections.map.LazyMap;

 import org.apache.commons.collections.map.ReferenceMap;

 import org.apache.commons.fileupload.FileItem;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.webslinger.PathContext;

 import org.webslinger.ThemingFactory;

 import org.webslinger.TypeHandler;

 import org.webslinger.Webslinger;

 import org.webslinger.WebslingerServletContext;

 import org.webslinger.collections.KeyedMapEntryComparator;

 import org.webslinger.commons.vfs.CachingLister;

 import org.webslinger.commons.vfs.ReloadingCachingLister;

 import org.webslinger.container.FileInfo;

 import org.webslinger.ext.types.thumb;

 import org.webslinger.servlet.MultipartFormUtil;

 import org.webslinger.util.TTLObject;

 public class DirectoryLister extends TTLObject<Map<Comparator, Map<String, Map<String, Object>>>> {

     static {

         TTLObject.setDefaultTTLForClass(DirectoryLister.class, 1000);

     }

     protected static class FileSorter extends KeyedMapEntryComparator {

         protected FileSorter(String name, boolean descending) {

             super(name, descending);

         }

         public int compare(Map left, Map right) {

             Integer leftSeq = (Integer) left.get("sequence");

             Integer rightSeq = (Integer) right.get("sequence");

             int r = leftSeq.intValue() - rightSeq.intValue();

             if (r == 0) return super.compare(left, right);

             return direction ? -r : r;

         }

     };

     private static final Comparator DEFAULT_COMPARATOR = new FileSorter("name", false);

     public final WebslingerServletContext wsc;

     public final FileObject base;

     public final String path;

     public final FileObject file;

     public DirectoryLister(WebslingerServletContext wsc, FileObject base, String path) throws IOException {

         this.wsc = wsc;

         this.base = base;

         while (path.length() > 0 && path.startsWith("/")) path = path.substring(1);

         this.path = path;

         file = base.resolveFile(path);

     }

     protected Map<Comparator, Map<String, Map<String, Object>>> load(Map<Comparator, Map<String, Map<String, Object>>> oldContext) throws IOException {

         file.refresh();

         if (!file.getType().hasChildren()) return null;

         final Map<String, Map<String, Object>> unsortedFiles = new LinkedHashMap<String, Map<String, Object>>();

         FileObject[] children = file.getChildren();

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

             FileObject child = children[i];

             FileContent content = child.getContent();

             Map<String, Object> datum = new HashMap<String, Object>();

             datum.put("path", child.getName().getPath());

             datum.put("time", new Timestamp(content.getLastModifiedTime()));

             datum.put("description", content.getAttribute("description"));

             FileInfo fileInfo = wsc.getContainer().getFileInfo(child);

             datum.put("content-type", fileInfo.getContentType());

             String icon = (String) fileInfo.getAttribute("icon");

             if (icon == null) icon = "unknown.png";

             datum.put("icon", icon);

             String sequence = (String) fileInfo.getAttribute("sequence");

             if (sequence == null) sequence = "0";

             datum.put("sequence", Integer.valueOf(sequence));

             if (child.getType().hasChildren()) {

                 datum.put("name", child.getName().getBaseName() + "/");

                 datum.put("alt", "inode/directory");

             } else {

                 datum.put("name", child.getName().getBaseName());

                 datum.put("size", new Long(content.getSize()));

             }

             unsortedFiles.put(child.getName().getBaseName(), datum);

         }

         final Map<Comparator, Map<String, Map<String, Object>>> sorted = LazyMap.decorate(new ReferenceMap(AbstractReferenceMap.HARD, AbstractReferenceMap.SOFT), new Transformer() {

             public Object transform(Object key) {

                 TreeSet<Map<String, Object>> set = new TreeSet<Map<String, Object>>((Comparator<Map<String, Object>>) key);

                 set.addAll(unsortedFiles.values());

                 Map<String, Map<String, Object>> files = new LinkedHashMap<String, Map<String, Object>>(set.size());

                 Iterator<Map<String, Object>> it = set.iterator();

                 while (it.hasNext()) {

                     Map<String, Object> datum = it.next();

                     files.put((String) datum.get("name"), datum);

                 }

                 return files;

             }

         });

         return sorted;

     }

     public Map<String, Map<String, Object>> getFiles() throws IOException {

         Map<Comparator, Map<String, Map<String, Object>>> sorted = getObject();

         return sorted != null ? sorted.get(DEFAULT_COMPARATOR) : null;

     }

     public void list(Webslinger webslinger, String prefix, ThemingFactory<OutputConfig> configFactory) throws IOException, ServletException {

         list(webslinger, webslinger.getPathContext(), webslinger.getRequest(), webslinger.getResponse(), webslinger.getContext(), prefix, configFactory.getThemedObject(webslinger.getThemePath()));

     }

     public void list(Webslinger webslinger, Map<String, Object> context, String prefix, ThemingFactory<OutputConfig> configFactory) throws IOException, ServletException {

         list(webslinger, webslinger.getPathContext(), webslinger.getRequest(), webslinger.getResponse(), context, prefix, configFactory.getThemedObject(webslinger.getThemePath()));

     }

     public void list(Webslinger webslinger, HttpServletRequest request, HttpServletResponse response, Map<String, Object> context, String prefix, ThemingFactory<OutputConfig> configFactory) throws IOException, ServletException {

         list(webslinger, webslinger.getPathContext(), request, response, context, prefix, configFactory.getThemedObject(webslinger.getThemePath()));

     }

     public void list(Webslinger webslinger, String prefix, OutputConfig config) throws IOException, ServletException {

         list(webslinger, webslinger.getPathContext(), webslinger.getRequest(), webslinger.getResponse(), webslinger.getContext(), prefix, config);

     }

     public void list(Webslinger webslinger, Map<String, Object> context, String prefix, OutputConfig config) throws IOException, ServletException {

         list(webslinger, webslinger.getPathContext(), webslinger.getRequest(), webslinger.getResponse(), context, prefix, config);

     }

     public void list(Webslinger webslinger, PathContext pc, HttpServletRequest request, HttpServletResponse response, Map<String, Object> context, String prefix, OutputConfig config) throws IOException, ServletException {

         Map<String, List<FileItem>> allParameters = (Map<String, List<FileItem>>) context.get("allParameters");

         if (allParameters == null) allParameters = MultipartFormUtil.parseRequestAsMap(request);

         Map<String, String> parameters = MultipartFormUtil.filterOutStrings(allParameters);

         if (file.getType().hasContent()) {

             if (parameters.get("thumb") != null) {

                 thumb thumbHandler = (thumb) wsc.getTypeHandler("thumb");

                 thumbHandler.serveThumb(wsc.resolve(file), request, response, 100, 100);

             } else {

                 webslinger.forward(wsc.resolve(file));

             }

             return;

         }

         context.put("TargetFile", file);

         context.put("Base", base);

         context.put("Path", path);

         context.put("Config", config);

         context.put("ListingPath", prefix + '/' + path);

         context.put("Errors", new ArrayList());

         context.put("DateFormat", DateFormat.getDateInstance(DateFormat.LONG));

         context.put("TimeFormat", DateFormat.getTimeInstance(DateFormat.LONG));

         context.put("DateTimeFormat", DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.FULL));

         String view = parameters.get("view");

         if (view == null) {

             if (file.exists()) view = (String) file.getContent().getAttribute("listing-view");

             if (view == null) {

                 view = (String) pc.getAttribute("listing-view");

                 if (view == null) view = "Details";

             }

         }

         context.put("View", view);

         Iterator<Map.Entry<String, String>> it = parameters.entrySet().iterator();

         while (it.hasNext()) {

             Map.Entry<String, String> entry = it.next();

             String key = entry.getKey();

             if (!key.startsWith("Action.")) continue;

             StringTokenizer st = new StringTokenizer(key.substring(7), ".");

             if (st.hasMoreTokens()) {

                 String whichName = st.nextToken();

                 CachingLister actionLister;

                 if ("Global".equals(whichName)) {

                     actionLister = config.globalActions;

                 } else if ("File".equals(whichName)) {

                     actionLister = config.fileActions;

                 } else {

                     continue;

                 }

                 if (actionLister != null && st.hasMoreTokens()) {

                     String action = st.nextToken();

                     FileObject actionFile = actionLister.getDir().resolveFile(action);

                     context.put("Name", entry.getValue());

                     String argument = key.substring(7 + whichName.length() + 1 + action.length());

                     if (st.hasMoreTokens()) argument = argument.substring(1);

                     context.put("ActionArgument", argument);

                     webslinger.event(webslinger.resolvePath(actionFile), context, "action", allParameters);

                     refresh();

                 }

             }

         }

         Map<Comparator, Map<String, Map<String, Object>>> sorted = getObject();

         if (sorted == null) {

             webslinger.forward(wsc.resolve(file));

             return;

         }

         Map<String, Map<String, Object>> files;

         String orderBy = parameters.get("orderBy");

         boolean nameDirection, timeDirection, sizeDirection, descending;

         nameDirection = timeDirection = sizeDirection = descending = "desc".equals(parameters.get("direction"));

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

         if ("name".equals(orderBy)) {

             nameDirection = !descending;

             files = sorted.get(new FileSorter("name", descending));

             qParams.add("orderBy=name");

         } else if ("time".equals(orderBy)) {

             timeDirection = !descending;

             files = sorted.get(new FileSorter("time", descending));

             qParams.add("orderBy=time");

         } else if ("size".equals(orderBy)) {

             sizeDirection = !descending;

             files = sorted.get(new FileSorter("size", descending));

             qParams.add("orderBy=size");

         } else {

             files = sorted.get(DEFAULT_COMPARATOR);

         }

         qParams.add("desc=" + (descending ? "desc" : "asc"));

         context.put("ListingFiles", files);

         context.put("ListingFilesList", new ArrayList<Map<String, Object>>(files.values()));

         context.put("orderBy", orderBy);

         context.put("direction", descending ? "desc" : "asc");

         context.put("nameDirection", nameDirection ? "desc" : "asc");

         context.put("timeDirection", timeDirection ? "desc" : "asc");

         context.put("sizeDirection", sizeDirection ? "desc" : "asc");

         webslinger.merge(wsc.resolve(config.views.getDir()), context);

     }

     public static class OutputConfig {

         public final CachingLister views;

         public final CachingLister globalActions;

         public final CachingLister fileActions;

         public OutputConfig(CachingLister views, CachingLister globalActions, CachingLister fileActions) {

             this.views = views;

             this.globalActions = globalActions;

             this.fileActions = fileActions;

         }

         public CachingLister getViews() {

             return views;

         }

         public CachingLister getGlobalActions() {

             return globalActions;

         }

         public CachingLister getFileActions() {

             return fileActions;

         }

     }

     public static class StandardThemingOutputConfig implements ThemingFactory<OutputConfig> {

         private final FileObject root;

         private final String viewsDir;

         private final String globalActionsDir;

         private final String fileActionsDir;

         public StandardThemingOutputConfig(FileObject root, String viewsDir, String globalActionsDir, String fileActionsDir) {

             this.root = root;

             this.viewsDir = viewsDir;

             this.globalActionsDir = globalActionsDir;

             this.fileActionsDir = fileActionsDir;

         }

         public OutputConfig getThemedObject(String themePath) throws IOException {

             return makeOutputConfig(root.resolveFile(themePath), viewsDir, globalActionsDir, fileActionsDir);

         }

     }

     public static OutputConfig makeOutputConfig(FileObject base, String viewsDir, String globalActionsDir, String fileActionsDir) throws IOException {

         return new OutputConfig(

             new ReloadingCachingLister(base.resolveFile(viewsDir)),

             new ReloadingCachingLister(base.resolveFile(globalActionsDir)),

             new ReloadingCachingLister(base.resolveFile(fileActionsDir))

         );

     }

 }