package org.webslinger.commons.vfs.ccache;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.FilterOutputStream;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.lang.ref.SoftReference;

 import java.security.cert.Certificate;

 import java.util.Map;

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.RandomAccessContent;

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

 import org.apache.commons.vfs.util.RandomAccessMode;

 import org.webslinger.io.IOUtil;

 import org.webslinger.commons.vfs.FilteringFileObject;

 public class ContentCacheFileObject extends FilteringFileObject<FileName, ContentCacheFileObject, ContentCacheFileSystem> {

     // Add hook for copying/svn

     protected FileName name;

     protected ContentCacheFileSystem ccfs;

     private final ReentrantReadWriteLock byteLock = new ReentrantReadWriteLock(false);

     private SoftReference<?> ref;

     private long lastModified;

     public ContentCacheFileObject(FileName name, FileObject base, ContentCacheFileSystem ccfs) throws FileSystemException {

         super(name, ccfs, base);

         this.name = name;

         this.ccfs = ccfs;

     }

     protected Object getCachedData() throws FileSystemException {

         byteLock.readLock().lock();

         try {

             if (ref != null) {

                 if (lastModified != getRealFile().getContent().getLastModifiedTime()) {

                     ref = null;

                 } else {

                     Object data =ref.get();

                     if (data != null) return data;

                 }

             }

         } finally {

             byteLock.readLock().unlock();

         }

         byteLock.writeLock().lock();

         try {

             Object data;

             if (ref != null) {

                 data = ref.get();

                 if (data != null) return data;

             }

             FileContent content = getRealFile().getContent();

             if (content.getSize() < 64 * 1024) {

                 ByteArrayOutputStream baos = new ByteArrayOutputStream();

                 try {

                     IOUtil.copy(getRealFile().getContent().getInputStream(), baos);

                     byte[] bytes = baos.toByteArray();

                     ref = new SoftReference<byte[]>(bytes);

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

                     return bytes;

                 } catch (IOException e) {

                 }

             }

             ref = new SoftReference<FileContent>(content);

             return content;

         } finally {

             byteLock.writeLock().unlock();

         }

     }

     protected InputStream doGetInputStream() throws FileSystemException {

         Object data = getCachedData();

         if (data instanceof FileContent) return ((FileContent) data).getInputStream();

         return new ByteArrayInputStream((byte[]) data);

     }

     protected long doGetSize() throws FileSystemException {

         Object data = getCachedData();

         if (data instanceof FileContent) return ((FileContent) data).getSize();

         return ((byte[]) data).length;

     }

     protected String[] doListChildren() throws FileSystemException {

         FileObject[] children = getRealFile().getChildren();

         String[] names = new String[children.length];

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

             names[i] = children[i].getName().getBaseName();

         }

         return names;

     }

     protected void doDelete() throws FileSystemException {

         super.doDelete();

         ref = null;

     }

     protected void doRename(FileObject newFile) throws Exception {

         getRealFile().moveTo(((ContentCacheFileObject) newFile));

         ref = null;

     }

     protected void doCreateFolder() throws FileSystemException {

         super.doCreateFolder();

         ref = null;

     }

     protected void doSetLastModifiedTime(long time) throws FileSystemException {

         lastModified = time;

         super.doSetLastModifiedTime(time);

     }

     protected RandomAccessContent doGetRandomAccessContent(RandomAccessMode mode) throws FileSystemException {

         throw new UnsupportedOperationException("foo");

     }

     protected OutputStream doGetOutputStream(boolean append) throws FileSystemException {

         return new FilterOutputStream(getRealFile().getContent().getOutputStream(append)) {

             public void close() throws IOException {

                 super.close();

                 ref = null;

             }

         };

     }

 }