using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Windows.Forms;
using System.Text;
using System.Timers;


namespace CSharp.Mok.WinSocket
{
	public delegate void ConnectDelegate(object sender, SockEventArgs e);
	public delegate void DisconnectDelegate(object sender,SockEventArgs e);
	public delegate void SendDelegate(object sender, SockEventArgs e);
	public delegate void ReceiveDelegate(object sender, SockEventArgs e);
	public delegate void CloseDelegate(object sender, SockEventArgs e);
	public delegate void SockErrDelegate(object sender, SockEventArgs e);
	public delegate void MessageDelegate(object sender, SockEventArgs e);
	public delegate void SendingDelegate(object sender, SockEventArgs e);
	public delegate void RecvFileDelegate(object sender, SockEventArgs e);
    
	public class SockEventArgs:EventArgs
	{
		private string msg;
		private double bytesend;
		private string UserName;
		private int SockRef;
	   
		public SockEventArgs(string msg):base()
		{
			this.msg = msg;
		} 
		
		public string RemoteUserName
		{
			get {return UserName;}
			set {UserName=value;}
		}

		public string SockMsg 
		{
			get {return msg;}
			set {msg=value;}  
		}

		public double ByteSend 
		{
			get {return bytesend;}
			set {bytesend =value;}  
		}

		public int SocketRef 
		{
			get {return SockRef;}
			set {SockRef=value;}
		}
       
	}
	
	class WSocket
	{  
		public class StateObject
		{
			public Socket workSocket=null;
			public const int BufferSize = 256;
			public byte[] buffer= new byte[BufferSize];
			public StringBuilder sb = new StringBuilder();
		}
		public Socket Soc; 
		//Events Defination
		public event ConnectDelegate OnConnected;
		public event DisconnectDelegate OnDisconnected;
		public event SendDelegate OnReadySend;
		public event ReceiveDelegate OnReadyReceive;
		public event CloseDelegate OnConnectClose;
		public event SockErrDelegate OnSocketError;
		public event MessageDelegate OnSockMessage;
		public event SendingDelegate OnSendingFile;
		public event RecvFileDelegate OnReceiveFile;

		//Socket Event message Classs
		private SockEventArgs sockArgs = new SockEventArgs("");
		//Variable
		private AddressFamily addressFamily;
		private SocketType socketType;
		private ProtocolType protocolType;
		private EndPoint remoteEP;
		private int nRefNo;
		private string UserName;

		//Status Var
		private bool lSocketClosed;


		//Socket Var
		public StringBuilder response = new StringBuilder();

		//Check Command Var
		
		//Sending File
		private FileStream SentFile;
		private int  nTtlByteSend; 
		private bool bSendFile;
		private System.Timers.Timer SendfileTimer;

        //Receiving file
		private FileStream RecvFile;
		private int nRecFileSize;
		private int nWritebyte;
		private bool bRecvFile;
		private bool bClosedRecvFile;
		private string RecvFilename;
		private System.Timers.Timer RecvfileTimer;
		//private int RecvCallbackLoop;

		public WSocket(AddressFamily addressFamily, SocketType socketType,ProtocolType protocolType)
		{
			Soc = new Socket(addressFamily,socketType,protocolType);
			this.addressFamily = addressFamily;
			this.socketType    = socketType;
			this.protocolType  = protocolType;   
			
			bRecvFile =false;
		}
        
		public int SockRefNo
		{
			get {return nRefNo;}
			set {nRefNo=value;}
		}

		public string RemoteUserName
		{
			get {return UserName;}
			set {UserName=value;}
		}
		
		public void AsyConnectTCIP(EndPoint remoteEP)
		{
			this.remoteEP =remoteEP;
			AsyncCallback beginConnectCallback = new AsyncCallback(ConnectCallBack);		
			Soc.BeginConnect(remoteEP,beginConnectCallback,Soc);
		}

		private  void ConnectCallBack(IAsyncResult ar)
		{
			try
			{  
				Socket soc = (Socket)ar.AsyncState;
				soc.EndConnect(ar);      
				if (soc.Connected)
				{   
					sockArgs.SocketRef=SockRefNo;
					sockArgs.RemoteUserName = RemoteUserName;
					lSocketClosed = false;
					if (OnConnected!=null)
						OnConnected(this, sockArgs);
				}
				else
				{
					if (OnDisconnected!=null)
						OnDisconnected(this,sockArgs );
				}
			}
			catch (Exception e)
			{
				RaiseSockErrEvent("Connect : "+e.Message);
				CloseSocket();
			}
		}

		
		public void DisConnectTCIP()
		{  
			try
			{ 
				CloseSocket();
				if (OnDisconnected!=null)
					OnDisconnected(this, sockArgs);
			}
			catch(Exception e)
			{
				RaiseSockErrEvent("Disconnect : "+e.Message);
				CloseSocket();
			    
			}
		}

		public void SendData(string data)
		{
			try
			{
				byte[] byteData = Encoding.ASCII.GetBytes(data);
				Soc.BeginSend(byteData,0,byteData.Length,SocketFlags.None, 
					new AsyncCallback(SendCallback),Soc);
			}
			catch(Exception e)
			{
				//MessageBox.Show(e.Message);
				RaiseSockErrEvent("Send : "+e.Message);
				CloseSocket();
			}

		}
		
		private void SendCallback(IAsyncResult ar)
		{
			try
			{
				Socket soc = (Socket)ar.AsyncState;
				int byteSend = soc.EndSend(ar);
				if (OnReadySend!=null)
					OnReadySend(this, sockArgs);
			}
			catch(Exception e)
			{
				RaiseSockErrEvent("Send : "+e.Message);
				CloseSocket();
			}
		}

		public void ReceiveData()
		{
			try
			{
				StateObject state = new StateObject();
				state.workSocket = Soc;
				Soc.BeginReceive(state.buffer,0,StateObject.BufferSize,SocketFlags.None,
					new AsyncCallback(ReceiveCallback),state);
			}
			catch(Exception e)
			{
				RaiseSockErrEvent("Receive : "+e.Message);
				CloseSocket();
			}
		}

		private void ReceiveCallback(IAsyncResult ar)
		{
			try
			{
				StateObject state = (StateObject)ar.AsyncState;
				Socket soc = state.workSocket;
				int byteRead = soc.EndReceive(ar);
				if (byteRead > 0)
				{
					if(bRecvFile)
					{ 
					   //RecvCallbackLoop +=1;	 
					   StoreToRecvFile(state.buffer,byteRead);
					}
					else
					{
						response.Append(Encoding.ASCII.GetString(state.buffer,0,byteRead));
						CheckCommand();
						if (OnReadyReceive!=null)
							OnReadyReceive(this,sockArgs);
					}
					
					soc.BeginReceive(state.buffer,0,StateObject.BufferSize,SocketFlags.None,
						new AsyncCallback(ReceiveCallback),state);
				}
				else CloseSocket();
				
			}
			catch(Exception e)
			{
				RaiseSockErrEvent("Receive : "+e.Message);
				CloseSocket();
			}
		}
		public void CloseSocket()
		{
			//Socket is closed, need not to closed again
			//cause if will raised the OnConnectClose event again

			//if the sent file still opening Close it.
			//cause the connection is down.
			if (bSendFile)
				CloseSendFile();

			if (bRecvFile)
			    CloseRecvFile();

			if (lSocketClosed)
				return;

			try
			{  
				lSocketClosed = true;
				if (Soc!=null)
				{
					if (Soc.Connected)
					{
						Soc.Shutdown(SocketShutdown.Both); 
						Soc.Close(); 
					}
				}
               
			}
			catch (ObjectDisposedException err) 
			{
				RaiseSockErrEvent("Close : "+err.Message);
			}
			
			if (OnConnectClose!=null)
				OnConnectClose(this,sockArgs);
			
		}
 
		private void RaiseSockErrEvent(string errMsg)
		{
			sockArgs.SockMsg = errMsg;
			sockArgs.SocketRef=SockRefNo;
			if (OnSocketError!=null)
				OnSocketError(this,sockArgs);
		}

		//Raise event -set the user define Args
		private void RaiseMessageEvent(string Msg)
		{
			SockEventArgs Args = new SockEventArgs("");
			Args.SockMsg = Msg;
			Args.SocketRef=SockRefNo;
			if (OnSockMessage!=null)
				OnSockMessage(this,Args);
		}

		private void RaiseSendingFileEvent(string Msg,int byteSend)
		{
			//SockEventArgs Args = new SockEventArgs("");
			sockArgs.SockMsg = Msg;
			sockArgs.ByteSend = (double)byteSend;
			sockArgs.SocketRef=SockRefNo;
			if (OnSendingFile!=null)
				OnSendingFile(this,sockArgs);
		}

		private void RaiseReceivingEvent(string Msg,int byteSend)
		{
			//SockEventArgs Args = new SockEventArgs("");
			sockArgs.SockMsg = Msg;
			sockArgs.ByteSend = (double)byteSend;
			sockArgs.SocketRef=SockRefNo;
			if (OnReceiveFile!=null)
				OnReceiveFile(this,sockArgs);
		}