using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace AGVSystem.Cls
{
	// Token: 0x0200002B RID: 43
	internal class OmrlonHostlink
	{
		// Token: 0x1400000B RID: 11
		// (add) Token: 0x06000270 RID: 624 RVA: 0x00052504 File Offset: 0x00050704
		// (remove) Token: 0x06000271 RID: 625 RVA: 0x0005253C File Offset: 0x0005073C
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event OmrlonHostlink.StartListeHandler StartListen;

		// Token: 0x1400000C RID: 12
		// (add) Token: 0x06000272 RID: 626 RVA: 0x00052574 File Offset: 0x00050774
		// (remove) Token: 0x06000273 RID: 627 RVA: 0x000525AC File Offset: 0x000507AC
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event OmrlonHostlink.ReceiveMsgHandler OnMsgReceived;

		// Token: 0x06000274 RID: 628 RVA: 0x000525E4 File Offset: 0x000507E4
		public OmrlonHostlink(string hostName, int port)
		{
			this.IPAdress = hostName;
			IPAddress[] hostAddresses = Dns.GetHostAddresses(hostName);
			this.hostEndPoint = new IPEndPoint(hostAddresses[hostAddresses.Length - 1], port);
			this.clientSocket = new Socket(this.hostEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
		}

		// Token: 0x06000275 RID: 629 RVA: 0x00052650 File Offset: 0x00050850
		private bool Connect()
		{
			bool result;
			using (SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs())
			{
				socketAsyncEventArgs.UserToken = this.clientSocket;
				socketAsyncEventArgs.RemoteEndPoint = this.hostEndPoint;
				socketAsyncEventArgs.Completed += this.OnConnect;
				this.clientSocket.ConnectAsync(socketAsyncEventArgs);
				bool flag = this.autoConnectEvent.WaitOne(1000);
				bool flag2 = flag;
				if (flag2)
				{
					this.lisnterSocketAsyncEventArgs = new SocketAsyncEventArgs();
					byte[] array = new byte[50];
					this.lisnterSocketAsyncEventArgs.UserToken = this.clientSocket;
					this.lisnterSocketAsyncEventArgs.SetBuffer(array, 0, array.Length);
					this.lisnterSocketAsyncEventArgs.Completed += this.OnReceive;
					this.StartListen();
					result = true;
				}
				else
				{
					result = false;
				}
			}
			return result;
		}

		// Token: 0x06000276 RID: 630 RVA: 0x00052738 File Offset: 0x00050938
		private void OnConnect(object sender, SocketAsyncEventArgs e)
		{
			this.connected = (e.SocketError == 0);
			this.autoConnectEvent.Set();
		}

		// Token: 0x06000277 RID: 631 RVA: 0x00052758 File Offset: 0x00050958
		public void Send(string mes)
		{
			bool flag = this.connected;
			if (flag)
			{
				EventHandler<SocketAsyncEventArgs> eventHandler = null;
				byte[] bytes = Encoding.Default.GetBytes(mes);
				SocketAsyncEventArgs senderSocketAsyncEventArgs = null;
				List<SocketAsyncEventArgs> obj = this.s_lst;
				lock (obj)
				{
					bool flag3 = this.s_lst.Count > 0;
					if (flag3)
					{
						senderSocketAsyncEventArgs = this.s_lst[this.s_lst.Count - 1];
						this.s_lst.RemoveAt(this.s_lst.Count - 1);
					}
				}
				bool flag4 = senderSocketAsyncEventArgs == null;
				if (flag4)
				{
					senderSocketAsyncEventArgs = new SocketAsyncEventArgs();
					senderSocketAsyncEventArgs.UserToken = this.clientSocket;
					senderSocketAsyncEventArgs.RemoteEndPoint = this.clientSocket.RemoteEndPoint;
					bool flag5 = eventHandler == null;
					if (flag5)
					{
						eventHandler = delegate(object sender, SocketAsyncEventArgs _e)
						{
							List<SocketAsyncEventArgs> obj2 = this.s_lst;
							lock (obj2)
							{
								this.s_lst.Add(senderSocketAsyncEventArgs);
							}
						};
					}
					senderSocketAsyncEventArgs.Completed += eventHandler;
				}
				senderSocketAsyncEventArgs.SetBuffer(bytes, 0, bytes.Length);
				this.clientSocket.SendAsync(senderSocketAsyncEventArgs);
			}
			else
			{
				this.connected = false;
			}
		}

		// Token: 0x06000278 RID: 632 RVA: 0x000528B4 File Offset: 0x00050AB4
		public void Listen()
		{
			bool flag = this.connected && this.clientSocket != null;
			if (flag)
			{
				try
				{
					(this.lisnterSocketAsyncEventArgs.UserToken as Socket).ReceiveAsync(this.lisnterSocketAsyncEventArgs);
				}
				catch (Exception)
				{
				}
			}
		}

		// Token: 0x06000279 RID: 633 RVA: 0x00052914 File Offset: 0x00050B14
		private int Disconnect()
		{
			int result = 0;
			try
			{
				this.clientSocket.Shutdown(SocketShutdown.Both);
			}
			catch (Exception)
			{
			}
			try
			{
				this.clientSocket.Close();
			}
			catch (Exception)
			{
			}
			this.connected = false;
			return result;
		}

		// Token: 0x0600027A RID: 634 RVA: 0x00052978 File Offset: 0x00050B78
		private void OnReceive(object sender, SocketAsyncEventArgs e)
		{
			bool flag = e.BytesTransferred == 0;
			if (flag)
			{
				try
				{
					this.clientSocket.Shutdown(SocketShutdown.Both);
				}
				catch (Exception)
				{
				}
				finally
				{
					bool flag2 = this.clientSocket.Connected;
					if (flag2)
					{
						this.clientSocket.Close();
					}
				}
				byte[] info = new byte[1];
				this.OnMsgReceived(info);
			}
			else
			{
				byte[] array = new byte[e.BytesTransferred];
				for (int i = 0; i < e.BytesTransferred; i++)
				{
					array[i] = e.Buffer[i];
				}
				this.OnMsgReceived(array);
				this.Listen();
			}
		}

		// Token: 0x0600027B RID: 635 RVA: 0x00052A4C File Offset: 0x00050C4C
		private void OmrlonSocketClient_OnMsgReceived(byte[] info)
		{
			bool flag = info[0] > 0;
			if (flag)
			{
				bool flag2 = this.SendOrRecv == 1;
				if (flag2)
				{
					this.SendDataPro = info;
					this.SendOrRecv = 0;
				}
				else
				{
					bool flag3 = this.SendOrRecv == 2;
					if (flag3)
					{
						this.SendData = info;
						this.SendOrRecv = 0;
					}
					else
					{
						bool flag4 = this.SendOrRecv == 3;
						if (flag4)
						{
							this.RecvDataPro = info;
							this.SendOrRecv = 0;
						}
						else
						{
							bool flag5 = this.SendOrRecv == 4;
							if (flag5)
							{
								this.RecvData = info;
								this.SendOrRecv = 0;
							}
						}
					}
				}
			}
			else
			{
				bool flag6 = this.SendOrRecv == 1;
				if (flag6)
				{
					this.SendDataPro = new byte[1];
					this.SendOrRecv = 0;
				}
				else
				{
					bool flag7 = this.SendOrRecv == 2;
					if (flag7)
					{
						this.SendData = new byte[1];
						this.SendOrRecv = 0;
					}
					else
					{
						bool flag8 = this.SendOrRecv == 3;
						if (flag8)
						{
							this.RecvDataPro = new byte[1];
							this.SendOrRecv = 0;
						}
						else
						{
							bool flag9 = this.SendOrRecv == 4;
							if (flag9)
							{
								this.RecvData = new byte[1];
								this.SendOrRecv = 0;
							}
						}
					}
				}
			}
		}

		// Token: 0x0600027C RID: 636 RVA: 0x00052B84 File Offset: 0x00050D84
		public bool OpenLinkPLC()
		{
			this.StartListen += this.OmrlonSocketClient_StartListen;
			this.OnMsgReceived += this.OmrlonSocketClient_OnMsgReceived;
			bool flag = this.Connect();
			bool flag2 = !flag;
			return !flag2 || flag;
		}

		// Token: 0x0600027D RID: 637 RVA: 0x00052BD4 File Offset: 0x00050DD4
		public int CloseLinkPLC()
		{
			return this.Disconnect();
		}

		// Token: 0x0600027E RID: 638 RVA: 0x00052BEC File Offset: 0x00050DEC
		private void OmrlonSocketClient_StartListen()
		{
			this.Listen();
		}

		// Token: 0x0600027F RID: 639 RVA: 0x00052BF8 File Offset: 0x00050DF8
		private string FCS(string Value)
		{
			int num = 0;
			for (int i = 0; i < Value.Length; i++)
			{
				byte[] bytes = Encoding.ASCII.GetBytes(Value.Substring(i, 1));
				num ^= (int)bytes[0];
			}
			return num.ToString("X");
		}

		// Token: 0x06000280 RID: 640 RVA: 0x00052C4C File Offset: 0x00050E4C
		public int WritePlcDMValue(string stationNO, int address, string value)
		{
			int result = -1;
			string text = address.ToString().PadLeft(4, '0');
			stationNO = stationNO.PadLeft(2, '0');
			string text2 = string.Concat(new string[]
			{
				"@",
				stationNO,
				"WD",
				text,
				value
			});
			text2 = string.Concat(new object[]
			{
				text2,
				this.FCS(text2),
				"*",
				'\r'
			});
			this.SendOrRecv = 1;
			int num = 0;
			this.Send(text2);
			while (this.SendOrRecv != 0 && num < 500)
			{
				Thread.Sleep(1);
				num++;
			}
			bool flag = num < 500;
			if (flag)
			{
				string @string = Encoding.Default.GetString(this.SendDataPro, 0, this.SendDataPro.Length);
				bool flag2 = @string.Length > 7;
				if (flag2)
				{
					bool flag3 = @string.Substring(5, 2) == "00" && @string.Substring(3, 2) == "WD" && @string.Substring(0, 1) == "@" && @string.Substring(@string.Length - 1, 1) == "\r";
					if (flag3)
					{
						result = 0;
					}
				}
			}
			else
			{
				this.SendOrRecv = 0;
			}
			return result;
		}

		// Token: 0x06000281 RID: 641 RVA: 0x00052DD0 File Offset: 0x00050FD0
		public int ReadPlcDMValue(string PlcNo, int Addr, out int value)
		{
			bool flag = Addr == 3000;
			if (flag)
			{
			}
			int result = -1;
			value = -1;
			string text = Addr.ToString().PadLeft(4, '0');
			PlcNo = PlcNo.PadLeft(2, '0');
			string text2 = string.Concat(new string[]
			{
				"@",
				PlcNo,
				"RD",
				text,
				"0001"
			});
			text2 = string.Concat(new object[]
			{
				text2,
				this.FCS(text2),
				"*",
				'\r'
			});
			this.SendOrRecv = 3;
			int num = 0;
			this.Send(text2);
			while (this.SendOrRecv != 0 && num < 500)
			{
				Thread.Sleep(1);
				num++;
			}
			bool flag2 = num < 500;
			if (flag2)
			{
				string @string = Encoding.Default.GetString(this.RecvDataPro, 0, this.RecvDataPro.Length);
				bool flag3 = @string.Length > 11;
				if (flag3)
				{
					bool flag4 = @string.Substring(5, 2) == "00" && @string.Substring(3, 2) == "RD" && @string.Substring(0, 1) == "@" && @string.Substring(@string.Length - 1, 1) == "\r";
					if (flag4)
					{
						value = int.Parse(@string.Trim().Substring(7, 4), NumberStyles.HexNumber);
						result = 0;
					}
				}
			}
			else
			{
				this.SendOrRecv = 0;
			}
			return result;
		}

		// Token: 0x06000282 RID: 642 RVA: 0x00052F8C File Offset: 0x0005118C
		public int ReadPlcHRValue(string PlcNo, int Addr, out int Value)
		{
			int result = -1;
			Value = -1;
			string text = Addr.ToString().PadLeft(4, '0');
			PlcNo = PlcNo.PadLeft(2, '0');
			string text2 = string.Concat(new string[]
			{
				"@",
				PlcNo,
				"RH",
				text,
				"0001"
			});
			text2 = string.Concat(new object[]
			{
				text2,
				this.FCS(text2),
				"*",
				'\r'
			});
			this.SendOrRecv = 4;
			int num = 0;
			this.Send(text2);
			while (this.SendOrRecv != 0 && num < 500)
			{
				Thread.Sleep(1);
				num++;
			}
			bool flag = num < 500;
			if (flag)
			{
				string @string = Encoding.Default.GetString(this.RecvData, 0, this.RecvData.Length);
				bool flag2 = @string.Length > 11;
				if (flag2)
				{
					bool flag3 = @string.Substring(5, 2) == "00" && @string.Substring(3, 2) == "RH" && @string.Substring(0, 1) == "@" && @string.Substring(@string.Length - 1, 1) == "\r";
					if (flag3)
					{
						Value = int.Parse(@string.Trim().Substring(7, 4), NumberStyles.HexNumber);
						result = 0;
					}
				}
			}
			else
			{
				this.SendOrRecv = 0;
			}
			return result;
		}

		// Token: 0x06000283 RID: 643 RVA: 0x00053130 File Offset: 0x00051330
		public void Dispose()
		{
			bool flag = this.clientSocket.Connected;
			if (flag)
			{
				this.clientSocket.Close();
			}
		}

		// Token: 0x0400061F RID: 1567
		public string IPAdress;

		// Token: 0x04000620 RID: 1568
		public bool connected = false;

		// Token: 0x04000621 RID: 1569
		public Socket clientSocket;

		// Token: 0x04000622 RID: 1570
		private IPEndPoint hostEndPoint;

		// Token: 0x04000623 RID: 1571
		private byte[] SendDataPro;

		// Token: 0x04000624 RID: 1572
		private byte[] RecvDataPro;

		// Token: 0x04000625 RID: 1573
		private byte[] SendData;

		// Token: 0x04000626 RID: 1574
		private byte[] RecvData;

		// Token: 0x04000627 RID: 1575
		private byte SendOrRecv;

		// Token: 0x04000628 RID: 1576
		private AutoResetEvent autoConnectEvent = new AutoResetEvent(false);

		// Token: 0x04000629 RID: 1577
		private SocketAsyncEventArgs lisnterSocketAsyncEventArgs;

		// Token: 0x0400062C RID: 1580
		private List<SocketAsyncEventArgs> s_lst = new List<SocketAsyncEventArgs>();

		// Token: 0x0200004A RID: 74
		// (Invoke) Token: 0x06000309 RID: 777
		public delegate void StartListeHandler();

		// Token: 0x0200004B RID: 75
		// (Invoke) Token: 0x0600030D RID: 781
		public delegate void ReceiveMsgHandler(byte[] info);
	}
}