////////////////////////////////////////////////////////////////////////////////
   // MillScript-Excel: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2006 Open World Ltd, Kevin Rogers
   //
   // This file is part of MillScript-Excel.
   //
   // MillScript-Excel 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-Excel 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-Excel; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.office.compound.vfs;
  
  import org.millscript.commons.alert.alerts.IOAlert;
  import org.millscript.commons.vfs.AbstractVFile;
  import org.millscript.commons.vfs.VFile;
  import org.millscript.commons.vfs.VFolder;
  import org.millscript.commons.vfs.alerts.VCannotOpenEntryAlert;
  import org.millscript.commons.vfs.alerts.VEntryNotFoundAlert;
  import org.millscript.commons.vfs.mime.AbstractMIMEVVolume;
  import org.millscript.office.compound.DirectoryEntry;
  import org.millscript.office.compound.Header;
  import org.millscript.office.endianness.EndianDecoder;
  
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.RandomAccessFile;
  
  /**
   * 
   */
  public class CompoundDocumentVolume extends AbstractMIMEVVolume {
  
      final RandomAccessFile compoundDocument;
  
      final DirectoryEntry[] directory;
  
      final EndianDecoder endianDecoder;
  
      final Header header;
  
      /**
       * @param backingFile
       */
      public CompoundDocumentVolume( final AbstractVFile< ? > sourceFile ) {
          super( sourceFile );
          try {
              this.compoundDocument = new RandomAccessFile( this.getTempBackingFile().getFile(), "r" );
              this.header = new Header( this.compoundDocument );
              this.endianDecoder = this.header.getEndianDecoder();
          } catch ( FileNotFoundException ex ) {
              if ( this.getTempBackingFile().getFile().isDirectory() ) {
                  // The file already exists and is a directory!
                  throw VCannotOpenEntryAlert.entryIsNotAFile( this.getTempBackingFile() ).setParentThrowable( ex ).mishap();
              }
              // The entry doesn't exist at all.
              throw VCannotOpenEntryAlert.fileNotFound( this.getTempBackingFile() ).setParentThrowable( ex ).mishap();
          } catch ( IOException ex ) {
              throw new IOAlert(
                  "Could not read compound document header"
              ).setParentThrowable( ex ).mishap();
          }
          this.directory = this.readDirectory();
      }
  
      /**
       * @return Returns the directory.
       */
      public DirectoryEntry[] getDirectory() {
          return directory;
      }
  
      DirectoryEntry getDirectoryEntry( final int did ) {
          if ( did <= this.directory.length ) {
              return this.directory[ did ];
          } else {
              throw VEntryNotFoundAlert.entryDoesNotExist().culprit(
                  "did",
                  did
              ).culprit(
                  "directory entries",
                  this.directory.length
              ).mishap();
          }
      }
  
      private DirectoryEntry[] readDirectory() {
          // Fetch the SID chain for the directory
          final int[] directorySIDChain = this.header.getSectorChain( this.header.getDirectorySID() );
          final byte[] rawData = this.readStream(
             directorySIDChain.length * this.header.getSectorSize(),
             directorySIDChain
         );
         final DirectoryEntry[] parsedData = new DirectoryEntry[ rawData.length / 128 ]; 
         for ( int did = 0; did < parsedData.length; did++ ) {
             parsedData[ did ] = new DirectoryEntry( this.endianDecoder, rawData, did );
         }
         return parsedData;
     }
 
     byte[] readStream( final DirectoryEntry entry ) {
         // Check the entries stream size against the minimum standard stream
         // size in the header
         if ( entry.getStreamSize() < this.header.getMinimumStandardStreamSize() ) {
             // It's a short stream
             return this.readShortStream(
                 entry.getStreamSize(),
                 this.header.getShortSectorChain( entry.getStreamSID() )
             );
         } else {
             // It's a normal stream
             return this.readStream(
                 entry.getStreamSize(),
                 this.header.getSectorChain( entry.getStreamSID() )
             );
         }
     }
 
     byte[] readStream( final int streamSize, final int[] sidChain ) {
         // Make the buffer for the stream
         final byte[] buffer = new byte[ streamSize ];
         try {
             // Read the stream into the buffer
             for ( int i = 0, offset = 0; i < sidChain.length; i++, offset += this.header.getSectorSize() ) {
                 // Seek to the sector for the current SID
                 this.compoundDocument.seek(
                     this.header.getSectorOffset( sidChain[ i ] )
                 );
                 // Now read the sector
                 if ( streamSize - offset < this.header.getSectorSize() ) {
                     this.compoundDocument.readFully( buffer, offset, streamSize - offset );
                 } else {
                     this.compoundDocument.readFully( buffer, offset, this.header.getSectorSize() );
                 }
             }
         } catch ( IOException e ) {
             throw new IOAlert(
                 "Could not read the compound document stream"
             ).mishap();
         }
         return buffer;
     }
 
     byte[] readShortStream( final int streamSize, final int[] sidChain ) {
           // Make the buffer for the stream
         final byte[] buffer = new byte[ streamSize ];
         // The short stream is made up of short sectors held in a normal stream
         // made of normal sectors.
         // Get the short stream container SID chain
         final int[] shortStreamContainerSidChain = this.header.getSectorChain( this.directory[ 0 ].getStreamSID() );
         try {
             // For each short sector we need to work out the offset within the
             // short stream container, then work out the sector which contains
             // that part of the short stream container and the offset within
             // that sector. Phew.
             // Read the short stream into the buffer
             for ( int i = 0, offset = 0; i < sidChain.length; i++, offset += this.header.getShortSectorSize() ) {
                 // Now for each short sector we need to work out where it is in
                 // overall document, e.g. the sector which contains it and the
                 // offset within that sector...
                 final int requiredSectorIndex = offset / this.header.getSectorSize();
                 final int offsetWithinSector = offset % this.header.getSectorSize();
                 // Seek to the short sector for the current SID
                 this.compoundDocument.seek(
                     offsetWithinSector + this.header.getSectorOffset(
                         shortStreamContainerSidChain[ requiredSectorIndex ]
                     )
                 );
                 // Now read the sector
                 if ( streamSize - offset < this.header.getShortSectorSize() ) {
                     this.compoundDocument.readFully( buffer, offset, streamSize - offset );
                 } else {
                     this.compoundDocument.readFully( buffer, offset, this.header.getShortSectorSize() );
                 }
             }
         } catch ( IOException ex ) {
             throw new IOAlert(
                 "Could not read the compound document short stream"
             ).mishap();
         }
         return buffer;
     }
 
     /**
      * @see org.millscript.commons.vfs.mime.AbstractMIMEVVolume#makeRootVFolder(org.millscript.commons.vfs.VFile)
      */
     @Override
     protected VFolder makeRootVFolder( final VFile sourceFile ) {
         return new CompoundDocumentFolder( this, sourceFile.getParent(), 0 );
     }
 
 }