using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Organization Cecil Libraries, Founder(s) Chaosyr")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A Bridge to connect .Net Framework 3.5 all the way up to Modern .Net.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2092b5ad8e1df7ac1bb5aec0831dc467f75da2f9")]
[assembly: AssemblyProduct("Cecil Bridge")]
[assembly: AssemblyTitle("Cecil Bridge")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Cecil-Libraries/Cecil-Bridge")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Cecil_Bridge.Objects
{
	public class Messenger
	{
		private class retPeices
		{
			public string message { get; set; }

			public string key { get; set; }

			public retPeices(string message, string key)
			{
				this.message = message;
				this.key = key;
			}
		}

		public string message = "";

		private string previousLine = "";

		public string MutualFilePath = "";

		public Sender Sender { get; set; }

		public Receiver Receiver { get; set; }

		public Messenger(Sender sender, Receiver receiver, string PathToFile)
		{
			Sender = sender;
			Receiver = receiver;
			MutualFilePath = PathToFile;
		}

		public void SendMessage(string message)
		{
			retPeices ret = EncryptMessage(message);
			StoreMessage(Receiver, ret, Sender);
		}

		private retPeices EncryptMessage(string message)
		{
			Random random = new Random();
			byte[] array = new byte[random.Next(32, 129)];
			random.NextBytes(array);
			string text = Convert.ToBase64String(array);
			return new retPeices(Convert.ToBase64String(Encoding.UTF8.GetBytes(text + " " + message)), text);
		}

		private void StoreMessage(Receiver receiver, retPeices ret, Sender sender)
		{
			using FileStream stream = new FileStream(Path.GetFullPath(MutualFilePath), FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
			using StreamWriter streamWriter = new StreamWriter(stream);
			streamWriter.WriteLine("SendsTo;Mesage;Key;SendBackTo");
			streamWriter.WriteLine("\"" + sender.SendsTo + "\";\"" + ret.message + "\";\"" + ret.key + "\";\"" + receiver.ReceivesFrom + "\"");
		}

		public bool ReceiveMessage()
		{
			try
			{
				string[] array;
				using (FileStream stream = new FileStream(Path.GetFullPath(MutualFilePath), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
				{
					using StreamReader streamReader = new StreamReader(stream);
					array = streamReader.ReadToEnd().Split(new string[1] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
				}
				string text = array[1];
				if (text == previousLine || text.Split(new char[1] { ';' })[0].Replace("\"", "") != Receiver.ReceivesFrom || text.Split(new char[1] { ';' })[3].Replace("\"", "") != Sender.SendsTo)
				{
					return false;
				}
				message = DecryptMessage(text.Split(new char[1] { ';' })[1].Replace("\"", ""), text.Split(new char[1] { ';' })[2].Replace("\"", ""));
				previousLine = text;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private string DecryptMessage(string message, string key)
		{
			byte[] bytes = Convert.FromBase64String(message);
			return Encoding.UTF8.GetString(bytes).Replace(key + " ", "");
		}
	}
	public class Receiver
	{
		public string ReceivesFrom { get; set; }

		public Receiver(string receivesFrom)
		{
			ReceivesFrom = Path.GetFullPath(receivesFrom);
		}
	}
	public class Sender
	{
		public string SendsTo { get; set; }

		public Sender(string sendToWhere)
		{
			SendsTo = Path.GetFullPath(sendToWhere);
		}
	}
}