package org.webslinger.io;

 import java.io.BufferedReader;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.CharArrayReader;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FilenameFilter;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.io.OutputStream;

 import java.io.OutputStreamWriter;

 import java.io.PrintWriter;

 import java.io.Reader;

 import java.io.Serializable;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.nio.charset.Charset;

 import java.nio.charset.CharsetDecoder;

 import java.nio.charset.CharsetEncoder;

 import java.nio.charset.CoderResult;

 import java.nio.charset.CodingErrorAction;

 import java.nio.CharBuffer;

 import java.nio.ByteBuffer;

 import java.nio.channels.Channels;

 import java.nio.channels.ReadableByteChannel;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Set;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import org.apache.commons.collections.CollectionUtils;

 import org.apache.commons.io.IOUtils;

 import org.apache.commons.io.output.NullOutputStream;

 import org.apache.commons.lang.StringUtils;

 import org.webslinger.collections.CollectionUtil;

 import org.webslinger.resolver.ObjectCreator;

 import org.webslinger.resolver.ObjectLoader;

 import org.webslinger.resolver.ObjectResolver;

 import org.webslinger.resolver.ObjectWalker;

 import org.webslinger.json.JSON;

 import org.webslinger.json.JSONWriter;

 public final class IOUtil {

     public static final ObjectWalker walker = new ObjectWalker();

     public static final ObjectLoader loader = new ObjectLoader();

     public static void touch(String name) {

         touch(new File(name), System.currentTimeMillis());

     }

     public static void touch(String name, long time) {

         touch(new File(name), time);

     }

     public static void touch(File file) {

         touch(file, System.currentTimeMillis());

     }

     public static void touch(File file, long time) {

         if (!file.exists()) {

             try {

                 file.getParentFile().mkdirs();

                 FileOutputStream out = getOutputStream(file);

                 out.close();

             } catch (Exception e) {

             }

         }

         file.setLastModified(time);

     }

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

         return cmp(new File(left), new File(right));

     }

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

         return cmp(new FileInputStream(left), new FileInputStream(right));

     }

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

         try {

             return IOUtils.contentEquals(left, right);

         } finally {

             IOUtils.closeQuietly(right);

             IOUtils.closeQuietly(left);

         }

     }

     public static void dump(InputStream in) throws IOException {

         copy(in, false, new NullOutputStream(), true);

     }

     public static void dump(InputStream in, boolean closeIn) throws IOException {

         copy(in, closeIn, new NullOutputStream(), true);

     }

     public static void copy(InputStream in, File file) throws IOException {

         copy(in, false, file);

     }

     public static void copy(InputStream in, boolean closeIn, File file) throws IOException {

         copy(in, closeIn, getOutputStream(file), true);

     }

     public static void copy(File file, OutputStream out) throws IOException {

         copy(file, out, false);

     }

     public static void copy(File file, OutputStream out, boolean closeOut) throws IOException {

         copy(getInputStream(file), true, out, closeOut);

     }

     public static void copy(InputStream in, OutputStream out) throws IOException {

         copy(in, false, out, false);

     }

     public static void copy(InputStream in, boolean closeIn, OutputStream out, boolean closeOut) throws IOException {

         try {

             try {

                 IOUtils.copy(in, out);

             } finally {

                 if (closeIn) in.close();

             }

         } finally {

             if (closeOut) out.close();

         }

     }

     public static long copy(InputStream in, boolean closeIn, OutputStream out, boolean closeOut, long count) throws IOException {

         try {

             byte[] buf = new byte[4096];

             long totalRead = 0;

             while (count > 0) {

                 int amountRead = in.read(buf);

                 if (amountRead == -1) break;

                 out.write(buf, 0, amountRead);

                 totalRead += amountRead;

                 count -= amountRead;

             }

             return totalRead;

         } finally {

             if (closeIn) in.close();

             if (closeOut) out.close();

         }

     }

     public static void copy(Reader reader, File file, String encoding) throws IOException {

         copy(reader, false, file, encoding);

     }

     public static void copy(Reader reader, boolean closeIn, File file, String encoding) throws IOException {

         copy(reader, closeIn, new OutputStreamWriter(getOutputStream(file), encoding), true);

     }

     public static void copy(File file, String encoding, Writer writer) throws IOException {

          copy(file, encoding, writer, false);

     }

     public static void copy(File file, String encoding, Writer writer, boolean closeOut) throws IOException {

          copy(new InputStreamReader(getInputStream(file), encoding), true, writer, closeOut);

     }

     public static void copy(Reader reader, Writer writer) throws IOException {

         copy(reader, false, writer, false);

     }

     public static void copy(Reader reader, boolean closeIn, Writer writer, boolean closeOut) throws IOException {

         try {

             try {

                 IOUtils.copy(reader, writer);

             } finally {

                 if (closeIn) IOUtils.closeQuietly(reader);

             }

         } finally {

             if (closeOut) IOUtils.closeQuietly(writer);

         }

     }

     public static void copy(File from, File to) throws IOException {

         copy(from, to, null);

     }

     public static void copy(File from, File to, FilenameFilter filter) throws IOException {

         if (!from.exists()) throw new FileNotFoundException("Source(" + from + ") does not exist");

         if (from.isDirectory()) {

             if (to.exists()) {

                 if (!to.isDirectory()) throw new IOException("Source(" + from + ") is directory while target(" + to + ") is not");

             } else {

                 if (!to.mkdirs()) throw new IOException("Couldn't make target directory(" + to + ")");

             }

             File[] files = from.listFiles(filter);

             if (files == null) return;

             for (File file: files) {

                 copy(file, new File(to, file.getName()));

             }

         } else {

             if (to.isDirectory()) to = new File(to, from.getName());

             copy(getInputStream(from), getOutputStream(to));

         }

     }

     public static boolean rename(File from, File to) throws IOException {

         if (from.renameTo(to)) return true;

         copy(getInputStream(from), getOutputStream(to));

         if (delete(from)) return true;

         return false;

     }

     public static boolean delete(File file) {

         if (!file.exists()) return true;

         if (!file.delete() && !file.isDirectory()) return false;

         File[] files = file.listFiles();

         // if null, then the delete above should have succeeded.

         if (files == null) return false;

         for (File f: files) {

             delete(f);

         }

         return file.delete();

     }

     public static String readStringFromFile(String file, String encoding) throws IOException {

         return readStringFromFile(new File(file), encoding);

     }

     public static void writeStringToFile(String file, String encoding, String value) throws IOException {

         writeStringToFile(new File(file), encoding, value);

     }

     public static String readStringFromFile(String file) throws IOException {

         return readStringFromFile(file, Charsets.UTF8);

     }

     public static String readStringFromFile(String file, Charset encoding) throws IOException {

         return readStringFromFile(new File(file), encoding);

     }

     public static void writeStringToFile(String file, String value) throws IOException {

         writeStringToFile(file, Charsets.UTF8, value);

     }

     public static void writeStringToFile(String file, Charset charset, String value) throws IOException {

         writeStringToFile(new File(file), charset, value);

     }

     public static String readString(File file, String encoding) throws IOException {

         return readStringFromFile(file, encoding);

     }

     public static String readStringFromFile(File file, String encoding) throws IOException {

         return readString(getInputStream(file), encoding);

     }

     public static void writeString(File file, String encoding, String value) throws IOException {

         writeStringToFile(file, encoding, value);

     }

     public static void writeStringToFile(File file, String encoding, String value) throws IOException {

         file.getParentFile().mkdirs();

         writeString(getOutputStream(file), encoding, value);

     }

     public static String readString(File file) throws IOException {

         return readStringFromFile(file);

     }

     public static String readStringFromFile(File file) throws IOException {

         return readStringFromFile(file, Charsets.UTF8);

     }

     public static String readString(File file, Charset encoding) throws IOException {

         return readStringFromFile(file, encoding);

     }

     public static String readStringFromFile(File file, Charset encoding) throws IOException {

         return readString(getInputStream(file), encoding);

     }

     public static void writeString(File file, String value) throws IOException {

         writeStringToFile(file, value);

     }

     public static void writeStringToFile(File file, String value) throws IOException {

         writeStringToFile(file, Charsets.UTF8, value);

     }

     public static void writeString(File file, Charset charset, String value) throws IOException {

         writeStringToFile(file, charset, value);

     }

     public static void writeStringToFile(File file, Charset charset, String value) throws IOException {

         file.getParentFile().mkdirs();

         writeString(getOutputStream(file), charset, value);

     }

     public static String readString(InputStream in) throws IOException {

         return readString(in, Charsets.UTF8);

     }

     public static String readString(InputStream in, String encoding) throws IOException {

         return readString(in, Charset.forName(encoding));

     }

     public static void writeString(OutputStream out, String encoding, String value) throws IOException {

         writeString(out, Charset.forName(encoding), value);

     }

     public static String readString(InputStream in, Charset encoding) throws IOException {

         try {

             ByteBuffer buf = ByteBuffer.allocate(4096);

             CharBuffer cbuf = CharBuffer.allocate(4096);

             ReadableByteChannel channel = Channels.newChannel(in);

             StringBuilder sb = new StringBuilder();

             CharsetDecoder decoder = encoding.newDecoder().onMalformedInput(CodingErrorAction.REPORT);

             int r;

             while ((r = channel.read(buf)) != -1) {

                 buf.flip();

                 CoderResult result = decoder.decode(buf, cbuf, false);

                 if (result.isError()) result.throwException();

                 cbuf.flip();

                 sb.append(cbuf);

                 buf.clear();

                 cbuf.clear();

             }

             CoderResult result = decoder.decode(buf, cbuf, true);

             if (result.isError()) result.throwException();

             sb.append(cbuf);

             return sb.toString();

         } finally {

             IOUtils.closeQuietly(in);

         }

     }

     public static void writeString(OutputStream out, String value) throws IOException {

         writeString(out, Charsets.UTF8, value);

     }

     public static void writeString(OutputStream out, Charset charset, String value) throws IOException {

         try {

             ByteBuffer buf = charset.encode(CharBuffer.wrap(value));

             Channels.newChannel(out).write(buf);

         } finally {

             IOUtils.closeQuietly(out);

         }

     }

     public static String readString(byte[] bytes) throws IOException {

         return readString(bytes, Charsets.UTF8);

     }

     public static String readString(byte[] bytes, String encoding) throws IOException {

         return readString(bytes, Charset.forName(encoding));

     }

     public static String readString(byte[] bytes, int offset, int length) throws IOException {

         return readString(bytes, offset, length, Charsets.UTF8);

     }

     public static String readString(byte[] bytes, int offset, int length, String encoding) throws IOException {

         return readString(bytes, offset, length, Charset.forName(encoding));

     }

     public static String readString(byte[] bytes, Charset charset) throws IOException {

         return readString(bytes, 0, bytes.length, charset);

     }

     public static String readString(byte[] bytes, int offset, int length, Charset charset) throws IOException {

         ByteBuffer buf = ByteBuffer.allocate(length);

         buf.put(bytes, offset, length);

         buf.flip();

         CharBuffer cbuf = charset.decode(buf);

         return cbuf.toString();

     }

     public static byte[] getBytes(String value) throws IOException {

         return getBytes(value, Charsets.UTF8);

     }

     public static byte[] getBytes(String value, String encoding) throws IOException {

         return getBytes(value, Charset.forName(encoding));

     }

     public static byte[] getBytes(String value, Charset charset) throws IOException {

         ByteBuffer bb = charset.encode(value);

         byte[] bytes = new byte[bb.limit()];

         bb.get(bytes);

         return bytes;

     }

     public static Object readObjectFromFile(String file) throws ClassNotFoundException, IOException {

         return readObjectFromFile(new File(file));

     }

     public static Object readObjectFromFile(File file) throws ClassNotFoundException, IOException {

         return readObject(getInputStream(file));

     }

     public static void writeObjectToFile(String file, Object value) throws IOException {

         writeObjectToFile(new File(file), value);

     }

     public static void writeObjectToFile(File file, Object value) throws IOException {

         file.getParentFile().mkdirs();

         writeObject(getOutputStream(file), value);

     }

     private static ClassLoader getClassLoader() {

         ClassLoader loader = Thread.currentThread().getContextClassLoader();

         if (loader != null) return loader;

         return IOUtil.class.getClassLoader();

     }

     public static Object readObject(InputStream in) throws ClassNotFoundException, IOException {

         ByteArrayOutputStream baos = new ByteArrayOutputStream();

         copy(in, baos);

         in.close();

         byte[] bytes = baos.toByteArray();

         try {

             char[] buffer = StringUtils.chomp(readString(bytes)).toCharArray();

             int i;

             for (i = 0; i < buffer.length && buffer[i] != ':'; i++);

             if (i > 0 && i < buffer.length) {

                 String className = new String(buffer, 0, i);

                 Class type = getClassLoader().loadClass(className);

                 return walker.getObject(type, buffer, i + 1, buffer.length - i - 1);

             }

         } catch (Exception e) {

         }

         try {

             return new JSON(new ByteArrayInputStream(bytes)).JSONValue();

         } catch (Exception e) {

         }

         ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(bytes));

         Serializable value = (Serializable) oin.readObject();

         oin.close();

         return value;

     }

     public static Object readObject(String name, InputStream in) throws IOException {

         ByteArrayOutputStream baos = new ByteArrayOutputStream();

         copy(in, baos);

         in.close();

         byte[] bytes = baos.toByteArray();

         char[] buffer = StringUtils.chomp(readString(bytes)).toCharArray();

         try {

             ObjectCreator<?> creator = loader.getCreator(name);

             if (creator != null) return creator.newObject(null, buffer, 0, buffer.length);

             return walker.getObject(name, buffer, 0, buffer.length);

         } catch (IOException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

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

         }

     }

     public static void writeObject(OutputStream out, Object value) throws IOException {

         try {

             ObjectResolver resolver = walker.getResolver(value.getClass());

             if (resolver != null) {

                 Class clz = resolver.primaryClass();

                 char[] chars = resolver.getChars(value);

                 if (chars != null) {

                     if (clz == null) clz = value.getClass();

                     PrintWriter writer = new PrintWriter(new OutputStreamWriter(out, Charsets.UTF8));

                     writer.write(clz.getName());

                     writer.write(':');

                     writer.write(chars);

                     writer.println();

                     writer.close();

                     return;

                 }

             }

             StringWriter writer = new StringWriter();

             IndentingWriter indenting = new IndentingWriter(writer, true, false);

             new JSONWriter(indenting).write(value);

             writer.write('\n');

             out.write(writer.toString().getBytes("UTF-8"));

             return;

         } catch (Exception e) {

         }

         ObjectOutputStream oout = new ObjectOutputStream(out);

         oout.writeObject(value);

         oout.close();

         out.close();

     }

     public static void writeObject(OutputStream out, String name, Object value) throws IOException {

         writeObject(out, Charsets.UTF8, name, value);

     }

     public static void writeObject(OutputStream out, Charset charset, String name, Object value) throws IOException {

         try {

             writeString(out, charset, new String(loader.getChars(name, value)));

         } catch (IOException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

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

         }

     }

     public static InputStream getInputStream(String value) throws IOException {

         return new ByteArrayInputStream(getBytes(value));

     }

     public static InputStream getInputStream(String value, String encoding) throws IOException {

         return new ByteArrayInputStream(getBytes(value, encoding));

     }

     public static InputStream getInputStream(String value, Charset charset) throws IOException {

         return new ByteArrayInputStream(getBytes(value, charset));

     }

     public static FileInputStream getInputStream(File file) throws IOException {

         if (file == null) return null;

         return new FileInputStream(file);

     }

     public static FileOutputStream getOutputStream(File file) throws IOException {

         if (file == null) return null;

         if (!file.exists()) file.getParentFile().mkdirs();

         return new FileOutputStream(file);

     }

     public static File getFile(File base, List names) {

         if (names.isEmpty()) return base;

         return new File(base, StringUtils.join(names, File.separator));

     }

     public static final String quoteName(String name) {

         return QuoteConvertor.convertString(name);

     }

     public static final Collection quoteNames(Collection names) {

         return CollectionUtils.collect(names, QuoteConvertor);

     }

     public static final Collection quoteNames(Iterator names) {

         return CollectionUtils.collect(names, QuoteConvertor);

     }

     public static final <T> T checkException(Throwable t) throws IOException {

         if (t instanceof IOException) throw (IOException) t;

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

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

         throw (IOException) new IOException(t.getMessage()).initCause(t);

     }

     public static final String unquoteName(String name) {

         return UnquoteConvertor.convertString(name);

     }

     public static final String slashToNative(String name) {

         String[] parts = name.split("/");

         StringBuilder sb = new StringBuilder(name.length() + parts.length * (File.separator.length() - 1));

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

             if (i != 0) sb.append(File.separator);

             sb.append(parts[i]);

         }

         return sb.toString();

     }

     public static final String nativeToSlash(String name) {

         String[] parts = name.split(File.separator);

         StringBuilder sb = new StringBuilder(name.length() - parts.length * (File.separator.length() - 1));

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

             if (i != 0) sb.append('/');

             sb.append(parts[i]);

         }

         return sb.toString();

     }

     // FIXME: get list from Robert's email

     public static final Pattern nameBadChars = Pattern.compile("[/\"\\\\:]");

     public static final CollectionUtil.StringConvertor QuoteConvertor = new CollectionUtil.StringConvertor() {

         public String convertString(String string) {

             StringBuffer sb = new StringBuffer(string.length());

             Matcher matcher = nameBadChars.matcher(string);

             while (matcher.find()) {

                 int c = matcher.group(0).charAt(0);

                 matcher.appendReplacement(sb, "");

                 sb.append("%{").append((int) c).append('}');

             }

             matcher.appendTail(sb);

             return sb.toString();

         }

     };

     public static final Pattern nameQuoted = Pattern.compile("%\\{(\\d+)\\}");

     public static final CollectionUtil.StringConvertor UnquoteConvertor = new CollectionUtil.StringConvertor() {

         public String convertString(String string) {

             StringBuffer sb = new StringBuffer(string.length());

             Matcher matcher = nameQuoted.matcher(string);

             while (matcher.find()) {

                 matcher.appendReplacement(sb, Character.toString((char) Integer.parseInt(matcher.group(1))));

             }

             matcher.appendTail(sb);

             return sb.toString();

         }

     };

     public static class NameFilter implements FilenameFilter {

         protected Set<Pattern> includePatterns = new HashSet<Pattern>();

         protected Set<Pattern> excludePatterns = new HashSet<Pattern>();

         protected Pattern includePattern;

         protected Pattern excludePattern;

         protected boolean def;

         public NameFilter(boolean def) {

             this.def = def;

         }

         public void addName(String name, boolean mode) {

             addPattern(Pattern.compile("^\\Q" + name + "\\E$"), mode);

         }

         public void addPattern(Pattern pattern, boolean mode) {

             if (mode) {

                 includePatterns.add(pattern);

                 includePattern = null;

             } else {

                 excludePatterns.add(pattern);

                 excludePattern = null;

             }

         }

         public Pattern getIncludePattern() {

             if (includePattern != null) return includePattern;

             includePattern = makePattern(includePatterns);

 //System.err.println("include:" + includePattern.pattern());

             return includePattern;

         }

         public Pattern getExcludePattern() {

             if (excludePattern != null) return excludePattern;

             excludePattern = makePattern(excludePatterns);

 //System.err.println("exclude:" + excludePattern.pattern());

             return excludePattern;

         }

         protected Pattern makePattern(Set patterns) {

             StringBuilder sb = new StringBuilder();

             Iterator it = patterns.iterator();

             while (it.hasNext()) {

                 Pattern pattern = (Pattern) it.next();

                 sb.append(pattern.pattern());

                 if (it.hasNext()) sb.append('|');

             }

             return Pattern.compile(sb.toString());

         }

         public boolean accept(File dir, String name) {

             Pattern includePattern = getIncludePattern();

             Pattern excludePattern = getExcludePattern();

             if (def) {

                 if (includePattern.matcher(name).matches()) return true;

                 if (excludePattern.matcher(name).matches()) return false;

             } else {

                 if (excludePattern.matcher(name).matches()) return true;

                 if (includePattern.matcher(name).matches()) return false;

             }

             return true;

         }

     }

 }