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

namespace AGVSystem
{
	// Token: 0x02000009 RID: 9
	internal class AGVClientCls
	{
		// Token: 0x14000001 RID: 1
		// (add) Token: 0x06000081 RID: 129 RVA: 0x0001073C File Offset: 0x0000E93C
		// (remove) Token: 0x06000082 RID: 130 RVA: 0x00010774 File Offset: 0x0000E974
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event AGVClientCls.StartListeHandler StartListen;

		// Token: 0x14000002 RID: 2
		// (add) Token: 0x06000083 RID: 131 RVA: 0x000107AC File Offset: 0x0000E9AC
		// (remove) Token: 0x06000084 RID: 132 RVA: 0x000107E4 File Offset: 0x0000E9E4
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event AGVClientCls.ReceiveMsgHandler OnMsgReceived;

		// Token: 0x06000085 RID: 133 RVA: 0x0001081C File Offset: 0x0000EA1C
		public AGVClientCls(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: 0x06000086 RID: 134 RVA: 0x00010888 File Offset: 0x0000EA88
		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 = this.connected;
				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: 0x06000087 RID: 135 RVA: 0x00010974 File Offset: 0x0000EB74
		private void OnConnect(object sender, SocketAsyncEventArgs e)
		{
			this.connected = (e.SocketError == 0);
			this.autoConnectEvent.Set();
		}

		// Token: 0x06000088 RID: 136 RVA: 0x00010994 File Offset: 0x0000EB94
		public void Send(byte[] mes)
		{
			bool flag = this.connected;
			if (flag)
			{
				EventHandler<SocketAsyncEventArgs> eventHandler = null;
				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(mes, 0, mes.Length);
				this.clientSocket.SendAsync(senderSocketAsyncEventArgs);
			}
			else
			{
				this.connected = false;
			}
		}

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

		// Token: 0x0600008A RID: 138 RVA: 0x00010B48 File Offset: 0x0000ED48
		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: 0x0600008B RID: 139 RVA: 0x00010BAC File Offset: 0x0000EDAC
		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: 0x0600008C RID: 140 RVA: 0x00010C80 File Offset: 0x0000EE80
		private void SimaticSocketClient_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: 0x0600008D RID: 141 RVA: 0x00010DB8 File Offset: 0x0000EFB8
		public bool OpenLinkPLC()
		{
			this.StartListen += this.SimaticSocketClient_StartListen;
			this.OnMsgReceived += this.SimaticSocketClient_OnMsgReceived;
			bool flag = this.Connect();
			bool flag2 = !flag;
			return !flag2 || flag;
		}

		// Token: 0x0600008E RID: 142 RVA: 0x00010E08 File Offset: 0x0000F008
		public int CloseLinkPLC()
		{
			return this.Disconnect();
		}

		// Token: 0x0600008F RID: 143 RVA: 0x00010E20 File Offset: 0x0000F020
		private void SimaticSocketClient_StartListen()
		{
			this.Listen();
		}

		// Token: 0x06000090 RID: 144 RVA: 0x00010E2C File Offset: 0x0000F02C
		public int WriteVM(int stationNO, int address, int value)
		{
			int result = -1;
			byte[] array = new byte[6];
			byte[] array2 = new byte[39];
			array2[0] = 104;
			array2[1] = 33;
			array2[2] = 33;
			array2[3] = 104;
			array2[4] = (byte)stationNO;
			array2[5] = 0;
			array2[6] = 108;
			array2[7] = 50;
			array2[8] = 1;
			array2[9] = 0;
			array2[10] = 0;
			array2[11] = 0;
			array2[12] = 0;
			array2[13] = 0;
			array2[14] = 14;
			array2[15] = 0;
			array2[16] = 6;
			array2[17] = 5;
			array2[18] = 1;
			array2[19] = 18;
			array2[20] = 10;
			array2[21] = 16;
			array2[22] = 4;
			array2[23] = 0;
			array2[24] = 1;
			array2[25] = 0;
			array2[26] = 1;
			array2[27] = 132;
			array2[28] = 0;
			array2[29] = Convert.ToByte(address * 8 / 256);
			array2[30] = Convert.ToByte(address * 8 % 256);
			array2[31] = 0;
			array2[32] = 4;
			array2[33] = 0;
			array2[34] = 16;
			array2[35] = Convert.ToByte(value / 256);
			array2[36] = Convert.ToByte(value % 256);
			int num = 0;
			for (int i = 4; i <= 36; i++)
			{
				num += (int)array2[i];
			}
			array2[37] = Convert.ToByte(num % 256);
			array2[38] = 22;
			array[0] = 16;
			array[1] = 2;
			array[2] = 0;
			array[3] = 92;
			array[4] = 94;
			array[5] = 22;
			Thread.Sleep(100);
			this.SendOrRecv = 1;
			int num2 = 0;
			this.Send(array2);
			while (this.SendOrRecv != 0 && num2 < 500)
			{
				Thread.Sleep(1);
				num2++;
			}
			bool flag = num2 < 500;
			if (flag)
			{
				bool flag2 = this.SendDataPro[0] == 229;
				if (flag2)
				{
					Thread.Sleep(100);
					this.SendOrRecv = 2;
					int num3 = 0;
					this.Send(array);
					while (this.SendOrRecv != 0 && num3 < 500)
					{
						Thread.Sleep(1);
						num3++;
					}
					bool flag3 = num3 < 500;
					if (flag3)
					{
						bool flag4 = this.SendData.Length == 24 && this.Check(this.SendData);
						if (flag4)
						{
							result = 0;
						}
						return result;
					}
				}
			}
			this.SendOrRecv = 0;
			return result;
		}

		// Token: 0x06000091 RID: 145 RVA: 0x00011094 File Offset: 0x0000F294
		public int ReadVM(int stationNO, int length, int address, out int value)
		{
			int result = -1;
			value = 0;
			byte[] array = new byte[6];
			byte[] array2 = new byte[33];
			array2[0] = 104;
			array2[1] = 27;
			array2[2] = 27;
			array2[3] = 104;
			array2[4] = (byte)stationNO;
			array2[5] = 0;
			array2[6] = 108;
			array2[7] = 50;
			array2[8] = 1;
			array2[9] = 0;
			array2[10] = 0;
			array2[11] = 0;
			array2[12] = 0;
			array2[13] = 0;
			array2[14] = 14;
			array2[15] = 0;
			array2[16] = 0;
			array2[17] = 4;
			array2[18] = 1;
			array2[19] = 18;
			array2[20] = 10;
			array2[21] = 16;
			array2[22] = 4;
			array2[23] = 0;
			array2[24] = Convert.ToByte(length);
			array2[25] = 0;
			array2[26] = 1;
			array2[27] = 132;
			array2[28] = 0;
			array2[29] = Convert.ToByte(address * 8 / 256);
			array2[30] = Convert.ToByte(address * 8 % 256);
			int num = 0;
			for (int i = 4; i <= 30; i++)
			{
				num += Convert.ToInt32(array2[i]);
			}
			array2[31] = Convert.ToByte(num % 256);
			array2[32] = 22;
			array[0] = 16;
			array[1] = 2;
			array[2] = 0;
			array[3] = 92;
			array[4] = 94;
			array[5] = 22;
			Thread.Sleep(100);
			this.SendOrRecv = 3;
			int num2 = 0;
			this.Send(array2);
			while (this.SendOrRecv != 0 && num2 < 500)
			{
				Thread.Sleep(1);
				num2++;
			}
			bool flag = num2 < 500;
			if (flag)
			{
				bool flag2 = this.RecvDataPro[0] == 229;
				if (flag2)
				{
					Thread.Sleep(100);
					this.SendOrRecv = 4;
					int num3 = 0;
					this.Send(array);
					while (this.SendOrRecv != 0 && num3 < 600)
					{
						Thread.Sleep(1);
						num3++;
					}
					bool flag3 = num3 < 600;
					if (flag3)
					{
						bool flag4 = this.RecvData.Length == 1;
						if (flag4)
						{
						}
						bool flag5 = this.RecvData.Length == 29;
						if (flag5)
						{
							result = 0;
							bool flag6 = this.RecvData[25] > 0;
							if (flag6)
							{
								value = (int)this.RecvData[26] * 256 + (int)this.RecvData[25];
							}
							else
							{
								value = (int)this.RecvData[26];
							}
						}
						else
						{
							bool flag7 = this.RecvData[0] == 0;
							if (flag7)
							{
								result = -3;
							}
						}
						return result;
					}
				}
				else
				{
					bool flag8 = this.RecvDataPro[0] == 0;
					if (flag8)
					{
						result = -3;
					}
				}
			}
			this.SendOrRecv = 0;
			return result;
		}

		// Token: 0x06000092 RID: 146 RVA: 0x00011350 File Offset: 0x0000F550
		private bool Check(byte[] by)
		{
			return by[0] == 104 && by[1] == 18 && by[2] == 18 && by[3] == 104 && by[4] == 0 && by[5] == 2 && by[6] == 8 && by[7] == 50 && by[8] == 3 && by[9] == 0 && by[10] == 0 && by[11] == 0 && by[12] == 0 && by[13] == 0 && by[14] == 2 && by[15] == 0 && by[16] == 1 && by[17] == 0 && by[18] == 0 && by[19] == 5 && by[20] == 1 && by[21] == byte.MaxValue && by[22] == 71 && by[23] == 22;
		}

		// Token: 0x06000093 RID: 147 RVA: 0x00011424 File Offset: 0x0000F624
		public void Dispose()
		{
			bool flag = this.clientSocket.Connected;
			if (flag)
			{
				this.clientSocket.Close();
			}
		}

		// Token: 0x04000102 RID: 258
		public string IPAdress;

		// Token: 0x04000103 RID: 259
		public bool connected = false;

		// Token: 0x04000104 RID: 260
		public Socket clientSocket;

		// Token: 0x04000105 RID: 261
		private IPEndPoint hostEndPoint;

		// Token: 0x04000106 RID: 262
		private byte[] SendDataPro;

		// Token: 0x04000107 RID: 263
		private byte[] RecvDataPro;

		// Token: 0x04000108 RID: 264
		private byte[] SendData;

		// Token: 0x04000109 RID: 265
		private byte[] RecvData;

		// Token: 0x0400010A RID: 266
		private byte SendOrRecv;

		// Token: 0x0400010B RID: 267
		private AutoResetEvent autoConnectEvent = new AutoResetEvent(false);

		// Token: 0x0400010C RID: 268
		private SocketAsyncEventArgs lisnterSocketAsyncEventArgs;

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

		// Token: 0x0200003B RID: 59
		// (Invoke) Token: 0x060002D9 RID: 729
		public delegate void StartListeHandler();

		// Token: 0x0200003C RID: 60
		// (Invoke) Token: 0x060002DD RID: 733
		public delegate void ReceiveMsgHandler(byte[] info);
	}
}