using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using SimpleJSON;
using XUnity.AutoTranslator.Plugin.Core;
using XUnity.AutoTranslator.Plugin.Core.Constants;
using XUnity.AutoTranslator.Plugin.Core.Endpoints;
using XUnity.AutoTranslator.Plugin.Core.Endpoints.Http;
using XUnity.AutoTranslator.Plugin.Core.Shims;
using XUnity.AutoTranslator.Plugin.Core.Utilities;
using XUnity.AutoTranslator.Plugin.Core.Web;
using XUnity.Common.Logging;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[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("PapagoTranslate")]
[assembly: AssemblyTitle("PapagoTranslate")]
[assembly: AssemblyVersion("5.6.1.0")]
namespace PapagoTranslate;

public class PapagoTranslateEndpoint : HttpEndpoint
{
	[CompilerGenerated]
	private sealed class <OnBeforeTranslate>d__22 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PapagoTranslateEndpoint <>4__this;

		private IEnumerator <enumerator>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <OnBeforeTranslate>d__22(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<enumerator>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			int num = <>1__state;
			PapagoTranslateEndpoint papagoTranslateEndpoint = <>4__this;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				if (papagoTranslateEndpoint._resetAfter != 0 && papagoTranslateEndpoint._translationCount % papagoTranslateEndpoint._resetAfter != 0)
				{
					goto IL_0099;
				}
				papagoTranslateEndpoint._translationCount = 1;
				papagoTranslateEndpoint._resetAfter = RandomNumbers.Next(150, 200);
				<enumerator>5__2 = papagoTranslateEndpoint.SetupVersion();
			}
			if (<enumerator>5__2.MoveNext())
			{
				<>2__current = <enumerator>5__2.Current;
				<>1__state = 1;
				return true;
			}
			<enumerator>5__2 = null;
			goto IL_0099;
			IL_0099:
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SetupVersion>d__25 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PapagoTranslateEndpoint <>4__this;

		private XUnityWebClient <client>5__2;

		private XUnityWebResponse <response>5__3;

		private IEnumerator <iterator>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SetupVersion>d__25(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<client>5__2 = null;
			<response>5__3 = null;
			<iterator>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			int num = <>1__state;
			PapagoTranslateEndpoint papagoTranslateEndpoint = <>4__this;
			Match match;
			string value;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<client>5__2 = new XUnityWebClient();
				<response>5__3 = <client>5__2.Send(new XUnityWebRequest(UrlBase));
				<iterator>5__4 = ((CustomYieldInstructionShim)<response>5__3).GetSupportedEnumerator();
				goto IL_0083;
			case 1:
				<>1__state = -1;
				goto IL_0083;
			case 2:
				{
					<>1__state = -1;
					break;
				}
				IL_0083:
				if (<iterator>5__4.MoveNext())
				{
					<>2__current = <iterator>5__4.Current;
					<>1__state = 1;
					return true;
				}
				match = PatternSource.Match(<response>5__3.Data);
				if (!match.Success)
				{
					XuaLogger.AutoTranslator.Warn("Could not parse papago page");
					return false;
				}
				value = match.Value;
				<response>5__3 = null;
				<iterator>5__4 = null;
				<response>5__3 = <client>5__2.Send(new XUnityWebRequest(UrlBase + value));
				<iterator>5__4 = ((CustomYieldInstructionShim)<response>5__3).GetSupportedEnumerator();
				break;
			}
			if (<iterator>5__4.MoveNext())
			{
				<>2__current = <iterator>5__4.Current;
				<>1__state = 2;
				return true;
			}
			Match match2 = PatternVersion.Match(<response>5__3.Data);
			if (!match2.Success)
			{
				XuaLogger.AutoTranslator.Warn("Could not parse papago version");
				return false;
			}
			XuaLogger.AutoTranslator.Debug("Current papago version is " + match2.Value);
			papagoTranslateEndpoint._version = match2.Value;
			<response>5__3 = null;
			<iterator>5__4 = null;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static readonly HashSet<string> SupportedLanguages = new HashSet<string>
	{
		"en", "ko", "zh-CN", "zh-TW", "es", "fr", "ru", "vi", "th", "id",
		"de", "ja", "hi", "pt"
	};

	private static readonly HashSet<string> SMTLanguages = new HashSet<string> { "hi", "pt" };

	private static readonly string UrlBase = "https://papago.naver.com";

	private static readonly string UrlN2MT = "/apis/n2mt/translate";

	private static readonly string UrlNSMT = "/apis/nsmt/translate";

	private static readonly string FormUrlEncodedTemplate = "deviceId={0}&locale=en&dict=false&honorific=false&instant=true&source={1}&target={2}&text={3}";

	private static readonly Random RandomNumbers = new Random();

	private static readonly Guid UUID = Guid.NewGuid();

	private static readonly Regex PatternSource = new Regex("/main\\.[a-f0-9]+\\.chunk\\.js", RegexOptions.Singleline);

	private static readonly Regex PatternVersion = new Regex("v\\d\\.\\d\\.\\d_[^\"]+", RegexOptions.Singleline);

	private string _version;

	private bool _isSMT;

	private int _translationCount;

	private int _resetAfter;

	public override string Id => "PapagoTranslate";

	public override string FriendlyName => "Papago Translator";

	public override int MaxTranslationsPerRequest => 10;

	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 void Initialize(IInitializationContext context)
	{
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		context.DisableCertificateChecksFor(new string[1] { "papago.naver.com" });
		string text = FixLanguage(context.SourceLanguage);
		string text2 = FixLanguage(context.DestinationLanguage);
		_isSMT = SMTLanguages.Contains(text) || SMTLanguages.Contains(text2);
		if (!SupportedLanguages.Contains(text2))
		{
			throw new EndpointInitializationException("The language '" + context.DestinationLanguage + "' is not supported by Papago Translate.");
		}
		if (_isSMT && text != "en" && text2 != "en")
		{
			throw new EndpointInitializationException("Translation from '" + context.SourceLanguage + "' to '" + context.DestinationLanguage + "' is not supported by Papago Translate.");
		}
	}

	public override IEnumerator OnBeforeTranslate(IHttpTranslationContext context)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <OnBeforeTranslate>d__22(0)
		{
			<>4__this = this
		};
	}

	public override void OnCreateRequest(IHttpRequestCreationContext context)
	{
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Expected O, but got Unknown
		string text = Uri.EscapeDataString(string.Join("\n", ((ITranslationContextBase)context).UntranslatedTexts));
		XUnityWebRequest val = new XUnityWebRequest("POST", UrlBase + (_isSMT ? UrlNSMT : UrlN2MT), string.Format(FormUrlEncodedTemplate, UUID, FixLanguage(((ITranslationContextBase)context).SourceLanguage), FixLanguage(((ITranslationContextBase)context).DestinationLanguage), text));
		DateTime utcNow = DateTime.UtcNow;
		DateTime minValue = DateTime.MinValue;
		double num = Math.Truncate(utcNow.Subtract(minValue.AddYears(1969)).TotalMilliseconds);
		byte[] bytes = Encoding.UTF8.GetBytes(_version);
		byte[] bytes2 = Encoding.UTF8.GetBytes($"{UUID}\n{val.Address}\n{num}");
		string arg = Convert.ToBase64String(new HMACMD5(bytes).ComputeHash(bytes2));
		val.Headers[HttpRequestHeader.UserAgent] = (string.IsNullOrEmpty(AutoTranslatorSettings.UserAgent) ? UserAgents.Chrome_Win10_Latest : AutoTranslatorSettings.UserAgent);
		val.Headers["Authorization"] = $"PPG {UUID}:{arg}";
		val.Headers["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";
		val.Headers["Timestamp"] = num.ToString(CultureInfo.InvariantCulture);
		context.Complete(val);
		_translationCount++;
	}

	public override void OnExtractTranslation(IHttpTranslationExtractionContext context)
	{
		string text = ((object)((JSONNode)JSON.Parse(((IHttpResponseInspectionContext)context).Response.Data).AsObject)["translatedText"]).ToString();
		string text2 = JsonHelper.Unescape(text.Substring(1, text.Length - 2));
		if (((ITranslationContextBase)context).UntranslatedTexts.Length == 1)
		{
			context.Complete(text2);
			return;
		}
		string[] array = text2.Split(new char[1] { '\n' });
		string[] array2 = new string[((ITranslationContextBase)context).UntranslatedTexts.Length];
		int num = 0;
		for (int i = 0; i < ((ITranslationContextBase)context).UntranslatedTexts.Length; i++)
		{
			string[] array3 = ((ITranslationContextBase)context).UntranslatedTexts[i].Split(new char[1] { '\n' });
			StringBuilder stringBuilder = new StringBuilder();
			for (int j = 0; j < array3.Length; j++)
			{
				string value = array[num++];
				if (array3.Length - 1 == j)
				{
					stringBuilder.Append(value);
				}
				else
				{
					stringBuilder.AppendLine(value);
				}
			}
			array2[i] = stringBuilder.ToString();
		}
		if (num != array.Length)
		{
			((ITranslationContextBase)context).Fail("Received invalid number of translations in batch.");
		}
		context.Complete(array2);
	}

	private IEnumerator SetupVersion()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SetupVersion>d__25(0)
		{
			<>4__this = this
		};
	}
}
internal static class GeneratedInfo
{
	public const string PROJECT_VERSION = "5.6.1";
}