package org.jscsi.target.connection.stage.fullfeature;
   
   
   import static org.jscsi.target.storage.IStorageModule.VIRTUAL_BLOCK_SIZE;
   
   import java.io.IOException;
   import java.nio.ByteBuffer;
   
   import org.jscsi.exception.InternetSCSIException;
  import org.jscsi.parser.BasicHeaderSegment;
  import org.jscsi.parser.ProtocolDataUnit;
  import org.jscsi.parser.scsi.SCSICommandParser;
  import org.jscsi.parser.scsi.SCSIResponseParser.ServiceResponse;
  import org.jscsi.parser.scsi.SCSIStatus;
  import org.jscsi.target.connection.TargetPduFactory;
  import org.jscsi.target.connection.phase.TargetFullFeaturePhase;
  import org.jscsi.target.scsi.ScsiResponseDataSegment;
  import org.jscsi.target.scsi.cdb.Read10Cdb;
  import org.jscsi.target.scsi.cdb.Read6Cdb;
  import org.jscsi.target.scsi.cdb.ReadCdb;
  import org.jscsi.target.scsi.cdb.ScsiOperationCode;
  import org.jscsi.target.settings.SettingsException;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * A stage for processing <code>READ (6)</code> and <code>READ (10)</code> SCSI commands.
   * 
   * @author Andreas Ergenzinger
   */
  public class ReadStage extends ReadOrWriteStage {
  
      private static final Logger LOGGER = LoggerFactory.getLogger(ReadStage.class);
  
      public ReadStage (final TargetFullFeaturePhase targetFullFeaturePhase) {
          super(targetFullFeaturePhase);
      }
  
      @Override
      public void execute (ProtocolDataUnit pdu) throws IOException , InterruptedException , InternetSCSIException , SettingsException {
  
          // get relevant variables ...
          // ... from settings
          final boolean immediateData = settings.getImmediateData();
  
          if (LOGGER.isDebugEnabled()) {
              LOGGER.debug("immediateData = " + immediateData);
              LOGGER.debug("maxRecvDataSegmentLength = " + settings.getMaxRecvDataSegmentLength());
          }
  
          // ... and from the PDU
          BasicHeaderSegment bhs = pdu.getBasicHeaderSegment();
          SCSICommandParser parser = (SCSICommandParser) bhs.getParser();
          final int initiatorTaskTag = bhs.getInitiatorTaskTag();
  
          // get the Read(6) or Read(10) CDB
          ReadCdb cdb;
          final ScsiOperationCode scsiOpCode = ScsiOperationCode.valueOf(parser.getCDB().get(0));
          if (scsiOpCode == ScsiOperationCode.READ_10)// most likely option first
              cdb = new Read10Cdb(parser.getCDB());
          else if (scsiOpCode == ScsiOperationCode.READ_6)
              cdb = new Read6Cdb(parser.getCDB());
          else {
              // anything else wouldn't be good (programmer error)
              // close connection
              throw new InternetSCSIException("wrong SCSI Operation Code " + scsiOpCode + " in ReadStage");
          }
  
          // check if requested blocks are out of bounds
          checkOverAndUnderflow(cdb);
  
          // check illegal field pointers
          if (cdb.getIllegalFieldPointers() != null) {
              // the command must fail
  
              LOGGER.debug("illegal field in Read CDB");
  
              // create and send error PDU and leave stage
              final ProtocolDataUnit responsePdu = createFixedFormatErrorPdu(cdb.getIllegalFieldPointers(),// senseKeySpecificData
                      initiatorTaskTag, parser.getExpectedDataTransferLength());
              connection.sendPdu(responsePdu);
              return;
          }
  
          final int totalTransferLength = VIRTUAL_BLOCK_SIZE * cdb.getTransferLength();
          final long storageOffset = VIRTUAL_BLOCK_SIZE * cdb.getLogicalBlockAddress();
  
          if (LOGGER.isDebugEnabled()) {
              LOGGER.debug("cdb.getLogicalBlockAddress() = " + cdb.getLogicalBlockAddress());
              LOGGER.debug("blockSize = " + VIRTUAL_BLOCK_SIZE);
              LOGGER.debug("totalTransferLength = " + totalTransferLength);
              LOGGER.debug("expectedDataSegmentLength = " + parser.getExpectedDataTransferLength());
          }
  
          // *** start sending ***
          // initialize counters and data segment buffer
          int bytesSent = 0;
          int dataSequenceNumber = 0;
         byte[] dataSegmentArray = null;
         ByteBuffer dataSegment = null;
         ProtocolDataUnit responsePdu;
 
         // *** send up to last but one Data-In PDU ***
         // (with DataSegmentSize == MaxRecvDataSegmentLength)
 
         if (bytesSent < totalTransferLength - settings.getMaxRecvDataSegmentLength()) {
             /*
              * Initialize dataSegmentArray and dataSegment with MaxRecvDataSegmentLength bytes.
              */
             dataSegmentArray = connection.getDataInArray(settings.getMaxRecvDataSegmentLength());
             dataSegment = ByteBuffer.wrap(dataSegmentArray);
         }
 
         while (bytesSent < totalTransferLength - settings.getMaxRecvDataSegmentLength()) {
 
             // get data and prepare data segment
             session.getStorageModule().read(dataSegmentArray, storageOffset + bytesSent);
 
             // create and send PDU
             responsePdu = TargetPduFactory.createDataInPdu(false,// finalFlag,
                                                                  // not the last
                                                                  // PDU with
                                                                  // data payload
                                                                  // in the
                                                                  // sequence
                     false,// acknowledgeFlag, ErrorRecoveryLevel == 0, so we
                           // never do that
                     false,// residualOverflowFlag
                     false,// residualUnderflowFlag
                     false,// statusFlag
                     SCSIStatus.GOOD,// status, actually reserved i.e. 0x0
                     0L,// logicalUnitNumber, reserved
                     initiatorTaskTag, 0xffffffff,// targetTransferTag
                     dataSequenceNumber,// dataSequenceNumber
                     bytesSent,// bufferOffset
                     0,// residualCount
                     dataSegment);
 
             connection.sendPdu(responsePdu);
 
             // increment counters
             ++dataSequenceNumber;
             bytesSent += settings.getMaxRecvDataSegmentLength();
         }
 
         /*
          * If ImmediateData=Yes has been negotiated, then a phase collapse has to take place, i.e. the status is sent in
          * the last Data-In PDU. Otherwise a separate SCSI Response PDU must follow.
          */
 
         // *** send last Data-In PDU ***
 
         // get data and prepare data segment
         final int bytesRemaining = totalTransferLength - bytesSent;
         dataSegmentArray = connection.getDataInArray(bytesRemaining);
         session.getStorageModule().read(dataSegmentArray, storageOffset + bytesSent);
         dataSegment = ByteBuffer.wrap(dataSegmentArray);
 
         // create and send PDU (with or without status)
         responsePdu = TargetPduFactory.createDataInPdu(true,// finalFlag, last
                                                             // PDU in the
                                                             // sequence with
                                                             // data payload
                 false,// acknowledgeFlag, ErrorRecoveryLevel == 0, so we never
                       // do that
                 false,// residualOverflowFlag
                 false,// residualUnderflowFlag
                 immediateData,// statusFlag
                 SCSIStatus.GOOD,// status, or not (reserved if no status)
                 0L,// logicalUnitNumber, reserved
                 initiatorTaskTag, 0xffffffff,// targetTransferTag
                 dataSequenceNumber,// dataSequenceNumber
                 bytesSent,// bufferOffset
                 0,// residualCount
                 dataSegment);
 
         LOGGER.debug("sending last Data-In PDU");
         connection.sendPdu(responsePdu);
 
         // send SCSI Response PDU?
         if (!immediateData) {
 
             responsePdu = TargetPduFactory.createSCSIResponsePdu(false,// bidirectionalReadResidualOverflow
                     false,// bidirectionalReadResidualUnderflow
                     false,// residualOverflow
                     false,// residualUnderflow
                     ServiceResponse.COMMAND_COMPLETED_AT_TARGET,// response
                     SCSIStatus.GOOD,// status
                     initiatorTaskTag,// initiatorTaskTag
                     0,// snackTag, reserved
                     0,// expectedDataSequenceNumber, reserved
                     0,// bidirectionalReadResidualCount
                     0,// residualCount
                     ScsiResponseDataSegment.EMPTY_DATA_SEGMENT);// empty
                                                                 // ScsiResponseDataSegment
 
             LOGGER.debug("sending SCSI Response PDU");
             connection.sendPdu(responsePdu);
         }
 
     }
 
 }