using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading.Tasks;
using Common.ExtProtocol;
using Common.ExtProtocol.Utilities;
using Http.ExtProtocol;
using SimpleJSON;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyCompany("gravydevsupreme, Bepis, others at https://github.com/bbepis/XUnity.AutoTranslator")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2018 / MIT License")]
[assembly: AssemblyFileVersion("5.6.1.0")]
[assembly: AssemblyInformationalVersion("5.6.1+7f1f3b9e8fc7d93a97734773804ba9c8fdf57714")]
[assembly: AssemblyProduct("GoogleTranslateCompat.ExtProtocol")]
[assembly: AssemblyTitle("GoogleTranslateCompat.ExtProtocol")]
[assembly: AssemblyVersion("5.6.1.0")]
namespace GoogleTranslateCompat.ExtProtocol;

internal class GoogleTranslateCompatTranslate : ExtHttpEndpoint
{
	public static readonly string UserAgent_Chrome_Win10_Latest = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36";

	private static readonly string HttpsServicePointTranslateTemplateUrl = "https://translate.googleapis.com/translate_a/single?client=webapp&sl={0}&tl={1}&dt=t&tk={2}&q={3}";

	private static readonly string HttpsTranslateUserSite = "https://translate.google.com";

	private static readonly Random RandomNumbers = new Random();

	private static readonly string[] Accepts = new string[3] { null, "*/*", "application/json" };

	private static readonly string[] AcceptLanguages = new string[4] { null, "en-US,en;q=0.9", "en-US", "en" };

	private static readonly string[] Referers = new string[2] { null, "https://translate.google.com/" };

	private static readonly string[] AcceptCharsets = new string[2]
	{
		null,
		Encoding.UTF8.WebName
	};

	private static readonly string Accept = Accepts[RandomNumbers.Next(Accepts.Length)];

	private static readonly string AcceptLanguage = AcceptLanguages[RandomNumbers.Next(AcceptLanguages.Length)];

	private static readonly string Referer = Referers[RandomNumbers.Next(Referers.Length)];

	private static readonly string AcceptCharset = AcceptCharsets[RandomNumbers.Next(AcceptCharsets.Length)];

	private CookieContainer _cookieContainer;

	private bool _hasSetup;

	private long m = 427761L;

	private long s = 1179739010L;

	private int _translationCount;

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

	public GoogleTranslateCompatTranslate()
	{
		_cookieContainer = new CookieContainer();
	}

	private string FixLanguage(string lang)
	{
		switch (lang)
		{
		case "zh-Hans":
		case "zh":
			return "zh-CN";
		case "zh-Hant":
			return "zh-TW";
		default:
			return lang;
		}
	}

	public override async Task OnBeforeTranslate(IHttpTranslationContext context)
	{
		if (!_hasSetup || _translationCount % _resetAfter == 0)
		{
			_resetAfter = RandomNumbers.Next(75, 125);
			_translationCount = 1;
			_hasSetup = true;
			await SetupTKK();
		}
	}

	public override void OnCreateRequest(IHttpRequestCreationContext context)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Expected O, but got Unknown
		_translationCount++;
		string text = string.Join("\n", ((ITranslationContextBase)context).UntranslatedTexts);
		XUnityWebRequest val = new XUnityWebRequest(string.Format(HttpsServicePointTranslateTemplateUrl, FixLanguage(((ITranslationContextBase)context).SourceLanguage), FixLanguage(((ITranslationContextBase)context).DestinationLanguage), Tk(text), Uri.EscapeDataString(text)));
		val.Cookies = _cookieContainer;
		AddHeaders(val, isTranslationRequest: true);
		context.Complete(val);
	}

	public override void OnInspectResponse(IHttpResponseInspectionContext context)
	{
		InspectResponse(context.Response);
	}

	public override void OnExtractTranslation(IHttpTranslationExtractionContext context)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		string data = ((IHttpResponseInspectionContext)context).Response.Data;
		JSONNode val = JSON.Parse(data);
		StringBuilder stringBuilder = new StringBuilder(data.Length);
		val = ((JSONNode)val.AsArray)[0];
		if (val.IsNull)
		{
			context.Complete(((ITranslationContextBase)context).UntranslatedText);
			return;
		}
		Enumerator enumerator = ((JSONNode)val.AsArray).GetEnumerator();
		while (((Enumerator)(ref enumerator)).MoveNext())
		{
			string text = ((object)((JSONNode)JSONNode.op_Implicit(((Enumerator)(ref enumerator)).Current).AsArray)[0]).ToString();
			text = JsonHelper.Unescape(text.Substring(1, text.Length - 2));
			if (!StringBuilderExtensions.EndsWithWhitespaceOrNewline(stringBuilder))
			{
				stringBuilder.Append('\n');
			}
			stringBuilder.Append(text);
		}
		string text2 = stringBuilder.ToString();
		if (((ITranslationContextBase)context).UntranslatedTexts.Length == 1)
		{
			context.Complete(text2);
			return;
		}
		string[] array = text2.Split(new char[1] { '\n' });
		List<string> list = new List<string>();
		int num = 0;
		string[] untranslatedTexts = ((ITranslationContextBase)context).UntranslatedTexts;
		for (int i = 0; i < untranslatedTexts.Length; i++)
		{
			int num2 = untranslatedTexts[i].Split(new char[1] { '\n' }).Length;
			string text3 = string.Empty;
			for (int j = 0; j < num2; j++)
			{
				if (num >= array.Length)
				{
					((ITranslationContextBase)context).Fail("Batch operation received incorrect number of translations.");
				}
				string text4 = array[num++];
				text3 += text4;
				if (j != num2 - 1)
				{
					text3 += "\n";
				}
			}
			list.Add(text3);
		}
		if (num != array.Length)
		{
			((ITranslationContextBase)context).Fail("Batch operation received incorrect number of translations.");
		}
		context.Complete(list.ToArray());
	}

	private XUnityWebRequest CreateWebSiteRequest()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		XUnityWebRequest val = new XUnityWebRequest(HttpsTranslateUserSite);
		val.Cookies = _cookieContainer;
		AddHeaders(val, isTranslationRequest: false);
		return val;
	}

	private void AddHeaders(XUnityWebRequest request, bool isTranslationRequest)
	{
		request.Headers[HttpRequestHeader.UserAgent] = UserAgent_Chrome_Win10_Latest;
		if (AcceptLanguage != null)
		{
			request.Headers[HttpRequestHeader.AcceptLanguage] = AcceptLanguage;
		}
		if (Accept != null)
		{
			request.Headers[HttpRequestHeader.Accept] = Accept;
		}
		if (Referer != null && isTranslationRequest)
		{
			request.Headers[HttpRequestHeader.Referer] = Referer;
		}
		if (AcceptCharset != null)
		{
			request.Headers[HttpRequestHeader.AcceptCharset] = AcceptCharset;
		}
	}

	private void InspectResponse(XUnityWebResponse response)
	{
		CookieCollection newCookies = response.NewCookies;
		foreach (Cookie item in newCookies)
		{
			item.Domain = ".googleapis.com";
		}
		_cookieContainer.Add(newCookies);
	}

	public async Task SetupTKK()
	{
		_cookieContainer = new CookieContainer();
		XUnityWebResponse val3;
		try
		{
			XUnityWebClient val = new XUnityWebClient();
			XUnityWebRequest val2 = CreateWebSiteRequest();
			val3 = await val.SendAsync(val2);
		}
		catch (Exception)
		{
			return;
		}
		if (val3.Error != null || val3.Data == null)
		{
			return;
		}
		InspectResponse(val3);
		try
		{
			string data = val3.Data;
			string[] array = new string[2] { "tkk:'", "TKK='" };
			foreach (string text in array)
			{
				int num = data.IndexOf(text, StringComparison.Ordinal);
				if (num > -1)
				{
					int num2 = num + text.Length;
					int num3 = data.IndexOf('\'', num2);
					string[] array2 = data.Substring(num2, num3 - num2).Split(new char[1] { '.' });
					if (array2.Length == 2)
					{
						m = long.Parse(array2[0]);
						s = long.Parse(array2[1]);
						break;
					}
				}
			}
		}
		catch (Exception)
		{
		}
	}

	private long Vi(long r, string o)
	{
		for (int i = 0; i < o.Length; i += 3)
		{
			long num = o[i + 2];
			num = ((num >= 97) ? (num - 87) : (num - 48));
			num = (('+' == o[i + 1]) ? (r >> (int)num) : (r << (int)num));
			r = (('+' == o[i]) ? ((r + num) & 0xFFFFFFFFu) : (r ^ num));
		}
		return r;
	}

	private string Tk(string r)
	{
		List<long> list = new List<long>();
		for (int i = 0; i < r.Length; i++)
		{
			long num = r[i];
			if (128 > num)
			{
				list.Add(num);
				continue;
			}
			if (2048 > num)
			{
				list.Add((num >> 6) | 0xC0);
			}
			else if (55296 == (0xFC00 & num) && i + 1 < r.Length && 56320 == (0xFC00 & r[i + 1]))
			{
				num = 65536 + ((0x3FF & num) << 10) + (0x3FF & r[++i]);
				list.Add((num >> 18) | 0xF0);
				list.Add(((num >> 12) & 0x3F) | 0x80);
			}
			else
			{
				list.Add((num >> 12) | 0xE0);
				list.Add(((num >> 6) & 0x3F) | 0x80);
			}
			list.Add((0x3F & num) | 0x80);
		}
		long num2 = m;
		for (int j = 0; j < list.Count; j++)
		{
			num2 += list[j];
			num2 = Vi(num2, "+-a^+6");
		}
		num2 = Vi(num2, "+-3^+b+-f");
		num2 ^= s;
		if (0 > num2)
		{
			num2 = (0x7FFFFFFF & num2) + 2147483648u;
		}
		num2 %= 1000000;
		return num2.ToString(CultureInfo.InvariantCulture) + "." + (num2 ^ m).ToString(CultureInfo.InvariantCulture);
	}
}
internal static class GeneratedInfo
{
	public const string PROJECT_VERSION = "5.6.1";
}