package org.jscsi.target.connection;
   
   
   import java.io.IOException;
   import java.nio.channels.SocketChannel;
   import java.security.DigestException;
   import java.util.concurrent.Callable;
   
   import javax.naming.OperationNotSupportedException;
  
  import org.jscsi.exception.InternetSCSIException;
  import org.jscsi.parser.OperationCode;
  import org.jscsi.parser.ProtocolDataUnit;
  import org.jscsi.target.connection.phase.TargetFullFeaturePhase;
  import org.jscsi.target.connection.phase.TargetLoginPhase;
  import org.jscsi.target.connection.phase.TargetPhase;
  import org.jscsi.target.connection.stage.fullfeature.PingStage;
  import org.jscsi.target.connection.stage.fullfeature.ReadStage;
  import org.jscsi.target.settings.ConnectionSettingsNegotiator;
  import org.jscsi.target.settings.SessionSettingsNegotiator;
  import org.jscsi.target.settings.Settings;
  import org.jscsi.target.settings.SettingsException;
  import org.jscsi.target.util.FastByteArrayProvider;
  import org.jscsi.target.util.SerialArithmeticNumber;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * A class for objects representing an iSCSI connection with all necessary variables.
   * <p>
   * Each {@link TargetConnection} runs in a separate {@link Thread}. The conceptually most important parts of its
   * behavior can be likened to a finite state machine (FSM), in which the most basic states (stages) are grouped into
   * more general states (phases). Commands send by the initiator are carried out in these stages, usually without
   * transitioning to a different phase. A connection's current phase determines which stages are reachable, limiting the
   * kind of commands the initiator may issue at any given moment.
   * 
   * @author Andreas Ergenzinger
   */
  public interface Connection extends Callable<Void> {
  
      Settings getSettings ();
  
      SerialArithmeticNumber getStatusSequenceNumber ();
  
      boolean isLeadingConnection ();
  
      ProtocolDataUnit receivePdu () throws DigestException , InternetSCSIException , IOException , SettingsException;
  
      void sendPdu (ProtocolDataUnit pDataUnit) throws InterruptedException , IOException , InternetSCSIException;
  
      ConnectionSettingsNegotiator getConnectionSettingsNegotiator ();
  
      void setSession (TargetSession pSession);
  
      TargetSession getTargetSession ();
  
      void setStatusSequenceNumber (int pStatusSequenceNumber);
  
      void initializeConnectionSettingsNegotiator (SessionSettingsNegotiator pSettingsNegotiator);
  
      byte[] getDataInArray (int pLength);
      
      public boolean stop();
  
      public static class TargetConnection implements Connection {
  
          private static final Logger LOGGER = LoggerFactory.getLogger(TargetConnection.class);
  
          /**
           * The {@link TargetSession} this connection belongs to.
           */
          private TargetSession targetSession;
  
          /**
           * The {@link TargetSenderWorker} used by this connection for sending and receiving {@link ProtocolDataUnit}s.
           */
          TargetSenderWorker senderWorker;
  
          /**
           * The {@link ConnectionSettingsNegotiator} of this connection responsible for negotiating and storing
           * connection parameters which have been negotiated with or declared by the initiator.
           */
          private ConnectionSettingsNegotiator connectionSettingsNegotiator;
  
          /**
           * The current {@link TargetPhase} describing a general state of the connection.
           */
          private TargetPhase phase;
  
          /**
           * A counter for the <code>StatSN</code> field of sent {@link ProtocolDataUnit} objects with Status.
           */
          private SerialArithmeticNumber statusSequenceNumber;
  
          /**
           * Will manage and serve as a source of byte arrays to be used for sending Data In PDUs in the {@link ReadStage}
           * .
           */
         private FastByteArrayProvider dataInArrayProvider = new FastByteArrayProvider(4);
 
         /**
          * <code>true</code> if and only if this connection is the first connection to be associated with its parent
          * session.
          * <p>
          * This distinction is necessary because some parameters may only be declared over the leading connection.
          */
         private final boolean isLeadingConnection;
 
         /**
          * The last {@link ProtocolDataUnit} received on this connection.
          */
         private ProtocolDataUnit lastReceivedPDU;
 
         /**
          * The {@link TargetConnection} constructor.
          * 
          * @param socketChannel used for sending and receiving PDUs
          * @param isLeadingConnection <code>true</code> if and only if this connection is the first connection
          *            associated with its enclosing session
          */
         public TargetConnection (SocketChannel socketChannel, final boolean isLeadingConnection) {
             this.isLeadingConnection = isLeadingConnection;
             senderWorker = new TargetSenderWorker(this, socketChannel);
         }
 
         /**
          * Returns a byte array that can be used for holding data segment data of Data In PDUs sent during the
          * {@link ReadStage}.
          * 
          * @param length the length of the array
          * @return a byte array of the specified length
          */
         public byte[] getDataInArray (final int length) {
             return dataInArrayProvider.getArray(length);
         }
 
         /**
          * Returns the {@link TargetSession} this connection belongs to.
          * 
          * @return the {@link TargetSession} this connection belongs to
          */
         TargetSession getSession () {
             return targetSession;
         }
 
         /**
          * Sets the {@link TargetSession} this connection belongs to.
          * 
          * @param session the {@link TargetSession} this connection belongs to
          */
         public void setSession (TargetSession session) {
             this.targetSession = session;
             senderWorker.setSession(session);
         }
 
         /**
          * Returns the next {@link ProtocolDataUnit} to be received on the connection.
          * <p>
          * The method will block until a PDU has been completely received.
          * 
          * @return the next received PDU
          * @throws DigestException if a digest error has occured
          * @throws InternetSCSIException if a general iSCSI protocol error has been detected
          * @throws IOException if the connection was closed
          * @throws SettingsException will not happen
          */
         public ProtocolDataUnit receivePdu () throws DigestException , InternetSCSIException , IOException , SettingsException {
             lastReceivedPDU = senderWorker.receiveFromWire();
 
             if (lastReceivedPDU.getBasicHeaderSegment().getOpCode().equals(OperationCode.NOP_OUT)) {
                 try {
                     // System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Handling ping immediately..");
                     // System.out.println("******************************\nRecieving\nSystem Time: " + new
                     // java.sql.Timestamp(System.currentTimeMillis()).toString() + "\n" + lastReceivedPDU +
                     // "\n******************************");
                     new PingStage(new TargetFullFeaturePhase(this)).execute(lastReceivedPDU);
                 } catch (InterruptedException e) {}
                 lastReceivedPDU = senderWorker.receiveFromWire();
             }
 
             // System.out.println("******************************\nRecieving\nSystem Time: " + new
             // java.sql.Timestamp(System.currentTimeMillis()).toString() + "\n" + lastReceivedPDU +
             // "\n******************************");
             return lastReceivedPDU;
         }
 
         /**
          * Serializes and sends a {@link ProtocolDataUnit} over the connection.
          * 
          * @param pdu the PDU to send
          * @throws InterruptedException
          * @throws IOException
          * @throws InternetSCSIException
          */
         public void sendPdu (ProtocolDataUnit pdu) throws InterruptedException , IOException , InternetSCSIException {
             // System.out.println("******************************\nSending\nSystem Time: " + new
             // java.sql.Timestamp(System.currentTimeMillis()).toString() + "\n" + pdu +
             // "\n******************************");
             senderWorker.sendOverWire(pdu);
         }
 
         /**
          * Starts the processing of PDUs by this connection.
          * <p>
          * For this method to work properly, the leading PDU send by the initiator over this connection must have been
          * received via {@link #receivePdu()}.
          * 
          */
         public Void call () {
 
             try {
                 // *** login phase ***
                 phase = new TargetLoginPhase(this);
                 if (phase.execute(lastReceivedPDU)) {
                     LOGGER.debug("Login Phase successful");
 
                     // if this is the leading connection, set the session type
                     final Settings settings = getSettings();
                     if (isLeadingConnection) targetSession.setSessionType(SessionType.getSessionType(settings.getSessionType()));
                     targetSession.setTargetName(settings.getTargetName());
                     // *** full feature phase ***
                     phase = new TargetFullFeaturePhase(this);
 
                     phase.execute();
                 }
                 senderWorker.close();
             } catch (OperationNotSupportedException | IOException | InterruptedException | InternetSCSIException | DigestException
                     | SettingsException e) {
                 LOGGER.error("Exception throws", e);
             }
 
             targetSession.removeTargetConnection(this);
 
             LOGGER.debug("closed connection");
 
             return null;
         }
 
         public TargetSession getTargetSession () {
             return targetSession;
         }
 
         /**
          * Returns <code>true</code> if this is the leading connection, i.e. the first TargetConnection in the
          * connection's {@link TargetSession}. Otherwise <code>false</code> is returned.
          * 
          * @return <code>true</code> if this is the leading connection
          */
         public boolean isLeadingConnection () {
             return isLeadingConnection;
         }
 
         /**
          * Initializes {@link #connectionSettingsNegotiator}.
          * <p>
          * This method must be be called after the this connection has been added to its session.
          */
         public void initializeConnectionSettingsNegotiator (final SessionSettingsNegotiator sessionSettingsNegotiator) {
             connectionSettingsNegotiator = new ConnectionSettingsNegotiator(sessionSettingsNegotiator);
         }
 
         /**
          * Returns a {@link Settings} object with a snapshot of the current connection and session parameters.
          * 
          * @return the current {@link Settings}
          */
         public Settings getSettings () {
             return connectionSettingsNegotiator.getSettings();
         }
 
         public ConnectionSettingsNegotiator getConnectionSettingsNegotiator () {
             return connectionSettingsNegotiator;
         }
 
         public SerialArithmeticNumber getStatusSequenceNumber () {
             return statusSequenceNumber;
         }
 
         public void setStatusSequenceNumber (final int statusSequenceNumber) {
             this.statusSequenceNumber = new SerialArithmeticNumber(statusSequenceNumber);
         }
         
         public boolean stop(){
             if(phase instanceof TargetFullFeaturePhase){
                 ((TargetFullFeaturePhase)phase).stop();
                 return true;
             }
             
             return false;
         }
     }
 }