using Assinador.Model.Common;
using Gestor.Application.Actions;
using Newtonsoft.Json;
using System;
using System.IO;
using System.IO.Pipes;
using System.Runtime.CompilerServices;
using System.Security.AccessControl;
using System.Security.Principal;

namespace Gestor.Application.Helpers
{
	public class PipeServer : IDisposable
	{
		private string _pipeName;

		private NamedPipeServerStream Pipe
		{
			get;
			set;
		}

		public PipeServer()
		{
		}

		private bool Create()
		{
			bool flag;
			bool flag1 = true;
			try
			{
				(new NamedPipeClientStream(".", this._pipeName, PipeDirection.Out, PipeOptions.Asynchronous)).Connect(1000);
			}
			catch (TimeoutException timeoutException)
			{
				flag1 = false;
			}
			catch (Exception exception)
			{
				flag = false;
				return flag;
			}
			if (flag1)
			{
				return true;
			}
			try
			{
				PipeSecurity pipeSecurity = new PipeSecurity();
				SecurityIdentifier securityIdentifier = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null);
				securityIdentifier.Translate(typeof(NTAccount));
				pipeSecurity.SetAccessRule(new PipeAccessRule(securityIdentifier, PipeAccessRights.ReadWrite, AccessControlType.Allow));
				this.Pipe = new NamedPipeServerStream(this._pipeName, PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 1, 1, pipeSecurity);
				this.Pipe.BeginWaitForConnection(new AsyncCallback(this.WaitForConnectionCallBack), this.Pipe);
				return true;
			}
			catch (Exception exception1)
			{
				flag = false;
			}
			return flag;
		}

		public bool CreateServer(string name)
		{
			this._pipeName = name;
			return this.Create();
		}

		public void Dispose()
		{
			this.Pipe.Dispose();
		}

		private void Handle(string message)
		{
			if (message == null)
			{
				return;
			}
			PipeMessageResult pipeMessageResult = JsonConvert.DeserializeObject<PipeMessageResult>(message);
			Action<PipeMessageResult> acessarHoster = Gestor.Application.Actions.Actions.AcessarHoster;
			if (acessarHoster == null)
			{
				return;
			}
			acessarHoster(pipeMessageResult);
		}

		private void WaitForConnectionCallBack(IAsyncResult iar)
		{
			try
			{
				NamedPipeServerStream asyncState = (NamedPipeServerStream)iar.AsyncState;
				asyncState.EndWaitForConnection(iar);
				using (StreamReader streamReader = new StreamReader(this.Pipe))
				{
					string str = streamReader.ReadLine();
					if ((str == null ? false : str.IndexOf("exit", StringComparison.InvariantCultureIgnoreCase) > -1))
					{
						this.Dispose();
					}
					this.Handle(str);
				}
				asyncState.Close();
				asyncState = null;
				this.Create();
			}
			catch
			{
			}
		}
	}
}