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

namespace AGVSystem.Cls
{
	// Token: 0x02000026 RID: 38
	internal class Cls_Mc_Mitsubishi
	{
		// Token: 0x14000005 RID: 5
		// (add) Token: 0x06000229 RID: 553 RVA: 0x0004FB00 File Offset: 0x0004DD00
		// (remove) Token: 0x0600022A RID: 554 RVA: 0x0004FB38 File Offset: 0x0004DD38
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event Cls_Mc_Mitsubishi.ReceiveMsgHandler OnMsgReceived;

		// Token: 0x14000006 RID: 6
		// (add) Token: 0x0600022B RID: 555 RVA: 0x0004FB70 File Offset: 0x0004DD70
		// (remove) Token: 0x0600022C RID: 556 RVA: 0x0004FBA8 File Offset: 0x0004DDA8
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event Cls_Mc_Mitsubishi.StartListenHandler StartListenThread;

		// Token: 0x14000007 RID: 7
		// (add) Token: 0x0600022D RID: 557 RVA: 0x0004FBE0 File Offset: 0x0004DDE0
		// (remove) Token: 0x0600022E RID: 558 RVA: 0x0004FC18 File Offset: 0x0004DE18
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event Cls_Mc_Mitsubishi.SendCompleted OnSended;

		// Token: 0x0600022F RID: 559 RVA: 0x0004FC50 File Offset: 0x0004DE50
		public Cls_Mc_Mitsubishi(string hostName, int port, int PLCStaion)
		{
			this.Plcport = PLCStaion;
			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: 0x06000230 RID: 560 RVA: 0x0004FCAC File Offset: 0x0004DEAC
		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 = Cls_Mc_Mitsubishi.autoConnectEvent.WaitOne(1000);
				bool flag2 = flag;
				if (flag2)
				{
					this.listenerSocketAsyncEventArgs = new SocketAsyncEventArgs();
					byte[] array = new byte[255];
					this.listenerSocketAsyncEventArgs.UserToken = this.clientSocket;
					this.listenerSocketAsyncEventArgs.SetBuffer(array, 0, array.Length);
					this.listenerSocketAsyncEventArgs.Completed += this.OnReceive;
					this.StartListenThread();
					this.clientSocket.SetKeepAlive(3000UL, 1000UL);
					result = true;
				}
				else
				{
					result = false;
				}
			}
			return result;
		}

		// Token: 0x06000231 RID: 561 RVA: 0x0004FDB0 File Offset: 0x0004DFB0
		private void Listen()
		{
			(this.listenerSocketAsyncEventArgs.UserToken as Socket).ReceiveAsync(this.listenerSocketAsyncEventArgs);
		}

		// Token: 0x06000232 RID: 562 RVA: 0x0004FDD0 File Offset: 0x0004DFD0
		private void Send(byte[] message)
		{
			bool flag = this.connected;
			if (flag)
			{
				SocketAsyncEventArgs senderSocketAsyncEventArgs = null;
				List<SocketAsyncEventArgs> obj = Cls_Mc_Mitsubishi.s_lst;
				lock (obj)
				{
					bool flag3 = Cls_Mc_Mitsubishi.s_lst.Count > 0;
					if (flag3)
					{
						senderSocketAsyncEventArgs = Cls_Mc_Mitsubishi.s_lst[Cls_Mc_Mitsubishi.s_lst.Count - 1];
						Cls_Mc_Mitsubishi.s_lst.RemoveAt(Cls_Mc_Mitsubishi.s_lst.Count - 1);
					}
				}
				bool flag4 = senderSocketAsyncEventArgs == null;
				if (flag4)
				{
					senderSocketAsyncEventArgs = new SocketAsyncEventArgs();
					senderSocketAsyncEventArgs.UserToken = this.clientSocket;
					senderSocketAsyncEventArgs.RemoteEndPoint = this.hostEndPoint;
					senderSocketAsyncEventArgs.Completed += delegate(object sender, SocketAsyncEventArgs _e)
					{
						List<SocketAsyncEventArgs> obj2 = Cls_Mc_Mitsubishi.s_lst;
						lock (obj2)
						{
							Cls_Mc_Mitsubishi.s_lst.Add(senderSocketAsyncEventArgs);
						}
					};
				}
				senderSocketAsyncEventArgs.SetBuffer(message, 0, message.Length);
				this.clientSocket.SendAsync(senderSocketAsyncEventArgs);
			}
			else
			{
				this.connected = false;
			}
			this.SendMess = message;
		}

		// Token: 0x06000233 RID: 563 RVA: 0x0004FF04 File Offset: 0x0004E104
		private bool Disconnect()
		{
			bool result = true;
			try
			{
				this.clientSocket.Shutdown(SocketShutdown.Both);
				this.clientSocket.Close();
			}
			catch (Exception)
			{
				result = false;
			}
			return result;
		}

		// Token: 0x06000234 RID: 564 RVA: 0x0004FF50 File Offset: 0x0004E150
		private void OnConnect(object sender, SocketAsyncEventArgs e)
		{
			Cls_Mc_Mitsubishi.autoConnectEvent.Set();
			this.connected = (e.SocketError == 0);
		}

		// Token: 0x06000235 RID: 565 RVA: 0x0004FF70 File Offset: 0x0004E170
		private void OnReceive(object sender, SocketAsyncEventArgs e)
		{
			bool flag = e.BytesTransferred == 0;
			if (flag)
			{
				bool flag2 = this.clientSocket.Connected;
				if (flag2)
				{
					try
					{
						this.clientSocket.Shutdown(SocketShutdown.Both);
					}
					catch (Exception)
					{
					}
					finally
					{
						bool flag3 = this.clientSocket.Connected;
						if (flag3)
						{
							this.clientSocket.Close();
						}
					}
				}
				byte[] info = new byte[]
				{
					0
				};
				this.OnMsgReceived(info);
				this.connected = false;
			}
			else
			{
				byte[] buffer = e.Buffer;
				this.OnMsgReceived(buffer);
				this.Listen();
			}
		}

		// Token: 0x06000236 RID: 566 RVA: 0x00050034 File Offset: 0x0004E234
		private void OnSend(object sender, SocketAsyncEventArgs e)
		{
			bool flag = e.SocketError == 0;
			if (flag)
			{
				this.OnSended(true);
			}
			else
			{
				this.OnSended(false);
				this.ProcessError(e);
			}
		}

		// Token: 0x06000237 RID: 567 RVA: 0x00050078 File Offset: 0x0004E278
		private void ProcessError(SocketAsyncEventArgs e)
		{
			Socket socket = e.UserToken as Socket;
			bool flag = socket.Connected;
			if (flag)
			{
				try
				{
					socket.Shutdown(SocketShutdown.Both);
				}
				catch (Exception)
				{
				}
				finally
				{
					bool flag2 = socket.Connected;
					if (flag2)
					{
						socket.Close();
					}
				}
				this.connected = false;
			}
		}

		// Token: 0x06000238 RID: 568 RVA: 0x000500EC File Offset: 0x0004E2EC
		public void Dispose()
		{
			Cls_Mc_Mitsubishi.autoConnectEvent.Close();
			bool flag = this.clientSocket.Connected;
			if (flag)
			{
				this.clientSocket.Close();
			}
		}

		// Token: 0x06000239 RID: 569 RVA: 0x00050124 File Offset: 0x0004E324
		private void OmronFINS_OnSended(bool successorfalse)
		{
			bool flag = !successorfalse;
			if (flag)
			{
			}
		}

		// Token: 0x0600023A RID: 570 RVA: 0x00050140 File Offset: 0x0004E340
		private void OmronFINS_OnMsgReceived(byte[] info)
		{
			bool sendmessHas = this.SendmessHas;
			if (sendmessHas)
			{
				bool flag = info[0] > 0;
				if (flag)
				{
					bool flag2 = info.Length > 24;
					if (flag2)
					{
						string str = "";
						for (int i = 0; i < 24; i++)
						{
							str += info[i].ToString("X").PadLeft(2, '0');
						}
						bool flag3 = int.Parse(info[23].ToString("X").Trim(), NumberStyles.HexNumber) == this.Plcport;
						if (flag3)
						{
							this.PCS = info[19];
							this.PLCS = info[23];
							this.SendmessHas = false;
						}
					}
				}
			}
			else
			{
				bool flag4 = info[0] > 0;
				if (flag4)
				{
					bool flag5 = this.SendOrRev2 == 1;
					if (flag5)
					{
						this.SendBack = info;
						this.SendOrRev2 = 0;
					}
					else
					{
						bool flag6 = this.SendOrRev == 2;
						if (flag6)
						{
							this.RecvBack = info;
							this.SendOrRev = 0;
						}
					}
				}
				else
				{
					bool flag7 = this.SendOrRev2 == 1;
					if (flag7)
					{
						this.SendBack = new byte[1];
						this.SendBack[0] = 0;
						this.SendOrRev2 = 0;
					}
					else
					{
						bool flag8 = this.SendOrRev == 2;
						if (flag8)
						{
							this.RecvBack = new byte[1];
							this.RecvBack[0] = 0;
							this.SendOrRev = 0;
						}
					}
				}
			}
		}

		// Token: 0x0600023B RID: 571 RVA: 0x000502BD File Offset: 0x0004E4BD
		private void OmronFINS_StartListenThread()
		{
			this.Listen();
		}

		// Token: 0x0600023C RID: 572 RVA: 0x000502C8 File Offset: 0x0004E4C8
		public bool OpenLinkPLC()
		{
			this.StartListenThread += this.OmronFINS_StartListenThread;
			this.OnMsgReceived += this.OmronFINS_OnMsgReceived;
			this.OnSended += this.OmronFINS_OnSended;
			return this.Connect();
		}

		// Token: 0x0600023D RID: 573 RVA: 0x00050320 File Offset: 0x0004E520
		public bool CloseLinkPLC()
		{
			return this.Disconnect();
		}

		// Token: 0x0600023E RID: 574 RVA: 0x00050338 File Offset: 0x0004E538
		public bool WritePlcData(int address, int value)
		{
			byte[] message = new byte[]
			{
				80,
				0,
				0,
				byte.MaxValue,
				byte.MaxValue,
				3,
				0,
				14,
				0,
				0,
				0,
				1,
				20,
				0,
				0,
				Convert.ToByte(address % 256),
				Convert.ToByte(address / 256),
				0,
				168,
				1,
				0,
				Convert.ToByte(value % 256),
				Convert.ToByte(value / 256)
			};
			bool result = false;
			this.SendOrRev2 = 1;
			this.Send(message);
			int num = 0;
			while (this.SendOrRev2 != 0 & this.connected & num < 1000)
			{
				Thread.Sleep(1);
				num++;
			}
			bool flag = num < 1000;
			if (flag)
			{
				try
				{
					bool flag2 = this.SendBack[0] == 208 && this.SendBack[5] == 3 && this.SendBack[7] == 2 && this.SendBack[10] == 0;
					result = flag2;
				}
				catch (Exception)
				{
				}
			}
			else
			{
				this.SendOrRev2 = 0;
			}
			return result;
		}

		// Token: 0x0600023F RID: 575 RVA: 0x000504B4 File Offset: 0x0004E6B4
		public bool ReadPlcData(int address, int length, out int[] IntValue)
		{
			bool result = false;
			IntValue = new int[length];
			this.Send(new byte[]
			{
				80,
				0,
				0,
				byte.MaxValue,
				byte.MaxValue,
				3,
				0,
				12,
				0,
				0,
				0,
				1,
				4,
				0,
				0,
				Convert.ToByte(address % 256),
				Convert.ToByte(address / 256),
				0,
				168,
				Convert.ToByte(length % 256),
				Convert.ToByte(length / 256)
			});
			this.SendOrRev = 2;
			int num = 0;
			while (this.SendOrRev != 0 & this.connected & num < 1000)
			{
				Thread.Sleep(1);
				num++;
			}
			bool flag = num < 1000;
			if (flag)
			{
				try
				{
					bool flag2 = this.RecvBack[0] == 208 && this.RecvBack[5] == 3 && this.RecvBack[7] == 22 && this.RecvBack[10] == 0;
					if (flag2)
					{
						result = true;
						for (int i = 0; i < 10; i++)
						{
							IntValue[i] = (int)this.RecvBack[11 + 2 * i] + (int)this.RecvBack[12 + 2 * i] * 256;
						}
					}
					else
					{
						result = false;
					}
				}
				catch (Exception)
				{
				}
			}
			else
			{
				this.SendOrRev = 0;
			}
			return result;
		}

		// Token: 0x040005F5 RID: 1525
		public Socket clientSocket;

		// Token: 0x040005F6 RID: 1526
		public bool connected = false;

		// Token: 0x040005F7 RID: 1527
		private byte[] SendMess;

		// Token: 0x040005F8 RID: 1528
		private IPEndPoint hostEndPoint;

		// Token: 0x040005F9 RID: 1529
		private static AutoResetEvent autoConnectEvent = new AutoResetEvent(false);

		// Token: 0x040005FD RID: 1533
		private SocketAsyncEventArgs listenerSocketAsyncEventArgs;

		// Token: 0x040005FE RID: 1534
		private int Plcport;

		// Token: 0x040005FF RID: 1535
		public static List<SocketAsyncEventArgs> s_lst = new List<SocketAsyncEventArgs>();

		// Token: 0x04000600 RID: 1536
		private byte PCS;

		// Token: 0x04000601 RID: 1537
		private byte PLCS;

		// Token: 0x04000602 RID: 1538
		private int SendOrRev;

		// Token: 0x04000603 RID: 1539
		private int SendOrRev2;

		// Token: 0x04000604 RID: 1540
		private byte[] SendBack;

		// Token: 0x04000605 RID: 1541
		private byte[] RecvBack;

		// Token: 0x04000606 RID: 1542
		private bool SendmessHas = false;

		// Token: 0x02000041 RID: 65
		// (Invoke) Token: 0x060002ED RID: 749
		public delegate void ReceiveMsgHandler(byte[] info);

		// Token: 0x02000042 RID: 66
		// (Invoke) Token: 0x060002F1 RID: 753
		public delegate void StartListenHandler();

		// Token: 0x02000043 RID: 67
		// (Invoke) Token: 0x060002F5 RID: 757
		public delegate void SendCompleted(bool successorfalse);
	}
}