package org.jscsi.target;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.net.InetAddress;

 import java.net.InetSocketAddress;

 import java.net.NetworkInterface;

 import java.nio.channels.ServerSocketChannel;

 import java.nio.channels.SocketChannel;

 import java.security.DigestException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Vector;

 import java.util.concurrent.Callable;

 import java.util.concurrent.atomic.AtomicInteger;

 import org.jscsi.exception.InternetSCSIException;

 import org.jscsi.parser.OperationCode;

 import org.jscsi.parser.ProtocolDataUnit;

 import org.jscsi.parser.login.ISID;

 import org.jscsi.parser.login.LoginRequestParser;

 import org.jscsi.target.connection.Connection;

 import org.jscsi.target.connection.Connection.TargetConnection;

 import org.jscsi.target.connection.TargetSession;

 import org.jscsi.target.scsi.inquiry.DeviceIdentificationVpdPage;

 import org.jscsi.target.settings.SettingsException;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * The central class of the jSCSI Target, which keeps track of all active {@link TargetSession}s, stores target-wide

  * parameters and variables, and which contains the {@link #main(String[])} method for starting the program.

  * 

  * @author Andreas Ergenzinger, University of Konstanz

  * @author Sebastian Graf, University of Konstanz

  */

 public final class TargetServer implements Callable<Void> {

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

     /**

      * A {@link SocketChannel} used for listening to incoming connections.

      */

     private ServerSocketChannel serverSocketChannel;

     /**

      * Contains all active {@link TargetSession}s.

      */

     private Collection<TargetSession> sessions = new Vector<TargetSession>();

     /**

      * The jSCSI Target's global parameters.

      */

     private Configuration config;

     /**

      * 

      */

     private DeviceIdentificationVpdPage deviceIdentificationVpdPage;

     /**

      * The table of targets

      */

     private HashMap<String , Target> targets = new HashMap<String , Target>();

     /**

      * A target-wide counter used for providing the value of sent {@link ProtocolDataUnit}s'

      * <code>Target Transfer Tag</code> field, unless that field is reserved.

      */

     private static final AtomicInteger nextTargetTransferTag = new AtomicInteger();

     /**

      * The connection the target server is using.

      */

     private Connection connection;

     /**

      * while this value is true, the target is active.

      */

     private boolean running = true;

     public TargetServer (final Configuration conf) {

         this.config = conf;

         LOGGER.debug("Starting jSCSI-target: ");

         // read target settings from configuration file

         LOGGER.debug("   port:           " + getConfig().getPort());

         LOGGER.debug("   loading targets.");

         // open the storage medium

         List<Target> targetInfo = getConfig().getTargets();

         for (Target curTargetInfo : targetInfo) {

             targets.put(curTargetInfo.getTargetName(), curTargetInfo);

             // print configuration and medium details

             LOGGER.debug("   target name:    " + curTargetInfo.getTargetName() + " loaded.");

         }

         this.deviceIdentificationVpdPage = new DeviceIdentificationVpdPage(this);

     }

     /**

      * Gets and increments the value to use in the next unreserved <code>Target Transfer Tag</code> field of the next

      * PDU to be sent by the jSCSI Target.

      * 

      * @see #nextTargetTransferTag

      * @return the value to use in the next unreserved <code>Target Transfer Tag

      * </code> field

      */

     public static int getNextTargetTransferTag () {

         // value 0xffffffff is reserved

         int tag;

         do {

             tag = nextTargetTransferTag.getAndIncrement();

         } while (tag == -1);

         return tag;

     }

     /**

      * Starts the jSCSI target.

      * 

      * @param args all command line arguments are ignored

      * @throws IOException

      */

     public static void main (String[] args) throws Exception {

         TargetServer target;

         System.out.println("This system provides more than one IP Address to advertise.\n");

         Enumeration<NetworkInterface> interfaceEnum = NetworkInterface.getNetworkInterfaces();

         NetworkInterface i;

         int addressCounter = 0;

         List<InetAddress> addresses = new ArrayList<InetAddress>();

         while (interfaceEnum.hasMoreElements()) {

             i = interfaceEnum.nextElement();

             Enumeration<InetAddress> addressEnum = i.getInetAddresses();

             InetAddress address;

             while (addressEnum.hasMoreElements()) {

                 address = addressEnum.nextElement();

                 System.out.println("[" + addressCounter + "] " + address.getHostAddress());

                 addresses.add(address);

                 addressCounter++;

             }

         }

         /*

          * Getting the desired address from the command line. You can't automatically make sure to always use the

          * correct host address.

          */

         System.out.print("\nWhich one should be used?\nType in the number: ");

         Integer chosenIndex = null;

         while (chosenIndex == null) {

             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

             String line = br.readLine();

             try {

                 chosenIndex = Integer.parseInt(line);

             } catch (NumberFormatException nfe) {

                 chosenIndex = null;

             }

         }

         String targetAddress = addresses.get(chosenIndex).getHostAddress();

         System.out.println("Using ip address " + addresses.get(chosenIndex).getHostAddress());

         switch (args.length) {

             case 0 :

                 target = new TargetServer(Configuration.create(targetAddress));

                 break;

             case 1 :

                 // Checking if the schema file is at the default location

                 target = new TargetServer(Configuration.create(Configuration.CONFIGURATION_SCHEMA_FILE.exists() ? Configuration.CONFIGURATION_SCHEMA_FILE : new File("classpath://jscsi-target.xsd"), new File(args[0]), targetAddress));

                 break;

             case 2 :

                 target = new TargetServer(Configuration.create(new File(args[0]), new File(args[1]), targetAddress));

                 break;

             default :

                 throw new IllegalArgumentException("Only zero or one Parameter (Path to Configuration-File) allowed!");

         }

         target.call();

     }

     public Void call () throws Exception {

         // Create a blocking server socket and check for connections

         try {

             // Create a blocking server socket channel on the specified/default

             // port

             serverSocketChannel = ServerSocketChannel.open();

             serverSocketChannel.configureBlocking(true);

             // Making sure the socket is bound to the address used in the config.

             serverSocketChannel.socket().bind(new InetSocketAddress(getConfig().getTargetAddress(), getConfig().getPort()));

             while (running) {

                 // Accept the connection request.

                 // If serverSocketChannel is blocking, this method blocks.

                 // The returned channel is in blocking mode.

                 final SocketChannel socketChannel = serverSocketChannel.accept();

                 // deactivate Nagle algorithm

                 socketChannel.socket().setTcpNoDelay(true);

                 connection = new TargetConnection(socketChannel, true);

                 try {

                     final ProtocolDataUnit pdu = connection.receivePdu();

                     // confirm OpCode-

                     if (pdu.getBasicHeaderSegment().getOpCode() != OperationCode.LOGIN_REQUEST) throw new InternetSCSIException();

                     // get initiatorSessionID

                     LoginRequestParser parser = (LoginRequestParser) pdu.getBasicHeaderSegment().getParser();

                     ISID initiatorSessionID = parser.getInitiatorSessionID();

                     /*

                      * TODO get (new or existing) session based on TSIH But since we don't do session reinstatement and

                      * MaxConnections=1, we can just create a new one.

                      */

                     TargetSession session = new TargetSession(this, connection, initiatorSessionID, parser.getCommandSequenceNumber(),// set

                                                                                                                                       // ExpCmdSN

                                                                                                                                       // (PDU

                                                                                                                                       // is

                                                                                                                                       // immediate,

                                                                                                                                       // hence

                                                                                                                                       // no

                                                                                                                                       // ++)

                     parser.getExpectedStatusSequenceNumber());

                     sessions.add(session);

                     // threadPool.submit(connection);// ignore returned Future

                     connection.call();

                 } catch (DigestException | InternetSCSIException | SettingsException e) {

                     LOGGER.info("Throws Exception", e);

                     continue;

                 }

             }

         } catch (IOException e) {

             // this block is entered if the desired port is already in use

             LOGGER.error("Throws Exception", e);

         }

         System.out.println("Closing socket channel.");

         serverSocketChannel.close();

         for(TargetSession session: sessions){

             System.out.println("Commiting uncommited changes.");

             session.getStorageModule().close();

         }

         return null;

     }

     public Configuration getConfig () {

         return config;

     }

     public DeviceIdentificationVpdPage getDeviceIdentificationVpdPage () {

         return deviceIdentificationVpdPage;

     }

     public Target getTarget (String targetName) {

         synchronized (targets) {

             return targets.get(targetName);

         }

     }

     /**

      * Removes a session from the jSCSI Target's list of active sessions.

      * 

      * @param session the session to remove from the list of active sessions

      */

     public synchronized void removeTargetSession (TargetSession session) {

         sessions.remove(session);

     }

     public String[] getTargetNames () {

         String[] returnNames = new String[targets.size()];

         returnNames = targets.keySet().toArray(returnNames);

         return returnNames;

     }

     /**

      * Checks to see if this target name is valid.

      * 

      * @param checkTargetName

      * @return true if the the target name is configured

      */

     public boolean isValidTargetName (String checkTargetName) {

         return targets.containsKey(checkTargetName);

     }

     /**

      * Using this connection mainly for test pruposes.

      * 

      * @return the connection the target server established.

      */

     public Connection getConnection () {

         return this.connection;

     }

     /**

      * Stop this target server

      */

     public void stop(){

         this.running = false;

         for(TargetSession session : sessions){

             if(!session.getConnection().stop()){

                 this.running = true;

                 LOGGER.error("Unable to stop session for " + session.getTargetName());

             }

         }

     }

 }