/*
      Copyright 2008 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.distribution.connection.tcp;
  
  import static fulmine.util.Utils.EMPTY_STRING;
  import static fulmine.util.Utils.nullCheck;
  
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  
  import fulmine.context.IFrameworkContext;
  import fulmine.context.INetwork;
  import fulmine.distribution.IHeartbeatMonitor;
  import fulmine.distribution.channel.Channel;
  import fulmine.distribution.channel.IChannel;
  import fulmine.distribution.connection.IConnection;
  import fulmine.distribution.connection.IConnectionBroker;
  import fulmine.distribution.connection.IConnectionDiscoverer;
  import fulmine.util.log.AsyncLog;
  
  /**
   * Creates components that connect using TCP/IP.
   * 
   * @author Ramon Servadei
   */
  public class TcpNetwork implements INetwork
  {
      /** The host to use for this context's TCP/IP connection */
      private final String hostAddress;
  
      /** The port to use for this context's TCP/IP connection */
      private final int tcpPort;
  
      /** The UDP discovery port */
      private final int udpPort;
  
      /** The UDP discovery network */
      private final String udpNetwork;
  
      /** The UDP discovery network interface card to use */
      private final String udpNic;
  
      /** The context this services */
      private IFrameworkContext context;
  
      /** The heartbeat period */
      private long heartbeatPeriod = IHeartbeatMonitor.DEFAULT_HEARTBEAT_PERIOD;
  
      /** The number of allowed missed heartbeats */
      private int allowedMissedHeartbeats =
          IHeartbeatMonitor.DEFAULT_ALLOWED_MISSED_COUNT;
  
      /** Indicates if the discoverer has pulsing disabled */
      private boolean listeningOnlyMode;
  
      private final static AsyncLog LOG = new AsyncLog(TcpNetwork.class);
  
      /**
       * Default constructor that reads system properties for the IP address and
       * TCP port to use.
       * 
       * @see TcpConnectionBroker#CONTEXT_IP_ADDRESS
       * @see TcpConnectionBroker#CONTEXT_TCP_PORT
       * @see TcpConnectionBroker#DEFAULT_CONTEXT_TCP_PORT
       * @see TcpConnectionDiscoverer#DEFAULT_UDP_DISCOVERY_NETWORK
       * @see TcpConnectionDiscoverer#DEFAULT_UDP_DISCOVERY_PORT
       */
      public TcpNetwork()
      {
          this(System.getProperty(TcpConnectionBroker.CONTEXT_IP_ADDRESS,
              TcpConnectionBroker.HOST_NAME),
              Integer.parseInt(System.getProperty(
                  TcpConnectionBroker.CONTEXT_TCP_PORT, EMPTY_STRING
                      + TcpConnectionBroker.DEFAULT_CONTEXT_TCP_PORT)),
              System.getProperty(TcpConnectionDiscoverer.UDP_DISCOVERY_NETWORK,
                  TcpConnectionDiscoverer.DEFAULT_UDP_DISCOVERY_NETWORK),
              Integer.parseInt(System.getProperty(
                  TcpConnectionDiscoverer.UDP_DISCOVERY_PORT,
                  TcpConnectionDiscoverer.DEFAULT_UDP_DISCOVERY_PORT)),
              System.getProperty(TcpConnectionDiscoverer.NETWORK_INTERFACE_NAME));
      }
  
      /**
       * Construct the network to use specific parameters for the IP address and
       * TCP port of the network connection for the context.
       * 
      * @param address
      *            the IP address (or hostname) of the host, <code>null</code>
      *            for the host address of the local host
      * @param port
      *            the TCP port for the context's network connection,
      *            <code>0</code> for
      *            {@link TcpConnectionBroker#DEFAULT_CONTEXT_TCP_PORT}
      */
     public TcpNetwork(String address, int port)
     {
         this(address, port, System.getProperty(
             TcpConnectionDiscoverer.UDP_DISCOVERY_NETWORK,
             TcpConnectionDiscoverer.DEFAULT_UDP_DISCOVERY_NETWORK),
             Integer.parseInt(System.getProperty(
                 TcpConnectionDiscoverer.UDP_DISCOVERY_PORT,
                 TcpConnectionDiscoverer.DEFAULT_UDP_DISCOVERY_PORT)),
             System.getProperty(TcpConnectionDiscoverer.NETWORK_INTERFACE_NAME));
     }
 
     /**
      * Construct the network to use specifying specific parameters for:
      * <ul>
      * <li>the IP address and TCP port of the network connection for the context
      * <li>the UDP connection parameters for the discoverer
      * </ul>
      * 
      * @param hostAddress
      *            the IP address (or hostname) of the host, <code>null</code>
      *            for the host address of the local host
      * @param tcpPort
      *            the TCP port for the context's network connection,
      *            <code>0</code> for
      *            {@link TcpConnectionBroker#DEFAULT_CONTEXT_TCP_PORT}
      * @param udpNetwork
      *            the UDP network for the discoverer
      * @param udpPort
      *            the UDP port for the discoverer
      * @param udpNic
      *            the network interface card name to bind to, <code>null</code>
      *            for default
      */
     public TcpNetwork(String hostAddress, int tcpPort, String udpNetwork,
         int udpPort, String udpNic)
     {
         super();
         nullCheck(udpNetwork, "UDP network is null");
         try
         {
             this.hostAddress =
                 hostAddress == null
                     ? (InetAddress.getLocalHost().getCanonicalHostName())
                     : hostAddress;
         }
         catch (UnknownHostException e)
         {
             throw new RuntimeException("Could not get host name", e);
         }
         this.tcpPort = tcpPort;
         this.udpNetwork = udpNetwork;
         this.udpPort = udpPort;
         this.udpNic = udpNic;
     }
 
     public IConnectionBroker createBroker()
     {
         return new TcpConnectionBroker(context, this.hostAddress, this.tcpPort);
     }
 
     public IChannel createChannel(IConnection connection)
     {
         if (LOG.isDebugEnabled())
         {
             LOG.debug("Creating channel over " + connection);
         }
         return new Channel(connection, context);
     }
 
     public IConnectionDiscoverer createDiscoverer()
     {
         final TcpConnectionDiscoverer tcpConnectionDiscoverer =
             new TcpConnectionDiscoverer(context, this.hostAddress,
                 this.tcpPort, this.udpNetwork, this.udpPort, this.udpNic);
         tcpConnectionDiscoverer.setNetworkHeartbeatPeriod(this.heartbeatPeriod);
         tcpConnectionDiscoverer.setAllowableNetworkHeartbeatMissCount(this.allowedMissedHeartbeats);
         return tcpConnectionDiscoverer;
     }
 
     public void setContext(IFrameworkContext context)
     {
         this.context = context;
     }
 
     public void setAllowableNetworkHeartbeatMissCount(
         int allowedHeartbeatMissCount)
     {
         this.allowedMissedHeartbeats = allowedHeartbeatMissCount;
     }
 
     public void setNetworkHeartbeatPeriod(long periodInMillis)
     {
         this.heartbeatPeriod = periodInMillis;
     }
 
     public int getAllowableNetworkHeartbeatMissCount()
     {
         return this.allowedMissedHeartbeats;
     }
 
     public long getNetworkHeartbeatPeriod()
     {
         return this.heartbeatPeriod;
     }
 
     public void setListeningOnlyMode(boolean listeningOnlyMode)
     {
         this.listeningOnlyMode = true;
     }
 
     public boolean isListeningOnlyMode()
     {
         return this.listeningOnlyMode;
     }
 }