package org.jscsi.target.connection.phase;

 import java.io.IOException;

 import java.security.DigestException;

 import javax.naming.OperationNotSupportedException;

 import org.jscsi.exception.InternetSCSIException;

 import org.jscsi.parser.BasicHeaderSegment;

 import org.jscsi.parser.ProtocolDataUnit;

 import org.jscsi.parser.scsi.SCSICommandParser;

 import org.jscsi.target.connection.Connection;

 import org.jscsi.target.connection.stage.TMStage;

 import org.jscsi.target.connection.stage.fullfeature.FormatUnitStage;

 import org.jscsi.target.connection.stage.fullfeature.InquiryStage;

 import org.jscsi.target.connection.stage.fullfeature.LogoutStage;

 import org.jscsi.target.connection.stage.fullfeature.ModeSenseStage;

 import org.jscsi.target.connection.stage.fullfeature.PingStage;

 import org.jscsi.target.connection.stage.fullfeature.ReadCapacityStage;

 import org.jscsi.target.connection.stage.fullfeature.ReadStage;

 import org.jscsi.target.connection.stage.fullfeature.ReportLunsStage;

 import org.jscsi.target.connection.stage.fullfeature.RequestSenseStage;

 import org.jscsi.target.connection.stage.fullfeature.SendDiagnosticStage;

 import org.jscsi.target.connection.stage.fullfeature.TargetFullFeatureStage;

 import org.jscsi.target.connection.stage.fullfeature.TestUnitReadyStage;

 import org.jscsi.target.connection.stage.fullfeature.TextNegotiationStage;

 import org.jscsi.target.connection.stage.fullfeature.UnsupportedOpCodeStage;

 import org.jscsi.target.connection.stage.fullfeature.WriteStage;

 import org.jscsi.target.scsi.cdb.ScsiOperationCode;

 import org.jscsi.target.settings.SettingsException;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * Objects of this class represent the Target Full Feature Phase of a connection.

  * 

  * @see TargetPhase

  * @author Andreas Ergenzinger

  */

 public final class TargetFullFeaturePhase extends TargetPhase {

     private static final Logger LOGGER = LoggerFactory.getLogger(TargetFullFeaturePhase.class);

     /**

      * The current stage of this phase.

      */

     private TargetFullFeatureStage stage;

     /**

      * While this variable is <code>true</code> the phase is still running, either executing a specific stage or waiting

      * for the next one to begin.

      */

     private boolean running;

     /**

      * The constructor.

      * 

      * @param connection {@inheritDoc}

      */

     public TargetFullFeaturePhase (Connection connection) {

         super(connection);

     }

     /**

      * Starts the full feature phase.

      * 

      * @return {@inheritDoc}

      * @throws OperationNotSupportedException {@inheritDoc}

      * @throws IOException {@inheritDoc}

      * @throws InterruptedException {@inheritDoc}

      * @throws InternetSCSIException {@inheritDoc}

      * @throws DigestException {@inheritDoc}

      * @throws SettingsException {@inheritDoc}

      */

     public boolean execute () throws DigestException , IOException , InterruptedException , InternetSCSIException , SettingsException {

         running = true;

         while (running) {

             ProtocolDataUnit pdu = connection.receivePdu();

             BasicHeaderSegment bhs = pdu.getBasicHeaderSegment();

             // identify desired stage

             switch (bhs.getOpCode()) {

                 case SCSI_COMMAND :

                     if (connection.getTargetSession().isNormalSession()) {

                         final SCSICommandParser parser = (SCSICommandParser) bhs.getParser();

                         ScsiOperationCode scsiOpCode = ScsiOperationCode.valueOf(parser.getCDB().get(0));

                         LOGGER.debug("scsiOpCode = " + scsiOpCode);// log SCSI

                                                                    // Operation Code

                         if (scsiOpCode != null) {

                             switch (scsiOpCode) {

                                 case TEST_UNIT_READY :

                                     stage = new TestUnitReadyStage(this);

                                     break;

                                 case REQUEST_SENSE :

                                     stage = new RequestSenseStage(this);

                                     break;

                                 case FORMAT_UNIT :

                                     stage = new FormatUnitStage(this);

                                     break;

                                 case INQUIRY :

                                     stage = new InquiryStage(this);

                                     break;

                                 case MODE_SELECT_6 :

                                     stage = null;

                                     scsiOpCode = null;

                                     break;

                                 case MODE_SENSE_6 :

                                     stage = new ModeSenseStage(this);

                                     if (!((ModeSenseStage) stage).canHandle(pdu)) {

                                         stage = null;

                                         scsiOpCode = null;

                                     }

                                     break;

                                 case SEND_DIAGNOSTIC :

                                     stage = new SendDiagnosticStage(this);

                                     break;

                                 case READ_CAPACITY_10 :// use common read capacity stage

                                 case READ_CAPACITY_16 :

                                     stage = new ReadCapacityStage(this);

                                     break;

                                 case WRITE_6 :// use common write stage

                                 case WRITE_10 :

                                     stage = new WriteStage(this);

                                     break;

                                 case READ_6 :// use common read stage

                                 case READ_10 :

                                     stage = new ReadStage(this);

                                     break;

                                 case REPORT_LUNS :

                                     stage = new ReportLunsStage(this);

                                     break;

                                 default :

                                     scsiOpCode = null;

                             }

                         }// else, or if default block was entered (programmer error)

                         if (scsiOpCode == null) {

                             LOGGER.error("Unsupported SCSI OpCode 0x" + Integer.toHexString(parser.getCDB().get(0) & 255) + " in SCSI Command PDU.");

                             stage = new UnsupportedOpCodeStage(this);

                         }

                     } else {// session is discovery session

                         throw new InternetSCSIException("received SCSI command in discovery session");

                     }

                     break; // SCSI_COMMAND

                 case SCSI_TM_REQUEST :

                     stage = new TMStage(this);

                     break;

                 case NOP_OUT :

                     stage = new PingStage(this);

                     break;

                 case TEXT_REQUEST :

                     stage = new TextNegotiationStage(this);

                     break;

                 case LOGOUT_REQUEST :

                     stage = new LogoutStage(this);

                     running = false;

                     break;

                 default :

                     LOGGER.error("Recieved unsupported opcode for " + pdu.getBasicHeaderSegment().getOpCode());

                     stage = new UnsupportedOpCodeStage(this);

             }

             // process the PDU

             stage.execute(pdu);

         }

         return false;

     }

     /**

      * Stopping this phases execution

      */

     public void stop(){

         this.running = false;

     }

 }