/*********************************************************************/
/*                                                                   */
/*                     AgentService Framework                        */
/*                       www.agentservice.it                         */
/*                                                                   */
/* Copyright (C) 2007 l.i.d.o. - DIST, University of Genoa, Italy    */
/* GNU Lesser General Public License                                 */
/*                                                                   */
/* This library is free software; you can redistribute it and/or     */
/* modify it under the terms of the GNU Lesser General Public        */
/* License as published by the Free Software Foundation,             */
/* version 2.1 of the License.                                       */
/*                                                                   */
/* This library is distributed in the hope that it will be useful,   */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of    */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
/* Lesser General Public License for more details.                   */
/*                                                                   */
/* You should have received a copy of the GNU Lesser General Public  */
/* License along with this library; if not, write to the             */
/* Free Software Foundation, Inc., 59 Temple Place - Suite 330,      */
/* Boston, MA  02111-1307, USA.                                      */
/*                                                                   */
/*********************************************************************/
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using AgentService.Interop;
using AgentService.Platform;


namespace AgentService.Interop.Implementation
{
	/// <summary>
	/// Class PlatformChannel. Defualt implementation
	/// of the IPlatformChannel interface.
	/// </summary>
	public class PlatformChannel : IPlatformChannel
	{
		
		/// <summary>
		///	paltform public key.
		/// </summary>
		private byte[] key;
		/// <summary>
		/// Gets the platform public key.
		/// </summary>
		public byte[] PlatformPublicKey 
		{
			get 
			{
				return this.key;
			}
		}
		/// <summary>
		/// TCP address of the platform instance
		/// to which the client is connected.
		/// </summary>
		private TCPAddress address;
		/// <summary>
		/// Gets the address of the platform instance
		/// to which the clieny is connected.
		/// </summary>
		public TCPAddress PlatformAddress
		{
			get
			{
				return this.address;
			}
		}
		/// <summary>
		/// client credentials.
		/// </summary>
		private PlatformClientInfo client;
		/// <summary>
		/// Gets the client credentials, used by the
		/// channel to connect to the platform.
		/// </summary>
		public PlatformClientInfo Client
		{
			get
			{
				return this.client;
			}
		}
		/// <summary>
		/// channel state.
		/// </summary>
		private ChannelState state;
		/// <summary>
		/// Gets the channel state.
		/// </summary>
		public AgentService.Interop.ChannelState State
		{
			get
			{
				
				return state;
			}
		}
		/// <summary>
		/// reference to the platform controller.
		/// </summary>
		private IPlatformController controller;
		/// <summary>
		/// Gets the interface used to access the platform.
		/// This value is not null only when the connection
		/// with the platform is active.
		/// </summary>
		public IPlatformController Controller 
		{
			get 
			{
				return this.controller;
			}
		}
		/// <summary>
		/// Fires evry time an error on the platform channel occurs.
		/// </summary>
		public event AgentService.Interop.PlatformChannelDelegate ChannelError;


		/// <summary>
		/// autoclose flag;
		/// </summary>
		private bool bAutoClose;
		/// <summary>
		/// Gets, sets the channel closure
		/// strategy, if true the channel
		/// authomatically closes on every
		/// type of error.
		/// </summary>
		public bool AutoCloseOnError 
		{
			get
			{
				return this.bAutoClose;
			}
			set
			{
				this.bAutoClose = value;
				if ((this.bAutoClose == true) && ((this.state & ChannelState.Error) > 0))
				{
					this.Close(true);
				}
			}
		}
		/// <summary>
		/// Reference to the platform binder that manages this channel.
		/// </summary>
		private PlatformBinder binder;

		/// <summary>
		/// thread used to connect to the platform instance.
		/// </summary>
		private Thread connectorThread;


		/// <summary>
		/// Constructs a PlatformChannel instance.
		/// </summary>
		/// <param name="binder">reference to the platform binder that created the channel</param>
		/// <param name="user">user credentials used by the channel</param>
		/// <param name="address">tcp address of the platform instance</param>
		/// <param name="publicKey">public key of the platform instance</param>
		public PlatformChannel(PlatformBinder binder, User user, TCPAddress address, byte[] publicKey)
		{
			this.bAutoClose = false;
			this.binder = binder;
			this.key = publicKey;
			// provide a dummy address
			// when the platform is connected
			// provide the correct one.
			TCPAddress thisAddress = null;
			this.client = new PlatformClientInfo(user,thisAddress);

			this.connectorThread = new Thread(new ThreadStart(this.DoActivation));
			this.connectorThread.Start();
		}

		/// <summary>
		/// Reconnects to the platform instance.
		/// </summary>
		public void Reconnect()
		{
			// TODO: provide channel reconnection.
		}

		/// <summary>
		/// Close the communication channel.
		/// </summary>
		public void Close()
		{
			this.Close(true);
		}

		/// <summary>
		/// Closes the connection and eventually signals
		/// to the binder the event of the channel closure.
		/// </summary>
		/// <param name="bNotifyBinder"></param>
		internal void Close(bool bNotifyBinder) 
		{
			// TODO: provide channel closure.
			if (this.state != ChannelState.Disconnected)
			{
				if (bNotifyBinder == true)
					this.binder.SignalClose(this);
			}
		}

		/// <summary>
		/// method used to connect the platform instance.
		/// </summary>
		private void DoActivation() 
		{
			this.state = ChannelState.Connecting;
			Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			IPEndPoint remotePoint = new IPEndPoint(this.address.Address, this.address.Port);
			try 
			{
				socket.Connect(remotePoint);
				this.state = ChannelState.Authenticating;

			}
			catch(SocketException sex)
			{
				this.state = ChannelState.Disconnected;
			}
		}

	}
}