package org.jscsi.target.scsi.modeSense;
   
   
   import java.nio.ByteBuffer;
   
   import org.jscsi.target.scsi.IResponseData;
   
   
   /**
   * The mode parameter list contains a header, followed by zero or more block descriptors, followed by zero or more
   * variable-length mode pages.
   * <p>
   * This class uses the builder pattern to minimize the number of constructors and to avoid constructor use with a lot of
   * <code>null</code> parameters.
   * 
   * @author Andreas Ergenzinger
   */
  public final class ModeParameterList implements IResponseData {
  
      /**
       * The header contains information about the fields that follow.
       */
      private final ModeParameterHeader modeParameterHeader;
  
      /**
       * Contains the elements of the list of Logical Block Descriptors.
       */
      private final LogicalBlockDescriptor[] logicalBlockDescriptors;
  
      /**
       * Contains the elements of the list of Mode Pages.
       */
      private final ModePage[] modePages;
  
      /**
       * Returns a new {@link ModeParameterList} instance based the variables of the <i>builder</i> object. If these
       * variables are mutually exclusive, then this method will return <code>null</code> instead.
       * 
       * @param builder contains all necessary information to create a {@link ModeParameterList} object
       * @return a new {@link ModeParameterList} or <code>null</code>
       */
      public static ModeParameterList build (final ModeParameterListBuilder builder) {
          if (!builder.checkIntegrity()) return null;
          // everything is okay, so
          // - calculate block descriptor length
          int blockDescriptorLength;
          if (builder.logicalBlockDescriptors == null)
              blockDescriptorLength = 0;
          else {
              int singleLbdLength;
              if (builder.longLba)
                  singleLbdLength = LongLogicalBlockDescriptor.SIZE;
              else
                  singleLbdLength = ShortLogicalBlockDescriptor.SIZE;
              blockDescriptorLength = builder.logicalBlockDescriptors.length * singleLbdLength;
          }
          // - calculate mode data length
          int modeDataLength;
          // -- calculate contribution of the header without bytes of MODE DATA
          // LENGTH field
          if (builder.headerType == HeaderType.MODE_PARAMETER_HEADER_6)
              modeDataLength = ModeParameterHeader6.SIZE - ModeParameterHeader6.MODE_DATA_LENGTH_FIELD_SIZE;
          else
              modeDataLength = ModeParameterHeader10.SIZE - ModeParameterHeader10.MODE_DATA_LENGTH_FIELD_SIZE;
          // -- add length of logical block descriptors
          modeDataLength += blockDescriptorLength;
          // -- add length of mode pages
          if (builder.modePages != null) for (ModePage mp : builder.modePages)
              modeDataLength += mp.size();
  
          /*
           * It might be nice to check the values for overflow here, however this is not necessary, since the length of
           * all available/returned elements will always be less than 256.
           */
  
          ModeParameterHeader modeParameterHeader;
          if (builder.headerType == HeaderType.MODE_PARAMETER_HEADER_6)
              modeParameterHeader = new ModeParameterHeader6(modeDataLength, blockDescriptorLength);
          else
              modeParameterHeader = new ModeParameterHeader10(modeDataLength, blockDescriptorLength, builder.longLba);
  
          // create and return the ModeParameterList
          return new ModeParameterList(modeParameterHeader, builder.logicalBlockDescriptors, builder.modePages);
      }
  
      private ModeParameterList (final ModeParameterHeader modeParameterHeader, final LogicalBlockDescriptor[] logicalBlockDescriptors, final ModePage[] modePages) {
          this.modeParameterHeader = modeParameterHeader;
          this.logicalBlockDescriptors = logicalBlockDescriptors;
          this.modePages = modePages;
      }
  
      public void serialize (ByteBuffer byteBuffer, int index) {
  
          int offset = 0;
  
          // serialize header
          modeParameterHeader.serialize(byteBuffer, index);
          offset += modeParameterHeader.size();
  
         // serialize logical block descriptors
         if (logicalBlockDescriptors != null) for (LogicalBlockDescriptor lbd : logicalBlockDescriptors) {
             lbd.serialize(byteBuffer, index + offset);
             offset += lbd.size();
         }
 
         // serialize mode pages
         if (modePages != null) for (ModePage mp : modePages) {
             mp.serialize(byteBuffer, index + offset);
             offset += mp.size();
         }
     }
 
     public int size () {
         // size = header + logical block descriptors + mode pages
         int size = modeParameterHeader.size();
         if (logicalBlockDescriptors != null && logicalBlockDescriptors.length > 0) size += logicalBlockDescriptors[0].size() * logicalBlockDescriptors.length;// all
                                                                                                                                                               // have
                                                                                                                                                               // the
                                                                                                                                                               // same
                                                                                                                                                               // size
         if (modePages != null) for (ModePage mp : modePages)
             size += mp.size();
         return size;
     }
 }