using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace Getf.Service.Transfer.Request.SDK
{
	public class TcpSevice : IDisposable
	{
		public event Action<TcpSevice, byte[]> OnDataGetted;

		private string _IP;
		private int _Port;
		TcpClient _TcpClient;

		public bool IsConnected = false;

		private NetworkStream MNetworkStream;

		public TcpSevice(string ip, int port)
		{
			_IP = ip;
			_Port = port;
		}

		public void Connect()
		{
			if (_TcpClient != null)
			{
				return;
			}
			_TcpClient = new TcpClient();
			var asyncCallback = new AsyncCallback(Connected);
			ManualResetEvent manualResetEvent = new ManualResetEvent(false);
			_TcpClient.BeginConnect(_IP, _Port, asyncCallback, new object[] { manualResetEvent });
			manualResetEvent.WaitOne();
			manualResetEvent.Dispose();
			IsConnected = true;
		}

		private void Connected(IAsyncResult asyncResult)
		{
			var objs = asyncResult.AsyncState as object[];

			var manualResetEvent = (ManualResetEvent)objs[0];

			_TcpClient.EndConnect(asyncResult);
			manualResetEvent.Set();
		}

		public void Receive()
		{
			if (MNetworkStream == null)
			{
				MNetworkStream = _TcpClient.GetStream();
			}
			var buffer = new byte[100 * 1024 * 1024];
			if (MNetworkStream.CanRead)
			{
				MNetworkStream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(Received), new object[] { MNetworkStream, buffer });
			}
		}

		private void Received(IAsyncResult asyncResult)
		{
			var objs = asyncResult.AsyncState as object[];
			var stream = objs[0] as Stream;
			var buffer = objs[1] as byte[];
			stream.EndRead(asyncResult);
			if (OnDataGetted != null)
			{
				OnDataGetted(this, buffer);
			}
		}

		public void Send(byte[] buffer)
		{
			ManualResetEvent manualResetEvent = new ManualResetEvent(false);
			if (MNetworkStream == null)
			{
				MNetworkStream = _TcpClient.GetStream();
			}
			if (MNetworkStream.CanWrite)
			{
				MNetworkStream.BeginWrite(buffer, 0, buffer.Length, new AsyncCallback(Sended), new object[] { manualResetEvent, MNetworkStream, buffer });
			}
		}

		private void Sended(IAsyncResult asyncResult)
		{
			var objs = asyncResult.AsyncState as object[];
			var manualResetEvent = (ManualResetEvent)objs[0];
			var stream = objs[1] as Stream;
			var buffer = objs[2] as byte[];
			stream.EndWrite(asyncResult);
			stream.Flush();
			//stream.Dispose();
			manualResetEvent.Set();
		}

		public void Dispose()
		{
			if (MNetworkStream != null)
			{
				MNetworkStream.Close();
				MNetworkStream.Dispose();
			}
		}
	}
}