////////////////////////////////////////////////////////////////////////////////
   // 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;
  
  import org.millscript.commons.alert.alerts.IOAlert;
  import org.millscript.office.endianness.BigEndianDecoder;
  import org.millscript.office.endianness.EndianDecoder;
  import org.millscript.office.endianness.LittleEndianDecoder;
  
  import java.io.IOException;
  import java.io.RandomAccessFile;
  
  
  public class Header {
  
      public static final byte[] COMPOUND_DOCUMENT_FILE_IDENT = new byte[] { -48, -49, 17, -32, -95, -79, 26, -31 };
  
      private final int directorySID;
  
      private final EndianDecoder endianDecoder;
  
      private final int[] masterSectorAllocationTable;
  
      private final int masterSectorAllocationTableSID;
  
      private final int minimumStandardStreamSize;
  
      private final int[] sectorAllocationTable;
  
      private final int sectorsInMasterSectorAllocationTable;
  
      private final int sectorsInSectorAllocationTable;
  
      private final int sectorsInShortSectorAllocationTable;
  
      private final int sectorSize;
  
      private final int[] shortSectorAllocationTable;
  
      private final int shortSectorAllocationTableSID;
  
      private final int shortSectorSize;
  
      public Header( final RandomAccessFile randomFile ) throws IOException {
          // Validate the header identifies itself as a compound document
          final byte[] header = new byte[ 512 ];
          randomFile.readFully( header );
          for ( int i = 0; i < 8; i++ ) {
              if ( header[ i ] != COMPOUND_DOCUMENT_FILE_IDENT[ i ] ) {
                  throw new IOAlert(
                      "This is not a compound document"
                  ).mishap();
              }
          }
          // Discover the byte order
          if ( header[ 28 ] == -2 && header[ 29 ] == -1 ) {
              // Little-Endian
              this.endianDecoder = new LittleEndianDecoder();
          } else if ( header[ 28 ] == -1 && header[ 29 ] == -2 ) {
              // Big-Endian
              this.endianDecoder = new BigEndianDecoder();
          } else {
              // Ooops. The byte order identifier is invalid.
              throw new IOAlert(
                  "Invalid byte order identifier"
              ).culprit(
                  "first byte",
                  header[ 28 ]
              ).culprit(
                  "second byte",
                  header[ 29 ]
              ).mishap();
          }
          // Extract the sector size
          final int ssz = this.endianDecoder.decode2ByteInt( header, 30 );
          if ( ssz < 7 ) {
              throw new IOAlert(
                  "Sector size cannot be less than 7(i.e. 128 bytes)"
              ).culprit(
                  "sector size",
                  ssz
             ).mishap();
         } else {
             this.sectorSize = 2 << ssz - 1;
         }
         // Extract the short sector size
         final int sssz = this.endianDecoder.decode2ByteInt( header, 32 );
         if ( sssz > ssz ) {
             throw new IOAlert(
                 "Short sector size cannot be larger than the normal sector size"
             ).culprit(
                 "short sector size",
                 sssz
             ).culprit(
                 "sector size",
                 ssz
             ).mishap();
         }
         this.shortSectorSize = 2 << sssz - 1;
         // Extract the number of sections in the SAT 
         this.sectorsInSectorAllocationTable = this.endianDecoder.decode4ByteInt( header, 44 );
         // Extract the SID of the directory
         this.directorySID = this.endianDecoder.decode4ByteInt( header, 48 );
         // Extract the minimum size for a standard stream
         this.minimumStandardStreamSize = this.endianDecoder.decode4ByteInt( header, 56 );
         // Extract the short-SAT SID
         this.shortSectorAllocationTableSID = this.endianDecoder.decode4ByteInt( header, 60 );
         // Extract the number of sectors in the short-SAT
         this.sectorsInShortSectorAllocationTable = this.endianDecoder.decode4ByteInt( header, 64 );
         // Extract the SID of the first sector of the master SAT
         this.masterSectorAllocationTableSID = this.endianDecoder.decode4ByteInt( header, 68 );
         // Extract the number of sectors in the master SAT
         this.sectorsInMasterSectorAllocationTable = this.endianDecoder.decode4ByteInt( header, 72 );
         // Read the master sector allocation table
         this.masterSectorAllocationTable = this.readMasterSectorAllocationTable( randomFile, header );
         // Read the sector allocation table
         this.sectorAllocationTable = this.readSectorAllocationTable( randomFile );
         // Read the short sector allocation table
         this.shortSectorAllocationTable = this.readShortSectorAllocationTable( randomFile );
     }
 
     /**
      * @return Returns the directorySID.
      */
     public int getDirectorySID() {
         return directorySID;
     }
 
     /**
      * @return Returns the endianDecoder.
      */
     public EndianDecoder getEndianDecoder() {
         return endianDecoder;
     }
 
     /**
      * @return Returns the masterSectorAllocationTableSID.
      */
     public int getMasterSectorAllocationTableSID() {
         return masterSectorAllocationTableSID;
     }
 
     /**
      * @return Returns the minimumStandardStreamSize.
      */
     public int getMinimumStandardStreamSize() {
         return minimumStandardStreamSize;
     }
 
     public int[] getSectorChain( final int sid ) {
         // First calculate the number of sectors in the chain
         int index = 1;
         int currentSid = this.sectorAllocationTable[ sid ];
         while ( currentSid != -2 ) {
             switch ( currentSid ) {
                 case -1:
                     throw new IOAlert(
                         "Unexpected end of chain in sector allocation table"
                     ).mishap();
                 case -3:
                     throw new IOAlert(
                         "Unexpected sector allocation table sector in chain"
                     ).mishap();
                 case -4:
                     throw new IOAlert(
                         "Unexpected master sector allocation table sector in chain"
                     ).mishap();
             }
             index++;
             currentSid = this.sectorAllocationTable[ currentSid ];
         }
         // Now construct the chain
         final int[] chain = new int[ index ];
         // Set the index
         index = 0;
         // Reset the current sector
         currentSid = sid;
         // Now fill in the chain
         while ( currentSid != -2 ) {
             chain[ index ] = currentSid;
             index++;
             // Get the next sector in the chain
             currentSid = this.sectorAllocationTable[ currentSid ];
         }
         return chain;
     }
 
     /**
      * Returns the offset of the start of the sector with the given sector id.
      *
      * @param sid   the id of the sector whose offset is required
      * @return  the offset of the specified sector within the file
      */
     public long getSectorOffset( final int sid ) {
         return 512 + sid * this.sectorSize;
     }
 
     /**
      * @return Returns the sectorsInMasterSectorAllocationTable.
      */
     public int getSectorsInMasterSectorAllocationTable() {
         return sectorsInMasterSectorAllocationTable;
     }
 
     /**
      * @return Returns the sectorsInSectorAllocationTable.
      */
     public int getSectorsInSectorAllocationTable() {
         return sectorsInSectorAllocationTable;
     }
 
     /**
      * @return Returns the sectorsInShortSectorAllocationTable.
      */
     public int getSectorsInShortSectorAllocationTable() {
         return sectorsInShortSectorAllocationTable;
     }
 
     /**
      * @return Returns the sectorSize.
      */
     public int getSectorSize() {
         return sectorSize;
     }
 
     /**
      * @return Returns the shortSectorAllocationTableSID.
      */
     public int getShortSectorAllocationTableSID() {
         return shortSectorAllocationTableSID;
     }
 
     public int[] getShortSectorChain( final int sid ) {
         // First calculate the number of sectors in the chain
         int index = 1;
         int currentSid = this.shortSectorAllocationTable[ sid ];
         while ( currentSid != -2 ) {
             switch ( currentSid ) {
                 case -1:
                     throw new IOAlert(
                         "Unexpected end of chain in short sector allocation table"
                     ).mishap();
                 case -3:
                     throw new IOAlert(
                         "Unexpected sector allocation table sector in chain"
                     ).mishap();
                 case -4:
                     throw new IOAlert(
                         "Unexpected master sector allocation table sector in chain"
                     ).mishap();
             }
             index++;
             currentSid = this.shortSectorAllocationTable[ currentSid ];
         }
         // Now construct the chain
         final int[] chain = new int[ index ];
         // Set the index
         index = 0;
         // Reset the current sector
         currentSid = sid;
         // Now fill in the chain
         while ( currentSid != -2 ) {
             chain[ index ] = currentSid;
             index++;
             // Get the next sector in the chain
             currentSid = this.shortSectorAllocationTable[ currentSid ];
         }
         return chain;
     }
 
     /**
      * @return Returns the shortSectorSize.
      */
     public int getShortSectorSize() {
         return shortSectorSize;
     }
 
     /**
      * Checks if the specified directory entry refers to a short stream.
      *
      * @param entry the directory entry to test
      * @return  <code>true</code> if the specified directory entry is for a
      * short stream and <code>false</code> otherwise
      */
     public boolean isShortStream( final DirectoryEntry entry ) {
         return entry.getStreamSize() < this.getMinimumStandardStreamSize();
     }
 
     public int[] readMasterSectorAllocationTable( final RandomAccessFile randomFile, final byte[] header ) throws IOException {
         final int[] mSAT = new int[ 109 + this.sectorSize * this.sectorsInMasterSectorAllocationTable ];
         byte[] buffer = header;
         int offset = 76;
         // Decode the master sector allocation table. Up to the first 109 SID's
         // of that are held in the document header.
         for ( int i = 0; i < mSAT.length; offset += 4, i++ ) {
             final int sid = this.endianDecoder.decode4ByteInt( buffer, offset );
             if ( sid == -2 ) {
                 // We're at the end of the MSAT. We can infer that we must be
                 // in a sector outside the header too.
                 if ( i + 1 != mSAT.length ) {
                     // Note that we do not add 1 to i here, as i is ready
                     // to store the current sid in the mSAT array. i.e. it
                     // has already been incremented
                     final int[] retval = new int[ i ];
                     System.arraycopy( mSAT, 0, retval, 0, i );
                     return retval;
                 } else {
                     break;
                 }
             } else if ( sid == -1 ) {
                 // We've got an SID of -1(free sector) so we must be in the
                 // header still, otherwise this is an error
                 if ( this.masterSectorAllocationTableSID == -2 ) {
                     // Ok, the MSAT doesn't extend outside the header so we
                     // must be at the end.
                     if ( i + 1 != mSAT.length ) {
                         // Note that we do not add 1 to i here, as i is ready
                         // to store the current sid in the mSAT array. i.e. it
                         // has already been incremented
                         final int[] retval = new int[ i ];
                         System.arraycopy( mSAT, 0, retval, 0, i );
                         return retval;
                     } else {
                         break;
                     }
                 } else {
                     // We've got an SID of -1(free sector)
                     throw new IOAlert(
                         "Unexpected end of master sector allocation table"
                     ).mishap();
                 }
             } else if ( offset + 4 == buffer.length && i + 1 != mSAT.length ) {
                 // We have got to the last element in the current sector but it
                 // is not the last element of the master sector allocation
                 // table, so jump to the next sector.
                 randomFile.seek( this.getSectorOffset( sid ) );
                 buffer = new byte[ this.sectorSize ];
                 randomFile.readFully( buffer );
                 offset = 0;
                 final int sid2 = this.endianDecoder.decode4ByteInt( buffer, offset );
                 mSAT[ i ] = sid2;
             } else {
                 mSAT[ i ] = sid;
             }
         }
         return mSAT;
     }
 
     public int[] readSectorAllocationTable( final RandomAccessFile randomFile ) throws IOException {
         final int[] SAT = new int[ this.sectorSize * this.sectorsInSectorAllocationTable >> 2 ];
         int satOffset = 0;
         for ( int i = 0; i < this.masterSectorAllocationTable.length; i++ ) {
             // Intialise a buffer to store the sector data
             final byte[] sector = new byte[ this.sectorSize ];
             // Read the sector of information for the current SID
             randomFile.seek(
                 this.getSectorOffset( this.masterSectorAllocationTable[ i ] )
             );
             randomFile.readFully( sector );
             // Now append all the SAT information from this sector
             for ( int sectorOffset = 0; sectorOffset < sector.length; sectorOffset += 4 ) {
                 SAT[ satOffset++ ] = this.endianDecoder.decode4ByteInt( sector, sectorOffset );
             }
         }
         return SAT;
     }
 
     public int[] readShortSectorAllocationTable( final RandomAccessFile randomFile ) throws IOException {
         final int[] SSAT = new int[ this.sectorSize * this.sectorsInShortSectorAllocationTable >> 2 ];
         int ssatOffset = 0;
         final int[] shortSATSectorChain = this.getSectorChain( this.shortSectorAllocationTableSID ); 
         for ( int i = 0; i < shortSATSectorChain.length; i++ ) {
             // Intialise a buffer to store the sector data
             final byte[] sector = new byte[ this.sectorSize ];
             // Read the sector of information for the current SID
             randomFile.seek(
                 this.getSectorOffset( shortSATSectorChain[ i ] )
             );
             randomFile.readFully( sector );
             // Now append all the SAT information from this sector
             for ( int sectorOffset = 0; sectorOffset < sector.length; sectorOffset += 4 ) {
                 SSAT[ ssatOffset++ ] = this.endianDecoder.decode4ByteInt( sector, sectorOffset );
             }
         }
         return SSAT;
     }
 
 }