package org.jscsi.target.connection;

 import java.io.IOException;

 import java.nio.channels.ClosedChannelException;

 import java.nio.channels.SocketChannel;

 import java.security.DigestException;

 import org.jscsi.exception.InternetSCSIException;

 import org.jscsi.parser.BasicHeaderSegment;

 import org.jscsi.parser.InitiatorMessageParser;

 import org.jscsi.parser.OperationCode;

 import org.jscsi.parser.ProtocolDataUnit;

 import org.jscsi.parser.ProtocolDataUnitFactory;

 import org.jscsi.parser.TargetMessageParser;

 import org.jscsi.parser.scsi.SCSICommandParser;

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

 import org.jscsi.target.settings.Settings;

 import org.jscsi.target.settings.SettingsException;

 import org.jscsi.target.settings.TextKeyword;

 import org.jscsi.target.util.Debug;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * Instances of this class are used by {@link Connection} objects for sending and receiving {@link ProtocolDataUnit}

  * objects.

  * 

  * @author Andreas Ergenzinger, University of Konstanz

  */

 public class TargetSenderWorker {

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

     /**

      * The connection which uses this object for sending and receiving PDUs.

      */

     final private Connection connection;

     /**

      * The session to which {@link #connection} belongs to.

      */

     private TargetSession session;

     /**

      * Used for writing serialized PDUs to and reading serialized PDUs from.

      */

     final private SocketChannel socketChannel;

     /**

      * Will be used to create {@link ProtocolDataUnit} objects from the byte stream read from the {@link #socketChannel}

      * .

      */

     final private ProtocolDataUnitFactory protocolDataUnitFactory;

     /**

      * If this is <code>true</code>, then the next PDU read from the {@link #socketChannel} will be the first PDU

      * received in the {@link #session}.

      * <p>

      * Will be initializes to <code>true</code> if and only if the {@link #connection} is the leading connection of its

      * session.

      * <p>

      * PDUs identified by this variable as the first PDU in a session will not have their counters (i.e. CmdSN and

      * ExpStatSN) checked. Instead the values of these counters will be used to initialize the targets local copies of

      * these counters that will be used to ensure that no PDUs have been lost in transit.

      */

     private boolean initialPdu;

     /**

      * Creates a new {@link TargetSenderWorker} object.

      * 

      * @param connection the connection that will use this object for sending and receiving PDUs

      * @param socketChannel used for sending and receiving serialized PDU to and from the target

      */

     public TargetSenderWorker (final Connection connection, final SocketChannel socketChannel) {

         this.connection = connection;

         this.socketChannel = socketChannel;

         protocolDataUnitFactory = new ProtocolDataUnitFactory();

         initialPdu = connection.isLeadingConnection();

     }

     /**

      * Sets the {@link #session} variable.

      * <p>

      * During the time this object is initialized, the {@link Connection#getSession()} method will return

      * <code>null</code>. Therefore {@link #session} must be set manually once the {@link TargetSession} object has been

      * created.

      * 

      * @param session the session of the {@link #connection}

      */

     void setSession (final TargetSession session) {

         this.session = session;

     }

     /**

      * This method does all the necessary steps, which are needed when a connection should be closed.

      * 

      * @throws IOException if an I/O error occurs.

      */

     public final void close () throws IOException {

         socketChannel.close();

     }

     /**

      * Receives a <code>ProtocolDataUnit</code> from the socket and appends it to the end of the receiving queue of this

      * connection.

      * 

      * @return Queue with the resulting units

      * @throws IOException if an I/O error occurs.

      * @throws InternetSCSIException if any violation of the iSCSI-Standard emerge.

      * @throws DigestException if a mismatch of the digest exists.

      * @throws SettingsException

      */

     ProtocolDataUnit receiveFromWire () throws DigestException , InternetSCSIException , IOException , SettingsException {

         ProtocolDataUnit pdu;

         if (initialPdu) {

             /*

              * The connection's ConnectionSettingsNegotiator has not been initialized, hence getSettings() would throw a

              * NullPointerException. Initialize PDU with default values, i.e. no digests.

              */

             pdu = protocolDataUnitFactory.create(TextKeyword.NONE,// header

                                                                   // digest

                     TextKeyword.NONE);// data digest

         } else {

             // use negotiated or (now available) default settings

             final Settings settings = connection.getSettings();

             pdu = protocolDataUnitFactory.create(settings.getHeaderDigest(), settings.getDataDigest());

         }

         try {

             pdu.read(socketChannel);

         } catch (ClosedChannelException e) {

             throw new InternetSCSIException(e);

         }

         if (LOGGER.isDebugEnabled()) LOGGER.debug("Receiving this PDU:\n" + pdu);

         // parse sequence counters

         final BasicHeaderSegment bhs = pdu.getBasicHeaderSegment();

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

         // final int commandSequenceNumber = parser.getCommandSequenceNumber();

         // final int expectedStatusSequenceNumber = parser.getExpectedStatusSequenceNumber();

         if (LOGGER.isDebugEnabled()) {

             // sharrajesh

             // Needed to debug, out of order receiving of StatusSN and ExpStatSN

             if (bhs.getOpCode() == OperationCode.SCSI_COMMAND) {

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

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

                 LOGGER.debug("scsiOpCode = " + scsiOpCode);

                 LOGGER.debug("CDB bytes: \n" + Debug.byteBufferToString(scsiParser.getCDB()));

             }

             // LOGGER.debug("parser.expectedStatusSequenceNumber: " + expectedStatusSequenceNumber);

             if (connection == null)

                 LOGGER.debug("connection: null");

             else if (connection.getStatusSequenceNumber() == null)

                 LOGGER.debug("connection.getStatusSequenceNumber: null");

             else

                 LOGGER.debug("connection.getStatusSequenceNumber: " + connection.getStatusSequenceNumber().getValue());

         }

         // if this is the first PDU in the leading connection, then

         // initialize the session's ExpectedCommandSequenceNumber

         if (initialPdu) {

             initialPdu = false;

             // PDU is immediate Login PDU, checked in Target.main(),

             // ExpCmdSN of this PDU will be used to initialize the

             // respective session and connection parameters (sequence numbers)

             // see TargetSession and TargetConnection initialization in

             // Target.main()

         } else {

             // check sequence counters

             // if (session.getMaximumCommandSequenceNumber().lessThan(commandSequenceNumber))

             // throw new InternetSCSIException("received CmdSN > local MaxCmdSN");

             // verified, is working with Windows 8 initiator

             // if (!connection.getStatusSequenceNumber().equals(expectedStatusSequenceNumber)

             // && expectedStatusSequenceNumber != 0)// required by MS iSCSI

             // // initiator DATA-OUT

             // // PDU sequence

             // throw new InternetSCSIException("received ExpStatusSN != local StatusSN + 1");

         }

         // increment CmdSN if not immediate PDU (or Data-Out PDU)

         try {

             if (parser.incrementSequenceNumber()) session.getExpectedCommandSequenceNumber().increment();

         } catch (NullPointerException exc) {

         }

         return pdu;

     }

     /**

      * Sends the given <code>ProtocolDataUnit</code> instance over the socket to the connected iSCSI Target.

      * 

      * @param pdu The <code>ProtocolDataUnit</code> instances to send.

      * @throws InternetSCSIException if any violation of the iSCSI-Standard emerge.

      * @throws IOException if an I/O error occurs.

      * @throws InterruptedException if another caller interrupted the current caller before or while the current caller

      *             was waiting for a notification. The interrupted status of the current caller is cleared when this

      *             exception is thrown.

      */

     final void sendOverWire (final ProtocolDataUnit pdu) throws InternetSCSIException , IOException , InterruptedException {

         // set sequence counters

         final TargetMessageParser parser = (TargetMessageParser) pdu.getBasicHeaderSegment().getParser();

         parser.setExpectedCommandSequenceNumber(session.getExpectedCommandSequenceNumber().getValue());

         parser.setMaximumCommandSequenceNumber(session.getMaximumCommandSequenceNumber().getValue());

         final boolean incrementSequenceNumber = parser.incrementSequenceNumber();

         if (incrementSequenceNumber) // set StatSN only if field is not reserved

         parser.setStatusSequenceNumber(connection.getStatusSequenceNumber().getValue());

         if (LOGGER.isDebugEnabled()) LOGGER.debug("Sending this PDU:\n" + pdu);

         // send pdu

         pdu.write(socketChannel);

         // increment StatusSN if this was a Response PDU (with status)

         // or if special cases apply

         if (incrementSequenceNumber) connection.getStatusSequenceNumber().increment();

     }

 }