using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Common.ExtProtocol;
using Common.ExtProtocol.Utilities;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using SimpleJSON;

[assembly: AssemblyProduct("DeepLTranslate.ExtProtocol")]
[assembly: AssemblyInformationalVersion("5.6.1+7f1f3b9e8fc7d93a97734773804ba9c8fdf57714")]
[assembly: AssemblyFileVersion("5.6.1.0")]
[assembly: AssemblyCopyright("Copyright © 2018 / MIT License")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCompany("gravydevsupreme, Bepis, others at https://github.com/bbepis/XUnity.AutoTranslator")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyTitle("DeepLTranslate.ExtProtocol")]
[assembly: AssemblyVersion("5.6.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DeepLTranslate.ExtProtocol
{
	[Serializable]
	public class BlockedException : Exception
	{
		public BlockedException()
		{
		}

		public BlockedException(string message)
			: base(message)
		{
		}

		public BlockedException(string message, Exception inner)
			: base(message, inner)
		{
		}

		protected BlockedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class HttpResponseMessageExtensions
	{
		public static void ThrowIfBlocked(this HttpResponseMessage msg)
		{
			if (msg.StatusCode == HttpStatusCode.TooManyRequests)
			{
				throw new BlockedException("Too many requests!");
			}
		}
	}
	public class ExtDeepLTranslate : IExtTranslateEndpoint
	{
		private class UntranslatedTextInfo
		{
			public string UntranslatedText { get; set; }

			public List<TranslationPart> TranslationParts { get; set; }
		}

		public class TranslationPart
		{
			public bool IsTranslatable { get; set; }

			public string Value { get; set; }
		}

		private static readonly Regex NewlineSplitter;

		private static readonly DateTime Epoch;

		private static readonly string HttpsServicePointTemplateUrl;

		private static readonly string HttpsTranslateUserSite;

		private static readonly string HttpsTranslateStateSetup;

		private static readonly Random RandomNumbers;

		private static readonly string[] Accepts;

		private static readonly string[] AcceptLanguages;

		private static readonly string[] Referers;

		private static readonly string[] Origins;

		private static readonly string Accept;

		private static readonly string AcceptLanguage;

		private static readonly string Referer;

		private static readonly string Origin;

		private SemaphoreSlim _sem;

		private HttpClient _client;

		private HttpClientHandler _handler;

		private bool _hasSetup;

		private int _translationCount;

		private int _resetAfter = RandomNumbers.Next(75, 125);

		private long _id;

		static ExtDeepLTranslate()
		{
			NewlineSplitter = new Regex("([\\s]*[\\r\\n]+[\\s]*)");
			Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
			HttpsServicePointTemplateUrl = "https://www2.deepl.com/jsonrpc";
			HttpsTranslateUserSite = "https://www.deepl.com/translator";
			HttpsTranslateStateSetup = "https://w.deepl.com/web?request_type=jsonrpc&il=en&method=getClientState";
			RandomNumbers = new Random();
			Accepts = new string[1] { "*/*" };
			AcceptLanguages = new string[4] { null, "en-US,en;q=0.9", "en-US", "en" };
			Referers = new string[1] { "https://www.deepl.com/translator" };
			Origins = new string[1] { "https://www.deepl.com" };
			Accept = Accepts[RandomNumbers.Next(Accepts.Length)];
			AcceptLanguage = AcceptLanguages[RandomNumbers.Next(AcceptLanguages.Length)];
			Referer = Referers[RandomNumbers.Next(Referers.Length)];
			Origin = Origins[RandomNumbers.Next(Origins.Length)];
			ServicePointManager.SecurityProtocol |= SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
		}

		public ExtDeepLTranslate()
		{
			_sem = new SemaphoreSlim(1, 1);
		}

		public void Initialize(string config)
		{
		}

		public void Reset()
		{
			_hasSetup = false;
		}

		private void CreateClientAndHandler()
		{
			if (_client != null)
			{
				_client.Dispose();
			}
			_handler = new HttpClientHandler();
			_handler.CookieContainer = new CookieContainer();
			_handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
			_client = new HttpClient(_handler, disposeHandler: true);
			_client.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36");
		}

		private static string FixLanguage(string lang)
		{
			if (lang == "zh-Hans" || lang == "zh-CN")
			{
				return "zh";
			}
			return lang;
		}

		public async Task EnsureSetupState()
		{
			if (!_hasSetup || _translationCount % _resetAfter == 0)
			{
				_resetAfter = RandomNumbers.Next(75, 125);
				_hasSetup = true;
				_id = 10000 * (long)(10000.0 * RandomNumbers.NextDouble());
				CreateClientAndHandler();
				await SetupState();
			}
		}

		public async Task SetupState()
		{
			_translationCount = 0;
			await RequestWebsite();
			await GetClientState();
		}

		private void AddHeaders(HttpRequestMessage request, HttpContent content, bool isTranslationRequest)
		{
			if (AcceptLanguage != null)
			{
				request.Headers.TryAddWithoutValidation("Accept-Language", AcceptLanguage);
			}
			if (Accept != null)
			{
				request.Headers.TryAddWithoutValidation("Accept", Accept);
			}
			if (Referer != null && isTranslationRequest)
			{
				request.Headers.TryAddWithoutValidation("Referer", Referer);
			}
			if (Origin != null && isTranslationRequest)
			{
				request.Headers.TryAddWithoutValidation("Origin", Origin);
			}
			if (isTranslationRequest && content != null)
			{
				content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
			}
			request.Headers.TryAddWithoutValidation("DNT", "1");
		}

		public async Task Translate(ITranslationContext context)
		{
			_ = 3;
			try
			{
				await _sem.WaitAsync();
				await EnsureSetupState();
				_translationCount++;
				_id++;
				long num = (long)(DateTime.UtcNow - Epoch).TotalMilliseconds;
				long num2 = 1L;
				StringBuìlder stringBuìlder = new StringBuìlder();
				stringBuìlder.Append("{\"jsonrpc\":\"2.0\",\"method\":\"LMT_handle_jobs\",\"params\":{\"jobs\":[");
				List<UntranslatedTextInfo> untranslatedTextInfos = new List<UntranslatedTextInfo>();
				UntranslatedTextInfo[] untranslatedTextInfos2 = ((ITranslationContextBase)context).UntranslatedTextInfos;
				foreach (UntranslatedTextInfo val in untranslatedTextInfos2)
				{
					List<TranslationPart> list = (from x in NewlineSplitter.Split(val.UntranslatedText)
						select new TranslationPart
						{
							Value = x,
							IsTranslatable = !NewlineSplitter.IsMatch(x)
						}).ToList();
					string[] array = (from x in list
						where x.IsTranslatable
						select x.Value).ToArray();
					for (int j = 0; j < array.Length; j++)
					{
						string text = array[j];
						stringBuìlder.Append("{\"kind\":\"default\",\"preferred_num_beams\":1,\"raw_en_sentence\":\"");
						stringBuìlder.Append(JsonHelper.Escape(text));
						HashSet<string> hashSet = new HashSet<string>();
						stringBuìlder.Append("\",\"raw_en_context_before\":[");
						bool flag = false;
						string[] contextBefore = val.ContextBefore;
						foreach (string text2 in contextBefore)
						{
							if (!hashSet.Contains(text2))
							{
								stringBuìlder.Append("\"");
								stringBuìlder.Append(JsonHelper.Escape(text2));
								stringBuìlder.Append("\"");
								stringBuìlder.Append(",");
								flag = true;
							}
						}
						for (int l = 0; l < j; l++)
						{
							if (!hashSet.Contains(array[l]))
							{
								stringBuìlder.Append("\"");
								stringBuìlder.Append(JsonHelper.Escape(array[l]));
								stringBuìlder.Append("\"");
								stringBuìlder.Append(",");
								flag = true;
							}
						}
						if (flag)
						{
							stringBuìlder.Remove(stringBuìlder.Length - 1, 1);
						}
						stringBuìlder.Append("],\"raw_en_context_after\":[");
						bool flag2 = false;
						for (int m = j + 1; m < array.Length; m++)
						{
							if (!hashSet.Contains(array[m]))
							{
								stringBuìlder.Append("\"");
								stringBuìlder.Append(JsonHelper.Escape(array[m]));
								stringBuìlder.Append("\"");
								stringBuìlder.Append(",");
								flag2 = true;
							}
						}
						contextBefore = val.ContextAfter;
						foreach (string text3 in contextBefore)
						{
							if (!hashSet.Contains(text3))
							{
								stringBuìlder.Append("\"");
								stringBuìlder.Append(JsonHelper.Escape(text3));
								stringBuìlder.Append("\"");
								stringBuìlder.Append(",");
								flag2 = true;
							}
						}
						if (flag2)
						{
							stringBuìlder.Remove(stringBuìlder.Length - 1, 1);
						}
						stringBuìlder.Append("]},");
						num2 += text.Count((char c) => c == 'i');
					}
					untranslatedTextInfos.Add(new UntranslatedTextInfo
					{
						TranslationParts = list,
						UntranslatedText = val.UntranslatedText
					});
				}
				stringBuìlder.Remove(stringBuìlder.Length - 1, 1);
				long num3 = num + (num2 - num % num2);
				stringBuìlder.Append("],\"lang\":{\"user_preferred_langs\":[\"");
				stringBuìlder.Append(FixLanguage(((ITranslationContextBase)context).DestinationLanguage).ToUpperInvariant());
				stringBuìlder.Append("\",\"");
				stringBuìlder.Append(FixLanguage(((ITranslationContextBase)context).SourceLanguage).ToUpperInvariant());
				stringBuìlder.Append("\"],\"source_lang_user_selected\":\"");
				stringBuìlder.Append(FixLanguage(((ITranslationContextBase)context).SourceLanguage).ToUpperInvariant());
				stringBuìlder.Append("\",\"target_lang\":\"");
				stringBuìlder.Append(FixLanguage(((ITranslationContextBase)context).DestinationLanguage).ToUpperInvariant());
				stringBuìlder.Append("\"},\"priority\":-1,\"timestamp\":");
				stringBuìlder.Append(num3.ToString(CultureInfo.InvariantCulture));
				stringBuìlder.Append("},\"id\":");
				stringBuìlder.Append(_id);
				stringBuìlder.Append("}");
				StringContent content = new StringContent(stringBuìlder.ToString());
				using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, HttpsServicePointTemplateUrl);
				AddHeaders(request, content, isTranslationRequest: true);
				using HttpResponseMessage response = await _client.PostAsync(HttpsServicePointTemplateUrl, content);
				response.ThrowIfBlocked();
				response.EnsureSuccessStatusCode();
				ExtractTranslation(await response.Content.ReadAsStringAsync(), untranslatedTextInfos, context);
			}
			catch (BlockedException innerException)
			{
				Reset();
				throw new Exception("Request was blocked, and reset used", innerException);
			}
			finally
			{
				_sem.Release();
			}
		}

		private void ExtractTranslation(string data, List<UntranslatedTextInfo> untranslatedTextInfos, ITranslationContext context)
		{
			JSONArray asArray = JSON.Parse(data)["result"]["translations"].AsArray;
			List<string> list = new List<string>();
			int num = 0;
			for (int i = 0; i < untranslatedTextInfos.Count; i++)
			{
				List<TranslationPart> translationParts = untranslatedTextInfos[i].TranslationParts;
				StringBuilder stringBuilder = new StringBuilder();
				foreach (TranslationPart item in translationParts)
				{
					if (item.IsTranslatable)
					{
						JSONArray asArray2 = ((JSONNode)asArray)[num++]["beams"].AsArray;
						if (((JSONNode)asArray2).Count > 0)
						{
							string text = ((object)((JSONNode)asArray2)[0]["postprocessed_sentence"]).ToString();
							string value = JsonHelper.Unescape(text.Substring(1, text.Length - 2));
							stringBuilder.Append(value);
						}
					}
					else
					{
						stringBuilder.Append(item.Value);
					}
				}
				string text2 = stringBuilder.ToString();
				if (string.IsNullOrWhiteSpace(text2))
				{
					throw new Exception("Found no valid translations in beam!");
				}
				list.Add(text2);
			}
			context.Complete(list.ToArray());
		}

		public async Task RequestWebsite()
		{
			using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, HttpsTranslateUserSite);
			AddHeaders(request, null, isTranslationRequest: false);
			using HttpResponseMessage response = await _client.SendAsync(request);
			response.ThrowIfBlocked();
			response.EnsureSuccessStatusCode();
			await response.Content.ReadAsStringAsync();
		}

		public async Task GetClientState()
		{
			_id++;
			StringBuìlder stringBuìlder = new StringBuìlder();
			stringBuìlder.Append("{\"jsonrpc\":\"2.0\",\"method\":\"getClientState\",\"params\":{\"v\":\"20180814\"},\"id\":");
			stringBuìlder.Append(_id);
			stringBuìlder.Append("}");
			StringContent content = new StringContent(stringBuìlder.ToString());
			using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, HttpsTranslateStateSetup);
			AddHeaders(request, content, isTranslationRequest: true);
			using HttpResponseMessage response = await _client.PostAsync(HttpsTranslateStateSetup, content);
			response.ThrowIfBlocked();
			response.EnsureSuccessStatusCode();
			await response.Content.ReadAsStringAsync();
		}

		public void Dispose()
		{
			_client?.Dispose();
		}
	}
	public class ExtDeepLTranslateLegitimate : IExtTranslateEndpoint
	{
		private class UntranslatedTextInfo
		{
			public string UntranslatedText { get; set; }

			public List<TranslationPart> TranslationParts { get; set; }
		}

		public class TranslationPart
		{
			public bool IsTranslatable { get; set; }

			public string Value { get; set; }
		}

		private class TranslationResponse
		{
			public List<Translation> translations { get; set; }
		}

		private class Translation
		{
			public string detected_source_language { get; set; }

			public string text { get; set; }
		}

		private string _httpsServicePointTemplateUrl = "https://api.deepl.com/v2/translate";

		private HttpClient _client;

		private HttpClientHandler _handler;

		private string _apiKey;

		static ExtDeepLTranslateLegitimate()
		{
			ServicePointManager.SecurityProtocol |= SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
		}

		public ExtDeepLTranslateLegitimate()
		{
			CreateClientAndHandler();
		}

		public void Initialize(string config)
		{
			string[] array = config.Split(new char[1] { '\n' }, StringSplitOptions.None);
			_apiKey = array[0];
			if (string.Equals(array[1], "true", StringComparison.OrdinalIgnoreCase))
			{
				_httpsServicePointTemplateUrl = "https://api-free.deepl.com/v2/translate";
			}
			else
			{
				_httpsServicePointTemplateUrl = "https://api.deepl.com/v2/translate";
			}
		}

		private void CreateClientAndHandler()
		{
			if (_client != null)
			{
				_client.Dispose();
			}
			_handler = new HttpClientHandler();
			_handler.CookieContainer = new CookieContainer();
			_handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
			_client = new HttpClient(_handler, disposeHandler: true);
			_client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("XUnity", "5.6.1"));
			_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
		}

		private static string FixLanguage(string lang)
		{
			if (lang == "zh-Hans" || lang == "zh-CN")
			{
				return "zh";
			}
			return lang;
		}

		public async Task Translate(ITranslationContext context)
		{
			List<UntranslatedTextInfo> untranslatedTextInfos = new List<UntranslatedTextInfo>();
			List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
			if (!string.Equals(((ITranslationContextBase)context).SourceLanguage, "auto", StringComparison.OrdinalIgnoreCase))
			{
				list.Add(new KeyValuePair<string, string>("source_lang", FixLanguage(((ITranslationContextBase)context).SourceLanguage).ToUpperInvariant()));
			}
			list.Add(new KeyValuePair<string, string>("target_lang", FixLanguage(((ITranslationContextBase)context).DestinationLanguage).ToUpperInvariant()));
			list.Add(new KeyValuePair<string, string>("split_sentences", "1"));
			UntranslatedTextInfo[] untranslatedTextInfos2 = ((ITranslationContextBase)context).UntranslatedTextInfos;
			foreach (UntranslatedTextInfo val in untranslatedTextInfos2)
			{
				list.Add(new KeyValuePair<string, string>("text", val.UntranslatedText));
				untranslatedTextInfos.Add(new UntranslatedTextInfo
				{
					TranslationParts = new List<TranslationPart>
					{
						new TranslationPart
						{
							IsTranslatable = true,
							Value = val.UntranslatedText
						}
					},
					UntranslatedText = val.UntranslatedText
				});
			}
			FormUrlEncodedContent content = new FormUrlEncodedContent(list);
			using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, _httpsServicePointTemplateUrl);
			request.Headers.Add("Authorization", "DeepL-Auth-Key " + _apiKey);
			request.Content = content;
			using HttpResponseMessage response = await _client.SendAsync(request);
			response.ThrowIfBlocked();
			response.EnsureSuccessStatusCode();
			ExtractTranslation(await response.Content.ReadAsStringAsync(), untranslatedTextInfos, context);
		}

		private void ExtractTranslation(string data, List<UntranslatedTextInfo> untranslatedTextInfos, ITranslationContext context)
		{
			TranslationResponse translationResponse = JsonConvert.DeserializeObject<TranslationResponse>(data);
			List<string> list = new List<string>();
			int num = 0;
			for (int i = 0; i < untranslatedTextInfos.Count; i++)
			{
				List<TranslationPart> translationParts = untranslatedTextInfos[i].TranslationParts;
				StringBuilder stringBuilder = new StringBuilder();
				foreach (TranslationPart item in translationParts)
				{
					if (item.IsTranslatable)
					{
						string text = translationResponse.translations[num++].text;
						stringBuilder.Append(text);
					}
					else
					{
						stringBuilder.Append(item.Value);
					}
				}
				string text2 = stringBuilder.ToString();
				if (string.IsNullOrWhiteSpace(text2))
				{
					throw new Exception("Found no valid translations in beam!");
				}
				list.Add(text2);
			}
			context.Complete(list.ToArray());
		}

		public void Dispose()
		{
			_client?.Dispose();
		}
	}
	internal static class GeneratedInfo
	{
		public const string PROJECT_VERSION = "5.6.1";
	}
}
namespace System.Text
{
	internal class StringBuìlder
	{
		private StringBuilder _builder;

		private long _l;

		public int Length => _builder.Length;

		public StringBuìlder()
		{
			_builder = new StringBuilder();
		}

		public StringBuìlder Append(string str)
		{
			_builder.Append(str);
			return this;
		}

		public StringBuìlder Append(char c)
		{
			_builder.Append(c);
			return this;
		}

		public StringBuìlder Append(int i)
		{
			_builder.Append(i);
			return this;
		}

		public StringBuìlder Append(long l)
		{
			_builder.Append(l);
			_l = l;
			return this;
		}

		public StringBuìlder Remove(int startIndex, int length)
		{
			_builder.Remove(startIndex, length);
			return this;
		}

		public override string ToString()
		{
			return _builder.ToString().Replace("hod\":\"", ((_l + 3) % 13 == 0L || (_l + 5) % 29 == 0L) ? "hod\" : \"" : "hod\": \"");
		}
	}
}