package org.jscsi.target.connection;
   
   
   import org.jscsi.parser.ProtocolDataUnit;
   import org.jscsi.parser.login.ISID;
   import org.jscsi.target.Target;
   import org.jscsi.target.TargetServer;
   import org.jscsi.target.settings.SessionSettingsNegotiator;
   import org.jscsi.target.storage.IStorageModule;
  import org.jscsi.target.util.SerialArithmeticNumber;
  
  
  /**
   * A class for objects representing an iSCSI session with all necessary variables.
   * <p>
   * Currently, a {@link TargetSession} can only have <b>one</b> {@link Connection}, i.e. <code>MaxConnections=1</code>.
   * 
   * @author Andreas Ergenzinger, University of Konstanz
   */
  public class TargetSession {
  
      /**
       * Returns the value of the next {@link TargetSession} object's {@link #targetSessionIdentifyingHandle} variable.
       * 
       * @return the value of the next {@link TargetSession} object's {@link #targetSessionIdentifyingHandle} variable
       */
      private static short getNextTargetSessionIdentifyingHandle () {
          short handle = nextTargetSessionIdentifyingHandle++;// no concurrency
                                                              // necessary
          if (handle == 0) {// is reserved
              handle = nextTargetSessionIdentifyingHandle++;
          }
          return handle;
      }
  
      /**
       * The {@link TargetServer} that this session is associated with
       */
      private TargetServer targetServer;
  
      /**
       * The {@link Target} that this session is associated with
       */
      private Target target;
  
      /**
       * The {@link TargetConnection} used for exchanging messages and data with the session's initiator endpoint.
       */
      private Connection connection;
  
      /**
       * The {@link ISID} used by the initiator for identifying this session.
       */
      private ISID initiatorSessionID;
  
      /**
       * Keeps track of the value to expect in the <code>ExpCmdSN</code> field of the next received
       * {@link ProtocolDataUnit}
       */
      private SerialArithmeticNumber expectedCommandSequenceNumber;
  
      /**
       * Determines the number of iSCSI Command {@link ProtocolDataUnit}s the initiator may send without having the wait
       * for confirmation from the target that the command has finished.
       * <p>
       * A value of <code>1</code> means that the initiator must wait for each command to finish before issuing the next
       * one.
       * 
       * @see #getExpectedCommandSequenceNumber()
       * @see #getMaximumCommandSequenceNumber()
       */
      private final int commandWindowSize = 1;
  
      /**
       * The {@link SessionSettingsNegotiator} responsible managing connection parameters with session scope.
       */
      private SessionSettingsNegotiator sessionSettingsNegotiator;
  
      /**
       * A value used by the target to identify this session.
       */
      private short targetSessionIdentifyingHandle;
  
      /**
       * A counter for {@link #targetSessionIdentifyingHandle}s.
       * 
       * @see #getNextTargetSessionIdentifyingHandle()
       */
      private static short nextTargetSessionIdentifyingHandle = 1;
  
      /**
       * This value determines if this {@link TargetSession} is a discovery session or a regular (operational) session.
       */
      private SessionType sessionType;
  
      /**
       * Constructs a new {@link TargetSession}
       * 
       * @param connection the session's (first) {@link Connection}
      * @param initiatorSessionID the {@link ISID} specified by the initiator
      * @param expectedCommandSequenceNumber initialization value of {@link #expectedCommandSequenceNumber}
      * @param statusSequenceNumber the value expected by the initiator in the next {@link ProtocolDataUnit}'s
      *            <code>StatSN</code> field
      */
     public TargetSession (final TargetServer target, final Connection connection, final ISID initiatorSessionID, final int expectedCommandSequenceNumber, final int statusSequenceNumber) {
         this.targetServer = target;
         // set connection variables and parameters
         connection.setSession(this);
         this.connection = connection;
         connection.setStatusSequenceNumber(statusSequenceNumber);
 
         // initialize ConnectionSettingsNegotiator (makes sure that settings are
         // initialized)
         sessionSettingsNegotiator = new SessionSettingsNegotiator();
         connection.initializeConnectionSettingsNegotiator(sessionSettingsNegotiator);
 
         // set session variables
         this.initiatorSessionID = initiatorSessionID;
         targetSessionIdentifyingHandle = getNextTargetSessionIdentifyingHandle();
         this.expectedCommandSequenceNumber = new SerialArithmeticNumber(expectedCommandSequenceNumber);
     }
 
     /**
      * Returns the session's {@link TargetServer}.
      * 
      * @return the session's {@link TargetServer}
      */
     public TargetServer getTargetServer () {
         return targetServer;
     }
 
     /**
      * Returns the session's {@link Connection}.
      * 
      * @return the session's {@link Connection}
      */
     public Connection getConnection () {
         return connection;
     }
 
     /**
      * Returns the session's {@link Target}
      * 
      * @return the session's {@link Target}
      */
     public Target getTarget () {
         return target;
     }
 
     /**
      * Returns the session's {@link IStorageModule}.
      * 
      * @return the session's {@link IStorageModule}
      */
     public IStorageModule getStorageModule () {
         return target.getStorageModule();
     }
 
     /**
      * Returns the {@link SerialArithmeticNumber} representing the next expected command sequence number.
      * <p>
      * This value will be used both during sending (<code>ExpCmdSN</code> field) and receiving ( <code>CmdSN</code>) of
      * {@link ProtocolDataUnit}s.
      * 
      * @return the {@link SerialArithmeticNumber} representing the next expected command sequence number
      * @see #expectedCommandSequenceNumber
      */
     SerialArithmeticNumber getExpectedCommandSequenceNumber () {
         return expectedCommandSequenceNumber;
     }
 
     /**
      * Returns the {@link ISID} used by the initiator to identify this session.
      * 
      * @return the {@link ISID} used by the initiator to identify this session
      */
     public ISID getInitiatorSessionID () {
         return initiatorSessionID;
     }
 
     /**
      * Returns a {@link SerialArithmeticNumber} representing the maximum command sequence number the target will accept.
      * <p>
      * This value will be used both during sending (<code>MaxCmdSN</code> field) and receiving (checking if PDU's
      * <code>CmdSN</code> lies in the command sequence number window resulting from
      * {@link #expectedCommandSequenceNumber} and {@link #commandWindowSize}) of {@link ProtocolDataUnit}s.
      * 
      * @return the {@link SerialArithmeticNumber} representing the next expected command sequence number
      */
     SerialArithmeticNumber getMaximumCommandSequenceNumber () {
         return new SerialArithmeticNumber(expectedCommandSequenceNumber.getValue() + commandWindowSize - 1);
     }
 
     /**
      * Returns the value used by the jSCSI Target to identify this session.
      * 
      * @return the value used by the jSCSI Target to identify this session
      */
     public short getTargetSessionIdentifyingHandle () {
         return targetSessionIdentifyingHandle;
     }
 
     /**
      * Returns <code>true</code> if this session is a regular (operational) session, and <code>false</code> if it is s
      * discovery session.
      * 
      * @return <code>true</code> if and only if this is not a regular (operational) session
      */
     public boolean isNormalSession () {
         return sessionType == SessionType.NORMAL;
     }
 
     /**
      * Removes a {@link TargetConnection} from the session's list of open connections. If this reduces the number of
      * connections to zero, the session will be removed from the {@link TargetServer}'s list of active sessions.
      * 
      * @param connection the connection to be removed
      */
     void removeTargetConnection (Connection connection) {
         // do this only if connection count == 0, currently it always is
         targetServer.removeTargetSession(this);
     }
 
     /**
      * Sets the session's type (discovery or operational).
      * <p>
      * The type may and must be set just once. Repeated calls of this method will fail. <code>true</code> will be
      * returned if the session type was set successfully, <code>false</code> if not.
      * 
      * @param sessionType the session type
      * @return <code>true</code> if the session type was set successfully, <code>false</code> if not
      */
     boolean setSessionType (SessionType sessionType) {
         // allow just once, accept only non-null parameter
         if (sessionType == null || this.sessionType != null) return false;
         this.sessionType = sessionType;
         return true;
     }
 
     /**
      * Sets the target name and retrieves the target (if it exists) from the TargetServer
      * 
      * @param targetName
      */
     public void setTargetName (String targetName) {
         if (targetName == null) target = null;
         target = targetServer.getTarget(targetName);
     }
 
     public String getTargetName () {
         if (target != null) return target.getTargetName();
         return null;
     }
 }