////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2005 Kevin Rogers
   //
   // This file is part of MillScript.
   //
   // MillScript is free software; you can redistribute it and/or modify it under
   // the terms of the GNU General Public License as published by the Free
   // Software Foundation; either version 2 of the License, or (at your option)
  // any later version.
  //
  // MillScript is distributed in the hope that it will be useful, but WITHOUT
  // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  // more details.
  //
  // You should have received a copy of the GNU General Public License along with
  // MillScript; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.commons.vfs;
  
  import org.millscript.commons.alert.Alert;
  import org.millscript.commons.alert.AlertDecorator;
  import org.millscript.commons.alert.alerts.Fault;
  import org.millscript.commons.alert.alerts.IOAlert;
  import org.millscript.commons.vfs.alerts.VEntryNotFoundAlert;
  import org.millscript.commons.vfs.protocols.file.LocalFile;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Reader;
  import java.io.Writer;
  import java.net.URI;
  
  /**
   * This class provides the skeletal implementation of a virtual filesystem
   * file,
   */
  public abstract class AbstractVFile< V extends VVolume > extends AbstractVEntry< V > implements AlertDecorator, VFile {
  
      /**
       * Constructs a new virtual filesystem file with the specified name,
       * parent folder and volume.
       *
       * @param vol   the volume this entry is held on
       * @param parent    the parent folder for this file
       * @param name  the name of the file
       */
      public AbstractVFile( final V vol, final VFolder parent, final String name ) {
          super( vol, parent, name );
      }
  
      /**
       * @see org.millscript.commons.vfs.VEntry#appendRelativePath(java.lang.StringBuffer)
       */
      public final StringBuffer appendRelativePath( final StringBuffer buff ) {
          // If we have a parent, append it's relative path to the buffer.
          // This will recurse all the way up the chain to give us the relative
          // path from the root of the filesystem.
          if ( this.getParent() != null ) {
              this.getParent().appendRelativePath( buff );
          }
          return buff.append( this.getName() );
      }
  
      /**
       * @see org.millscript.commons.vfs.VEntry#appendRelativePathOnVolume(java.lang.StringBuffer)
       */
      public StringBuffer appendRelativePathOnVolume( final StringBuffer buff ) {
          // If we have a parent and it's volume is the same as ours, append it's
          // relative path to the buffer.
          // This will recurse all the way up the chain to the root of the volume
          // this file belongs on, to give us the relative path from the root of
          // the volume.
          // TODO - This should probably use equality not identity but we need
          // implementations of hashCode() and equals()
          if ( this.getParent() == null ) {
              // Ah. No parent, so we must be at the top of the hierarchy
              return buff.append( this.getName() );
          } else if ( this.getParent().getVolume() == this.getVolume() ) {
              // The parent volume is the same as this one, so we should append
              // the parents path as it's on the same volume
              this.getParent().appendRelativePathOnVolume( buff );
          }
          return buff.append( this.getName() );
      }
  
      /**
       * @see org.millscript.commons.vfs.VEntry#appendURI(java.lang.StringBuffer)
       */
      public final StringBuffer appendURI( final StringBuffer buffer ) {
          // If we have a parent, append it's URI to the buffer.
          // This will recurse all the way up the chain to give us the complete
         // URI for this entry
         if ( this.getParent() == null ) {
             // No parent - this is the root entry
             this.getVolume().appendBaseURI( buffer );
         } else {
             // We have a parent, so append it's URI
             this.getParent().appendURI( buffer );
         }
         return buffer.append( this.getName() );
     }
 
     /**
      * @see org.millscript.commons.alert.AlertDecorator#decorate(org.millscript.commons.alert.Alert)
      */
     public Alert decorate( final Alert alert ) {
         return alert.culprit( "vfile", this );
     }
 
     /**
      * @see org.millscript.commons.vfs.VFile#getAppendWriter()
      */
     public final Writer getAppendWriter() {
         return new OutputStreamWriter(
             this.getAppendOutputStream(),
             this.getVolume().getParentVFS().getDefaultCharset()
         );
     }
 
     /**
      * @see org.millscript.commons.vfs.VFile#getContentMIMEType()
      */
     public String getContentMIMEType() {
         return this.getMIMEType( this.getName() );
     }
 
     /**
      * @see org.millscript.commons.vfs.VFile#getReader()
      */
     public final Reader getReader() {
         return new InputStreamReader(
             this.getInputStream(),
             this.getVolume().getParentVFS().getDefaultCharset()
         );
     }
 
     /**
      * @see org.millscript.commons.vfs.VFile#getWriter()
      */
     public final Writer getWriter() {
         return new OutputStreamWriter(
             this.getOutputStream(),
             this.getVolume().getParentVFS().getDefaultCharset()
         );
     }
 
     /**
      * @see org.millscript.commons.vfs.VFile#toLocal()
      */
     public LocalFile toLocal() {
         // TODO - Must add hook to remove temporary files
         // Get the virtual file name, to use as a template for the temporary
         // one
         final String originialFileName = this.getName();
         LocalFile tempFile;
         try {
             final String name = originialFileName.substring( 0, originialFileName.indexOf( '.' ) );
             final String extn = originialFileName.substring( originialFileName.indexOf( '.' ) );
             final URI localFileURI = File.createTempFile( name, extn, null ).toURI();
             tempFile = (LocalFile) this.getVolume().getParentVFS().resolveAsFile( localFileURI );
         } catch ( IOException ex ) {
             throw new IOAlert(
                 "Could not create a temporary copy of the virtual file"
             ).culpritURI( this.getURI() ).setParentThrowable( ex ).mishap();
         }
         InputStream source = null;
         OutputStream destination = null;
         try {
             // We have to put this code here to ensure proper clean up if
             // something goes wrong. e.g. the variables need to be declared
             // outside the try-block so that we can refer to them inside the
             // catch, to ensure that we free any resources used by the streams
             source = this.getInputStream();
             destination = tempFile.getOutputStream();
             // Get a buffer to use for copying the file
             final byte[] buffer = new byte[1024];
             int len = 0;
             // Transfer everything from the input to the output
             while ( ( len = source.read( buffer ) ) > 0 ) {
                  destination.write( buffer, 0, len );
             }
             source.close();
             destination.close();
             return tempFile;
         } catch ( FileNotFoundException ex ) {
             // Clean up - avoids leaking file descriptors
             try {
                 if ( source != null ) {
                     source.close();
                 }
                 if ( destination != null ) {
                     destination.close();
                 }
             } catch ( IOException ex2 ) {
                 throw new Fault(
                     "Failed to close input or output stream"
                 ).mishap();
             }
             // WTF? We've only just made it, but I suppose it could happen...
             throw new VEntryNotFoundAlert(
                 "Temporary file seems to have disappeared before we could open it!"
             ).setParentThrowable( ex ).mishap();
         } catch ( IOException ex ) {
             // Clean up - avoids leaking file descriptors
             try {
                 if ( source != null ) {
                     source.close();
                 }
                 if ( destination != null ) {
                     destination.close();
                 }
             } catch ( IOException ex2 ) {
                 throw new Fault(
                     "Failed to close input or output stream"
                 ).mishap();
             }
             throw new IOAlert(
                 "A problem occured transfering data from the virtual file to the temporary copy"
             ).culpritURI( this.getURI() ).setParentThrowable( ex ).mishap();
         }
     }
 
     /**
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         final StringBuffer buff = new StringBuffer( "VFILE( " );
         this.appendAbsolutePath( buff );
         buff.append( " )" );
         return buff.toString();
     }
 
 }