package org.webslinger.commons.vfs;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.io.PrintStream;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.nio.charset.Charset;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

 import java.util.TreeMap;

 import org.apache.commons.io.input.NullInputStream;

 import org.apache.commons.vfs.CacheStrategy;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileFilter;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSelectInfo;

 import org.apache.commons.vfs.FileSystem;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileSystemManager;

 import org.apache.commons.vfs.FileSystemOptions;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.impl.StandardFileSystemManager;

 import org.apache.commons.vfs.operations.FileOperation;

 import org.apache.commons.vfs.operations.FileOperations;

 import org.apache.commons.vfs.provider.local.LocalFile;

 import org.apache.commons.vfs.provider.DelegateFileObject;

 import org.webslinger.commons.vfs.cow.COWFileObject;

 import org.webslinger.commons.vfs.local.WebslingerLocalFileProvider;

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

 import org.webslinger.io.Charsets;

 import org.webslinger.io.IOUtil;

 public class VFSUtil {

     static Method getLocalFile;

     static {

         try {

             getLocalFile = LocalFile.class.getDeclaredMethod("getLocalFile", (Class[]) null);

             getLocalFile.setAccessible(true);

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (InternalError) new InternalError(e.getMessage()).initCause(e);

         }

     }

     public static void touch(FileObject file) throws FileSystemException, IOException {

         touch(file, System.currentTimeMillis());

     }

     public static void touch(FileObject file, long time) throws FileSystemException, IOException {

         if (!file.exists()) {

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

             out.close();

         }

         file.getContent().setLastModifiedTime(time);

     }

     public static boolean cmp(FileObject left, FileObject right) throws IOException {

         FileContent leftContent = left.getContent();

         FileContent rightContent = right.getContent();

         if (leftContent.getSize() != rightContent.getSize()) return true;

         return IOUtil.cmp(leftContent.getInputStream(), rightContent.getInputStream());

     }

     public static byte[] getBytes(FileObject file) throws IOException {

         ByteArrayOutputStream baos = new ByteArrayOutputStream();

         IOUtil.copy(file.getContent().getInputStream(), true, baos, true);

         return baos.toByteArray();

     }

     public static void setBytes(FileObject file, byte[] bytes) throws IOException {

         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

         IOUtil.copy(bais, true, file.getContent().getOutputStream(), true);

     }

     public static InputStream getInputStream(FileObject root, String fileName) throws FileSystemException {

         return root.resolveFile(fileName).getContent().getInputStream();

     }

     public static OutputStream getOutputStream(FileObject root, String fileName) throws FileSystemException {

         return root.resolveFile(fileName).getContent().getOutputStream();

     }

     public static Object getAttribute(FileObject root, String fileName, String attrName) throws FileSystemException {

         return getAttribute(root.resolveFile(fileName), attrName);

     }

     public static Object getAttribute(FileObject file, String attrName) throws FileSystemException {

         return file.getContent().getAttribute(attrName);

     }

     public static void setAttribute(FileObject root, String fileName, String attrName, Object value) throws FileSystemException {

         setAttribute(root.resolveFile(fileName), attrName, value);

     }

     public static void setAttribute(FileObject file, String attrName, Object value) throws FileSystemException {

         file.getContent().setAttribute(attrName, value);

     }

     public static String getString(FileObject file) throws FileSystemException, IOException {

         return getStringEncoding(file, Charsets.UTF8);

     }

     public static String getString(FileObject root, String fileName) throws FileSystemException, IOException {

         return getStringEncoding(root, fileName, Charsets.UTF8);

     }

     public static String getStringEncoding(FileObject root, String fileName, String encoding) throws FileSystemException, IOException {

         return getStringEncoding(root.resolveFile(fileName), encoding);

     }

     public static String getStringEncoding(FileObject root, String fileName, Charset charset) throws FileSystemException, IOException {

         return getStringEncoding(root.resolveFile(fileName), charset);

     }

     public static String getStringEncoding(FileObject file, String encoding) throws FileSystemException, IOException {

         return IOUtil.readString(file.getContent().getInputStream(), encoding);

     }

     public static String getStringEncoding(FileObject file, Charset charset) throws FileSystemException, IOException {

         return IOUtil.readString(file.getContent().getInputStream(), charset);

     }

     public static void setString(FileObject file, String value) throws FileSystemException, IOException {

         setStringEncoding(file, Charsets.UTF8, value);

     }

     public static void setString(FileObject root, String fileName, String value) throws FileSystemException, IOException {

         setStringEncoding(root, fileName, Charsets.UTF8, value);

     }

     public static void setStringEncoding(FileObject root, String fileName, String encoding, String value) throws FileSystemException, IOException {

         setStringEncoding(root.resolveFile(fileName), encoding, value);

     }

     public static void setStringEncoding(FileObject root, String fileName, Charset charset, String value) throws FileSystemException, IOException {

         setStringEncoding(root.resolveFile(fileName), charset, value);

     }

     public static void setStringEncoding(FileObject file, String encoding, String value) throws FileSystemException, IOException {

         IOUtil.writeString(file.getContent().getOutputStream(), encoding, value);

     }

     public static void setStringEncoding(FileObject file, Charset charset, String value) throws FileSystemException, IOException {

         IOUtil.writeString(file.getContent().getOutputStream(), charset, value);

     }

     public static File getLocalFile(LocalFile file) throws FileSystemException {

         file.getType();

         try {

             try {

                 return (File) getLocalFile.invoke(file, (Object[]) null);

             } catch (InvocationTargetException e) {

                 throw (InternalError) new InternalError("SNO").initCause(e.getCause());

             }

         } catch (IllegalAccessException e) {

             throw (InternalError) new InternalError("SNO").initCause(e);

         }

     }

     private static File resolveLocalFile(FileObject file, List<FileObject> queue) throws FileSystemException, IOException {

         FileObject ptr = queue.get(0);

         if (ptr instanceof DelegateFileObject) {

             queue.set(0, ((DelegateFileObject) ptr).getDelegateFile());

         } else if (ptr instanceof FilteringFileObject) {

             queue.set(0, ((FilteringFileObject) ptr).getRealFile());

         } else if (ptr instanceof COWFileObject) {

             queue.remove(0);

             queue.addAll(0, Arrays.asList(((COWFileObject) ptr).getAllFiles()));

         } else if (ptr instanceof VirtualFileObject) {

             queue.set(0, ((VirtualFileObject) ptr).getFile());

         } else if (!ptr.exists()) {

             queue.remove(0);

         } else if (ptr instanceof LocalFile) {

             queue.remove(0);

             return new File(ptr.getName().getPath());

         } else {

             throw new IOException("not a local file(" + file + "->(" + ptr.getClass().getName() + ")" + ptr + ")");

         }

         return null;

     }

     public static void refresh(FileObject file) throws FileSystemException {

         file.close();

     }

     public static File findLocalFile(FileObject file) throws FileSystemException, IOException {

         ArrayList<FileObject> queue = new ArrayList<FileObject>();

         queue.add(file);

         while (!queue.isEmpty()) {

             File localFile = resolveLocalFile(file, queue);

             if (localFile != null) return localFile;

         }

         throw new IOException("no local file found(" + file + ")");

     }

     public static File[] findAllLocalFiles(FileObject file) throws FileSystemException, IOException {

         ArrayList<File> files = new ArrayList<File>();

         ArrayList<FileObject> queue = new ArrayList<FileObject>();

         queue.add(file);

         while (!queue.isEmpty()) {

             File localFile = resolveLocalFile(file, queue);

             if (localFile != null) files.add(localFile);

         }

         return files.toArray(new File[files.size()]);

     }

     public static void truncate(FileObject file, long size) throws FileSystemException, IOException {

         FileContent fromContent = file.getContent();

         FileObject tmp = file.getFileSystem().getFileSystemManager().resolveFile("tmp:/VFSUtil.tmp");

         OutputStream tmpOut = tmp.getContent().getOutputStream();

         if (fromContent.getSize() > size) {

             IOUtil.copy(fromContent.getInputStream(), true, tmpOut, true, size);

         } else {

             if (fromContent.getSize() > 0) {

                 IOUtil.copy(fromContent.getInputStream(), true, tmpOut, false);

                 size -= fromContent.getSize();

             }

             IOUtil.copy(new NullInputStream(size), true, tmpOut, true);

         }

         tmp.moveTo(file);

     }

     public static FileObject[] sortFiles(FileObject[] children) {

         TreeMap<String, FileObject> sortMap = new TreeMap<String, FileObject>();

         for (FileObject child: children) {

             sortMap.put(child.getName().getPath(), child);

         }

         return sortMap.values().toArray(new FileObject[sortMap.size()]);

     }

     public static FileFilter getFileFilterPattern(final String pattern) {

         return new FileFilter() {

             public boolean accept(FileSelectInfo info) {

                 return info.getFile().getName().getBaseName().matches(pattern);

             }

         };

     }

     public static void tree(FileObject file, PrintStream out) throws IOException {

         tree(file, out, false);

     }

     public static void tree(FileObject file, PrintStream out, boolean showHidden) throws IOException {

         if (file.isHidden() && !showHidden) return;

         printFileName(true, file, out);

         if (out != null) out.println();

         tree(new StringBuilder(), file, out, showHidden);

     }

     protected static void tree(StringBuilder prefix, FileObject file, PrintStream out, boolean showHidden) throws IOException {

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

         FileObject[] children = file.getChildren();

         if (children == null || children.length == 0) return;

         prefix.append(' ');

         for (FileObject child: children) {

             if (child.isHidden() && !showHidden) continue;

             if (out != null) out.print(prefix);

             printFileName(false, child, out);

             if (out != null) out.println();

             tree(prefix, child, out, showHidden);

         }

         prefix.setLength(prefix.length() - 1);

     }

     public static void printFileName(boolean full, FileObject file, PrintStream out) throws IOException {

         FileName name = file.getName();

         out.print(full ? name.toString() : name.getBaseName());

         FileType type = file.getType();

         if (type == FileType.IMAGINARY) {

             out.print('!');

         } else {

             if (type.hasChildren()) out.print('/');

             if (type.hasContent()) {

                 out.print('|');

                 out.print(file.getContent().getSize());

             }

         }

         out.print(' ');

         out.print(file.isReadable() ? 'R' : '-');

         out.print(file.isWriteable() ? 'W' : '-');

         out.print(file.isHidden() ? 'H' : '-');

     }

     public static FileSystemException makeFileSystemException(Throwable t) throws FileSystemException {

         if (t instanceof Error) throw (Error) t;

         if (t instanceof RuntimeException) throw (RuntimeException) t;

         if (t instanceof FileSystemException) throw (FileSystemException) t;

         return (FileSystemException) new FileSystemException(t.getMessage()).initCause(t);

     }

     public static <T extends FileOperation> T getOperation(FileObject file, Class<T> operationClass) throws FileSystemException {

         FileOperations operations = file.getFileOperations();

         if (!operations.hasOperation(operationClass)) return null;

         return operationClass.cast(operations.getOperation(operationClass));

     }

     public static <T extends FileOperation> T getOperation(FileSystem fs, String path, Class<T> operationClass) throws FileSystemException {

         return getOperation(fs.resolveFile(path), operationClass);

     }

     public static FileSystemOptions findFileSystemOptions(FileObject file, FileSystemOptions options, boolean create) {

         if (options != null) return options;

         while (options == null && file != null) {

             options = file.getFileSystem().getFileSystemOptions();

             if (file instanceof DelegateFileObject) {

                 file = ((DelegateFileObject) file).getDelegateFile();

             } else {

                 file = null;

             }

         }

         if (options == null && create) options = new FileSystemOptions();

         return options;

     }

     public static StandardFileSystemManager createStandardFileSystemManager() throws FileSystemException {

         StandardFileSystemManager sfsm = new StandardFileSystemManager();

         sfsm.setCacheStrategy(CacheStrategy.MANUAL);

         //sfsm.setCacheStrategy(CacheStrategy.ON_CALL);

         sfsm.addProvider(new String[] {"wsfile"}, new WebslingerLocalFileProvider());

         sfsm.init();

         return sfsm;

     }

     public static FileObject toFileObject(FileSystemManager fsm, File file, FileSystemOptions options) throws FileSystemException {

         try {

             return toFileObject(fsm, file.toURL().toString(), options);

         } catch (Exception e) {

             throw makeFileSystemException(e);

         }

     }

     public static FileObject toFileObject(FileSystemManager fsm, String url, FileSystemOptions options) throws FileSystemException {

         try {

             String newUrl = url.toString().replaceAll("^file:", "wsfile:");

             FileObject file = fsm.resolveFile(url, options);

             if (!file.getName().getScheme().equals("file")) return file;

             return fsm.resolveFile(file.getURL().toString().replaceAll("^file:", "wsfile:"), options);

         } catch (Exception e) {

             throw makeFileSystemException(e);

         }

     }

 }