#if NET5_0_OR_NETFRAMEWORK
using System.Runtime.CompilerServices;
#endif
// Added SKIP_LICENSE_CHECK preprocessor definition that can be enabled to bypass all license checks
#define SKIP_LICENSE_CHECK
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
#if NET5_0_OR_GREATER || NET6_0_OR_GREATER
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Http.Json;
#else
using System.Net;
using System.Net.Http;
#endif
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Bunifu.Licensing.Helpers;
using Bunifu.Licensing.Models;
using Bunifu.Licensing.Options;
using Bunifu.Licensing.Properties;
using Bunifu.Licensing.Views;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.ComponentModel;
using System.Net;
using System.Runtime.CompilerServices;

namespace Bunifu.Licensing
{
	// Token: 0x02000003 RID: 3
	[DebuggerStepThrough]
	public sealed class LicenseValidator
	{
		// Token: 0x17000001 RID: 1
		// (get) Token: 0x06000008 RID: 8 RVA: 0x0000275C File Offset: 0x0000095C
		public static bool DesignMode2
		{
			get
			{
				return Application.ExecutablePath.IndexOf("DesignToolsServer.exe", StringComparison.OrdinalIgnoreCase) > -1;
			}
		}

		// Token: 0x17000002 RID: 2
		// (get) Token: 0x06000009 RID: 9 RVA: 0x0000278C File Offset: 0x0000098C
		// (set) Token: 0x0600000A RID: 10 RVA: 0x00002793 File Offset: 0x00000993
		internal static string ResponseError { get; private set; }

		// Token: 0x17000003 RID: 3
		// (get) Token: 0x0600000B RID: 11 RVA: 0x0000279C File Offset: 0x0000099C
		private static bool DesignMode
		{
			get
			{
				return LicenseManager.UsageMode == LicenseUsageMode.Designtime || Debugger.IsAttached;
			}
		}

		// Token: 0x17000004 RID: 4
		// (get) Token: 0x0600000C RID: 12 RVA: 0x000027CC File Offset: 0x000009CC
		internal static bool LicenseExpired
		{
			get
			{
				return LicenseValidator.RetrievedLicense.License.Status == StatusOptions.Expired;
			}
		}

		// Token: 0x17000005 RID: 5
		// (get) Token: 0x0600000D RID: 13 RVA: 0x000027FC File Offset: 0x000009FC
		private static string LicenseFolder
		{
			get
			{
				string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(2, 2);
				defaultInterpolatedStringHandler.AppendLiteral("\\");
				defaultInterpolatedStringHandler.AppendFormatted(Resources.CPA);
				defaultInterpolatedStringHandler.AppendLiteral("\\");
				defaultInterpolatedStringHandler.AppendFormatted<ProductTypes>(LicenseValidator.Product);
				return folderPath + defaultInterpolatedStringHandler.ToStringAndClear();
			}
		}

		// Token: 0x17000006 RID: 6
		// (get) Token: 0x0600000E RID: 14 RVA: 0x00002860 File Offset: 0x00000A60
		private static string LicenseFile
		{
			get
			{
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(5, 2);
				defaultInterpolatedStringHandler.AppendFormatted(LicenseValidator.LicenseFolder);
				defaultInterpolatedStringHandler.AppendLiteral("\\");
				defaultInterpolatedStringHandler.AppendFormatted<ProductTypes>(LicenseValidator.Product);
				defaultInterpolatedStringHandler.AppendLiteral(".lic");
				return defaultInterpolatedStringHandler.ToStringAndClear();
			}
		}

		// Token: 0x17000007 RID: 7
		// (get) Token: 0x0600000F RID: 15 RVA: 0x000028B4 File Offset: 0x00000AB4
		// (set) Token: 0x06000010 RID: 16 RVA: 0x000028FF File Offset: 0x00000AFF
		internal static Record RetrievedLicense
		{
			get
			{
				bool flag = LicenseValidator._retrievedLicense != null && LicenseValidator._retrievedLicense.IsValid;
				Record record;
				if (flag)
				{
					bool flag2 = LicenseValidator.IsProductLicenseAvailable(LicenseValidator._retrievedLicense, LicenseValidator.Product);
					if (flag2)
					{
						record = LicenseValidator._retrievedLicense;
					}
					else
					{
						record = null;
					}
				}
				else
				{
					record = null;
				}
				return record;
			}
			set
			{
				LicenseValidator._retrievedLicense = value;
			}
		}

		// Token: 0x17000008 RID: 8
		// (get) Token: 0x06000011 RID: 17 RVA: 0x00002907 File Offset: 0x00000B07
		// (set) Token: 0x06000012 RID: 18 RVA: 0x0000290E File Offset: 0x00000B0E
		internal static ProductTypes Product { get; set; }

		// Token: 0x17000009 RID: 9
		// (get) Token: 0x06000013 RID: 19 RVA: 0x00002916 File Offset: 0x00000B16
		// (set) Token: 0x06000014 RID: 20 RVA: 0x0000291D File Offset: 0x00000B1D
		internal static Type LicensedControlType { get; set; }

		// Token: 0x1700000A RID: 10
		// (get) Token: 0x06000015 RID: 21 RVA: 0x00002925 File Offset: 0x00000B25
		// (set) Token: 0x06000016 RID: 22 RVA: 0x0000292C File Offset: 0x00000B2C
		internal static object LicensedControlInstance { get; set; }

		// Token: 0x06000017 RID: 23 RVA: 0x00002934 File Offset: 0x00000B34
		public static License Validate(ProductTypes product, Type control = null)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, return a valid license without any checks
			var license = LicenseBypass.CreateFakeLicense(product);
			_retrievedLicense = license as Record;
			return license;
#else
			control = typeof(Button);
			LicenseValidator.Product = product;
			LicenseValidator._activator.FromCli = false;
			return LicenseValidator.GetProductLicense(product, new LicenseContext(), control);
#endif
		}

		// Token: 0x06000018 RID: 24 RVA: 0x00002974 File Offset: 0x00000B74
		public static License Validate(ProductTypes product, Type control, object instance)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, return a valid license without any checks
			var license = LicenseBypass.CreateFakeLicense(product);
			_retrievedLicense = license as Record;
			return license;
#else
			LicenseValidator.Product = product;
			return LicenseManager.Validate(control, instance);
#endif
		}

		// Token: 0x06000019 RID: 25 RVA: 0x00002998 File Offset: 0x00000B98
		public static License Activate(ProductTypes product, bool fromCli = false)
		{
			LicenseValidator.Product = product;
			LicenseValidator._activator.FromCli = fromCli;
			LicenseValidator._activator.ShowDialog();
			bool licenseCreated = LicenseActivator.LicenseCreated;
			License license;
			if (licenseCreated)
			{
				license = LicenseValidator.RetrievedLicense;
			}
			else
			{
				license = null;
			}
			return license;
		}

		// Token: 0x0600001A RID: 26 RVA: 0x000029DC File Offset: 0x00000BDC
		internal static Record Validate(string email, string licenseKey)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, return a fake valid record
			return LicenseBypass.CreateFakeRecord(email, licenseKey, LicenseValidator.Product);
#else
			Record record2;
			try
			{
				LicenseValidator.ResponseError = string.Empty;
				Logger.Add("Activation request initiated.");
				v2Request v2Request = new v2Request
				{
					DeviceID = LicenseValidator.GetHardwareID(),
					DeviceName = Environment.MachineName,
					OS = Hardware.GetOSName(),
					Email = email,
					LicenseKey = licenseKey
				};
				//LicenseValidator._apiClient.DefaultRequestHeaders.Accept.Clear();
				//LicenseValidator._apiClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); net462 issues..
				LicenseValidator._apiClient.BaseAddress = new Uri(Resources.BUL);
				Logger.Add("Request successfully created.");
				StringContent stringContent = new StringContent(JsonConvert.SerializeObject(v2Request), Encoding.UTF8, "application/json");
				Logger.Add("Request now being sent...");
				HttpResponseMessage result = LicenseValidator._apiClient.PostAsync("", stringContent).GetAwaiter().GetResult();
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(19, 1);
				defaultInterpolatedStringHandler.AppendLiteral("Response received: ");
				defaultInterpolatedStringHandler.AppendFormatted<HttpStatusCode>(result.StatusCode);
				Logger.Add(defaultInterpolatedStringHandler.ToStringAndClear());
				bool flag = result.StatusCode == HttpStatusCode.Created;
				if (flag)
				{
					Logger.Add("License verified (200).");
					Logger.Add("Preparing to parse response object...");
					JObject jobject = JObject.Parse(result.Content.ToString());
					Record record = new Record();
					try
					{
						record.IsValid = true;
						record.ID = (int)jobject["id"];
						record.UUID = (string)jobject["uuid"];
						record.CreatedAt = new DateTime?(LicenseValidator.IsNullDateTime(jobject["created_at"]));
						record.RemovedAt = new DateTime?(LicenseValidator.IsNullDateTime(jobject["removed_at"]));
						Logger.Add("Header object fields parsed.");
						record.Device.ID = (int)jobject["device_id"];
						record.Device.Name = (string)jobject["device"]["name"];
						record.Device.HardwareID = (string)jobject["device"]["hw_id"];
						record.Device.OS = (string)jobject["device"]["os"];
						record.Device.Blocked = (bool)jobject["device"]["blocked"];
						record.Device.LastSeen = LicenseValidator.IsNullDateTime(jobject["device"]["last_seen"]);
						Logger.Add("Device object fields parsed.");
						record.Client.ID = LicenseValidator.IsNullInt(jobject["client"]["id"]);
						record.Client.TeamID = LicenseValidator.IsNullInt(jobject["client"]["team_id"]);
						record.Client.WPUserID = LicenseValidator.IsNullInt(jobject["client"]["wp_user_id"]);
						record.Client.IsTeamAdmin = (bool)jobject["client"]["is_team_admin"];
						record.Client.Name = (string)jobject["client"]["name"];
						record.Client.Email = (string)jobject["client"]["email"];
						record.Client.Blocked = (bool)jobject["client"]["blocked"];
						record.Client.CreatedAt = LicenseValidator.IsNullDateTime(jobject["client"]["created_at"]);
						Logger.Add("Client object fields parsed.");
						record._licenseKey = licenseKey;
						record.License.ID = (int)jobject["license"]["id"];
						record.License.UUID = (string)jobject["license"]["uuid"];
						record.License.BundleID = new int?(LicenseValidator.IsNullInt(jobject["license"]["bundle_id"]));
						record.License.TeamID = new int?(LicenseValidator.IsNullInt(jobject["license"]["team_id"]));
						record.License.UserID = new int?(LicenseValidator.IsNullInt(jobject["license"]["user_id"]));
						record.License.PurchaseID = LicenseValidator.IsNullInt(jobject["license"]["purchase_ref_id"]);
						record.License.Plan = (string)jobject["license"]["name"];
						record.License.Product = LicenseValidator.Product;
						record.License.TotalDays = (int)jobject["license"]["duration"];
						record.License.MaxDevices = (int)jobject["license"]["no_of_devices"];
						record.License.RemainingDevices = (int)jobject["license"]["devices_remaining"];
						record.License.Activations = (int)jobject["license"]["activations"];
						record.License.CreatedAt = LicenseValidator.IsNullDateTime(jobject["license"]["created_at"]);
						record.License.LicenseKeyID = new int?((int)jobject["license_key_id"]);
						Logger.Add("License object fields parsed.");
						string text = jobject["license"]["type"].ToString().ToLower();
						string text2 = jobject["license"]["status"].ToString().ToLower();
						JArray jarray = JsonConvert.DeserializeObject<JArray>(jobject["license"]["products"].ToString());
						Logger.Add("Special license object fields parsed.");
						foreach (JToken jtoken in jarray)
						{
							bool flag2 = jtoken.Type != JTokenType.Object;
							if (flag2)
							{
								record.License.ProductsLicensed.Add(new Product
								{
									ID = (int)jtoken["id"],
									Name = LicenseValidator.GetProduct((int)jtoken["id"]),
									UUID = (string)jtoken["uuid"]
								});
							}
						}
						Logger.Add("Licensed products successfully added.");
						record.License.Type = LicenseValidator.GetTypeEnum(text);
						record.License.Status = LicenseValidator.GetStatusEnum(text2);
						bool flag3 = record.License.TotalDays > 14 && record.License.TotalDays <= 365;
						if (flag3)
						{
							record.License.Type = LicenseTypes.Premium;
						}
						else
						{
							bool flag4 = record.License.TotalDays >= 1000000;
							if (flag4)
							{
								record.License.Type = LicenseTypes.Enterprise;
							}
						}
						Logger.Add("Special license enum fields casted.");
						Logger.Add("Activation succeeded.");
					}
					catch (Exception ex)
					{
						Logger.Add("Exception raised while parsing response: " + ex.Message + ".");
						LicenseValidator.ResponseError = ex.Message;
						LicenseValidator.RetrievedLicense = new Record
						{
							IsValid = false
						};
						return LicenseValidator.RetrievedLicense;
					}
					bool flag5 = LicenseValidator.IsProductLicenseAvailable(record, LicenseValidator.Product);
					if (flag5)
					{
						LicenseValidator.RetrievedLicense = record;
						record2 = record;
					}
					else
					{
						string text3 = string.Join(", ", LicenseValidator.GetProductsLicensed(record, LicenseValidator.Product, true));
						LicenseValidator.ResponseError = "[404] Product License Mismatch. Your license caters for " + text3 + ".";
						Logger.Add(LicenseValidator.ResponseError);
						LicenseValidator.RetrievedLicense = new Record
						{
							IsValid = false
						};
						record2 = LicenseValidator.RetrievedLicense;
					}
				}
				else
				{
					bool flag6 = result.StatusCode == HttpStatusCode.Forbidden;
					if (flag6)
					{
						JObject jobject2 = JObject.Parse(result.Content.ToString());
						LicenseValidator.ResponseError = "[403] " + (string)jobject2["message"];
						bool flag7 = LicenseValidator.ResponseError.ToLower().Contains("key is blocked");
						if (flag7)
						{
							Logger.Add("License blocked; revocation executed.");
							LicenseValidator.ResponseError = "[403] Your license has been blocked.\n\nIf this was unintentional, please visit our support site: https://bunifuframework.com/support.";
						}
						Logger.Add(LicenseValidator.ResponseError);
						LicenseValidator.RetrievedLicense = new Record
						{
							IsValid = false
						};
						record2 = LicenseValidator._retrievedLicense;
					}
					else
					{
						bool flag8 = !Network.IsAvailable();
						if (flag8)
						{
							LicenseValidator.ResponseError = Strings.Exceptions.NetworkUnavailable;
							Logger.Add("Network unavailable.");
						}
						else
						{
							bool flag9 = result.StatusCode.ToString() == "0";
							if (flag9)
							{
								LicenseValidator.ResponseError = "[101] TLS-1.2 request did not succeed.";
							}
							else
							{
								defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(3, 2);
								defaultInterpolatedStringHandler.AppendLiteral("[");
								defaultInterpolatedStringHandler.AppendFormatted<HttpStatusCode>(result.StatusCode);
								defaultInterpolatedStringHandler.AppendLiteral("] ");
								defaultInterpolatedStringHandler.AppendFormatted<HttpContent>(result.Content);
								LicenseValidator.ResponseError = defaultInterpolatedStringHandler.ToStringAndClear();
							}
							Logger.Add(LicenseValidator.ResponseError);
						}
						LicenseValidator.RetrievedLicense = new Record
						{
							IsValid = false
						};
						record2 = LicenseValidator._retrievedLicense;
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Add("[Exception] " + ex2.Message + "; " + ex2.StackTrace);
				LicenseValidator.ResponseError = ex2.Message;
				LicenseValidator.RetrievedLicense = new Record
				{
					IsValid = false
				};
				record2 = LicenseValidator._retrievedLicense;
			}
			return record2;
#endif
		}

		// Token: 0x0600001B RID: 27 RVA: 0x000034F4 File Offset: 0x000016F4
		internal static Record Validate(string email, string licenseKey, ProductTypes product)
		{
			LicenseValidator.Product = product;
			return LicenseValidator.Validate(email, licenseKey);
		}

		// Token: 0x0600001C RID: 28 RVA: 0x00003514 File Offset: 0x00001714
		internal static ActivationResults Activate(string email, string licenseKey)
		{
			ActivationResults activationResults;
			try
			{
				Record record = LicenseValidator.Validate(email, licenseKey);
				bool flag = record == null;
				if (flag)
				{
					Logger.Add("License not found for " + email + ".");
					activationResults = ActivationResults.ProductLicenseMismatch;
				}
				else
				{
					bool isValid = record.IsValid;
					if (isValid)
					{
						LicenseValidator.CreateLicense(record);
						Logger.Add("License created.");
						activationResults = ActivationResults.Success;
					}
					else
					{
						bool flag2 = LicenseValidator.ResponseError.Contains("[101]");
						if (flag2)
						{
							Logger.Add("TLS 1.2 not supported.");
							activationResults = ActivationResults.TLS12Issue;
						}
						else
						{
							bool flag3 = LicenseValidator.ResponseError.Contains("[403]");
							if (flag3)
							{
								Logger.Add("License activation forbidden.");
								activationResults = ActivationResults.Forbidden;
							}
							else
							{
								Logger.Add("License activation failed.");
								activationResults = ActivationResults.Failed;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				bool flag4 = !Network.IsAvailable();
				if (flag4)
				{
					Logger.Add("[Exception] Network unavailable.");
					LicenseValidator.ResponseError = Strings.Exceptions.NetworkUnavailable;
				}
				else
				{
					Logger.Add("[Exception] " + ex.Message + ".");
					LicenseValidator.ResponseError = ex.Message;
				}
				activationResults = ActivationResults.ExceptionRaised;
			}
			return activationResults;
		}

		// Token: 0x0600001D RID: 29 RVA: 0x00003640 File Offset: 0x00001840
		internal static ActivationResults Activate(string email, string licenseKey, ProductTypes product)
		{
			LicenseValidator.Product = product;
			return LicenseValidator.Activate(email, licenseKey);
		}

		// Token: 0x0600001E RID: 30 RVA: 0x00003660 File Offset: 0x00001860
		internal static bool CreateLicense(Record license)
		{
			Registry.Licensing.SaveLicense(license);
			return true;
		}

		// Token: 0x0600001F RID: 31 RVA: 0x0000367C File Offset: 0x0000187C
		internal static Record ReadLicense(bool forceRead = false)
		{
			Record record;
			try
			{
				if (forceRead)
				{
					LicenseValidator.RetrievedLicense = Registry.Licensing.GetLicense(LicenseValidator.Product);
					record = LicenseValidator.RetrievedLicense;
				}
				else
				{
					bool flag = LicenseValidator._retrievedLicense != null;
					if (flag)
					{
						record = LicenseValidator.RetrievedLicense;
					}
					else
					{
						LicenseValidator.RetrievedLicense = Registry.Licensing.GetLicense(LicenseValidator.Product);
						record = LicenseValidator.RetrievedLicense;
					}
				}
			}
			catch (Exception)
			{
				record = new Record
				{
					IsValid = false
				};
			}
			return record;
		}

		// Token: 0x06000020 RID: 32 RVA: 0x000036FC File Offset: 0x000018FC
		internal static bool DeleteLicense(bool deleteLicenseInfoFile)
		{
			bool flag;
			try
			{
				flag = Registry.Licensing.DeleteLicense(LicenseValidator.Product, deleteLicenseInfoFile);
			}
			catch (Exception)
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x06000021 RID: 33 RVA: 0x00003730 File Offset: 0x00001930
		internal static bool LicenseExists()
		{
			bool flag = false;
			string hardwareID = LicenseValidator.GetHardwareID();
			Record license = Registry.Licensing.GetLicense(LicenseValidator.Product);
			bool flag2 = license.Device.HardwareID == hardwareID;
			if (flag2)
			{
				LicenseValidator.RetrievedLicense = license;
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000022 RID: 34 RVA: 0x00003778 File Offset: 0x00001978
		private static int GetProductID()
		{
			int num = 0;
			bool flag = LicenseValidator.LicenseExists();
			if (flag)
			{
				bool flag2 = LicenseValidator.RetrievedLicense.LicenseKey.StartsWith("FREE");
				if (flag2)
				{
					num = 0;
				}
				else
				{
					bool flag3 = LicenseValidator.RetrievedLicense.License.TotalDays >= 10000;
					if (flag3)
					{
						num = 112860;
					}
					else
					{
						bool flag4 = LicenseValidator.RetrievedLicense.ID.ToString().StartsWith("26");
						if (flag4)
						{
							num = LicenseValidator.RetrievedLicense.ID;
						}
						else
						{
							bool flag5 = LicenseValidator.RetrievedLicense.License.Product == ProductTypes.UIWinForms;
							if (flag5)
							{
								num = 25428;
							}
							else
							{
								bool flag6 = LicenseValidator.RetrievedLicense.License.Product == ProductTypes.DatavizBasicWinForms;
								if (flag6)
								{
									num = 25429;
								}
								else
								{
									bool flag7 = LicenseValidator.RetrievedLicense.License.Product == ProductTypes.DatavizAdvancedWinForms;
									if (flag7)
									{
										num = 25431;
									}
									else
									{
										bool flag8 = LicenseValidator.RetrievedLicense.License.Product == ProductTypes.Charts;
										if (flag8)
										{
											num = 262207;
										}
									}
								}
							}
						}
					}
				}
			}
			else
			{
				bool flag9 = LicenseValidator.Product == ProductTypes.UIWinForms;
				if (flag9)
				{
					num = 25428;
				}
				else
				{
					bool flag10 = LicenseValidator.Product == ProductTypes.DatavizBasicWinForms;
					if (flag10)
					{
						num = 25429;
					}
					else
					{
						bool flag11 = LicenseValidator.Product == ProductTypes.DatavizAdvancedWinForms;
						if (flag11)
						{
							num = 25431;
						}
						else
						{
							bool flag12 = LicenseValidator.Product == ProductTypes.Charts;
							if (flag12)
							{
								num = 262207;
							}
						}
					}
				}
			}
			return num;
		}

		// Token: 0x06000023 RID: 35 RVA: 0x000038FC File Offset: 0x00001AFC
		internal static string GetRenewalLink(string licenseKey = "")
		{
			int productID = LicenseValidator.GetProductID();
			bool flag = LicenseValidator.LicenseExists();
			string text;
			if (flag)
			{
				licenseKey = LicenseValidator.RetrievedLicense.LicenseKey;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(67, 2);
				defaultInterpolatedStringHandler.AppendLiteral("https://bunifuframework.com/checkout/?edd_license_key=");
				defaultInterpolatedStringHandler.AppendFormatted(licenseKey);
				defaultInterpolatedStringHandler.AppendLiteral("&download_id=");
				defaultInterpolatedStringHandler.AppendFormatted<int>(productID);
				text = defaultInterpolatedStringHandler.ToStringAndClear();
			}
			else
			{
				bool flag2 = string.IsNullOrWhiteSpace(licenseKey);
				if (flag2)
				{
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(72, 1);
					defaultInterpolatedStringHandler.AppendLiteral("https://bunifuframework.com/checkout?edd_action=add_to_cart&download_id=");
					defaultInterpolatedStringHandler.AppendFormatted<int>(productID);
					text = defaultInterpolatedStringHandler.ToStringAndClear();
				}
				else
				{
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(67, 2);
					defaultInterpolatedStringHandler.AppendLiteral("https://bunifuframework.com/checkout/?edd_license_key=");
					defaultInterpolatedStringHandler.AppendFormatted(licenseKey);
					defaultInterpolatedStringHandler.AppendLiteral("&download_id=");
					defaultInterpolatedStringHandler.AppendFormatted<int>(productID);
					text = defaultInterpolatedStringHandler.ToStringAndClear();
				}
			}
			return text;
		}

		// Token: 0x06000024 RID: 36 RVA: 0x000039E0 File Offset: 0x00001BE0
		internal static string GetHardwareID()
		{
			return Hardware.GetUniqueID();
		}

		// Token: 0x06000025 RID: 37 RVA: 0x000039F8 File Offset: 0x00001BF8
		internal static bool IsLicenseValid(Record license)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, always return true
			return true;
#else
			bool flag3;
			try
			{
				bool flag = license != null;
				if (flag)
				{
					bool flag2 = license.Device.HardwareID == LicenseValidator.GetHardwareID();
					if (flag2)
					{
						flag3 = true;
					}
					else
					{
						flag3 = false;
					}
				}
				else
				{
					flag3 = false;
				}
			}
			catch (Exception)
			{
				flag3 = false;
			}
			return flag3;
#endif
		}

		// Token: 0x06000026 RID: 38 RVA: 0x00003A50 File Offset: 0x00001C50
		internal static bool IsDateBackdated()
		{
			bool flag = LicenseValidator._retrievedLicense != null && LicenseValidator._retrievedLicense.IsValid;
			bool flag3;
			if (flag)
			{
				int num = LicenseValidator._retrievedLicense.License.CreatedAt.Date.CompareTo(DateTime.Now.Date);
				bool flag2 = num == 1;
				flag3 = flag2;
			}
			else
			{
				int num2 = InternetTime.GetDateTime().Date.CompareTo(DateTime.Now.Date);
				bool flag4 = num2 == 1;
				flag3 = flag4;
			}
			return flag3;
		}

		// Token: 0x06000027 RID: 39 RVA: 0x00003AF8 File Offset: 0x00001CF8
		internal static void InnerValidate(ProductTypes product, Type control, object instance)
		{
			bool designMode = LicenseValidator.DesignMode;
			if (designMode)
			{
				ValidationResults validationResults = LicenseValidator.Validate(product);
				LicenseValidator.LicensedControlType = control;
				LicenseValidator.LicensedControlInstance = instance;
				LicenseValidator.ProvideResponse(validationResults, product, control, instance);
			}
		}

		// Token: 0x06000028 RID: 40 RVA: 0x00003B30 File Offset: 0x00001D30
		internal static void ThrowRuntimeLicenseException()
		{
			LicenseValidator._activator.Hide();
			bool flag = LicenseValidator.Product == ProductTypes.UIWinForms;
			if (flag)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "This product does not have a registered Bunifu UI license to run.");
			}
			bool flag2 = LicenseValidator.Product == ProductTypes.Charts;
			if (flag2)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "This product does not have a registered Bunifu Charts license to run.");
			}
			bool flag3 = LicenseValidator.Product == ProductTypes.DatavizBasicWinForms;
			if (flag3)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "This product does not have a registered Bunifu Dataviz license to run.");
			}
			bool flag4 = LicenseValidator.Product == ProductTypes.DatavizAdvancedWinForms;
			if (flag4)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "This product does not have a registered Bunifu Dataviz license to run.");
			}
		}

		// Token: 0x06000029 RID: 41 RVA: 0x00003BD4 File Offset: 0x00001DD4
		internal static void ThrowLicenseNonExistentException()
		{
			LicenseValidator._activator.Hide();
			bool flag = LicenseValidator.Product == ProductTypes.UIWinForms;
			if (flag)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have an active Bunifu UI WinForms license.");
			}
			bool flag2 = LicenseValidator.Product == ProductTypes.Charts;
			if (flag2)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have an active Bunifu Charts license.");
			}
			bool flag3 = LicenseValidator.Product == ProductTypes.DatavizBasicWinForms;
			if (flag3)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have an active Bunifu Dataviz Basic license.");
			}
			bool flag4 = LicenseValidator.Product == ProductTypes.DatavizAdvancedWinForms;
			if (flag4)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have an active Bunifu Dataviz Advanced license.");
			}
		}

		// Token: 0x0600002A RID: 42 RVA: 0x00003C78 File Offset: 0x00001E78
		internal static void ThrowLicenseInvalidException()
		{
			bool flag = LicenseValidator.Product == ProductTypes.UIWinForms;
			if (flag)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have a valid Bunifu UI WinForms license.");
			}
			bool flag2 = LicenseValidator.Product == ProductTypes.Charts;
			if (flag2)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have a valid Bunifu Charts license.");
			}
			bool flag3 = LicenseValidator.Product == ProductTypes.DatavizBasicWinForms;
			if (flag3)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have a valid Bunifu Dataviz Basic license.");
			}
			bool flag4 = LicenseValidator.Product == ProductTypes.DatavizAdvancedWinForms;
			if (flag4)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure you have a valid Bunifu Dataviz Advanced license.");
			}
		}

		// Token: 0x0600002B RID: 43 RVA: 0x00003D10 File Offset: 0x00001F10
		internal static void ThrowLicenseExpiredException()
		{
			bool flag = LicenseValidator.Product == ProductTypes.UIWinForms;
			if (flag)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu UI WinForms license has expired.");
			}
			bool flag2 = LicenseValidator.Product == ProductTypes.Charts;
			if (flag2)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu Charts license has expired.");
			}
			bool flag3 = LicenseValidator.Product == ProductTypes.DatavizBasicWinForms;
			if (flag3)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu Dataviz Basic license has expired.");
			}
			bool flag4 = LicenseValidator.Product == ProductTypes.DatavizAdvancedWinForms;
			if (flag4)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu Dataviz Advanced license has expired.");
			}
		}

		// Token: 0x0600002C RID: 44 RVA: 0x00003DA8 File Offset: 0x00001FA8
		internal static void ThrowLicenseBlockedException()
		{
			LicenseValidator._activator.Hide();
			bool flag = LicenseValidator.Product == ProductTypes.UIWinForms;
			if (flag)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu UI license has been blocked.");
			}
			bool flag2 = LicenseValidator.Product == ProductTypes.Charts;
			if (flag2)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu Charts license has been blocked.");
			}
			bool flag3 = LicenseValidator.Product == ProductTypes.DatavizBasicWinForms;
			if (flag3)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu Dataviz Basic license has been blocked.");
			}
			bool flag4 = LicenseValidator.Product == ProductTypes.DatavizAdvancedWinForms;
			if (flag4)
			{
				throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Your Bunifu Dataviz Advanced license has been blocked.");
			}
		}

		// Token: 0x0600002D RID: 45 RVA: 0x00003E49 File Offset: 0x00002049
		internal static void ThrowSystemBackdatedException()
		{
			throw new LicenseException(LicenseValidator.LicensedControlType, LicenseValidator.LicensedControlInstance, "Please ensure your System Date/Time is correct.");
		}

		// Token: 0x0600002E RID: 46 RVA: 0x00003E60 File Offset: 0x00002060
		private static void ProvideResponse(ValidationResults result, ProductTypes product, Type control, object instance)
		{
			bool flag = result == ValidationResults.LicenseBlocked;
			if (flag)
			{
				bool flag2 = product == ProductTypes.UIWinForms;
				if (flag2)
				{
					throw new LicenseException(control, instance, "Your Bunifu UI license has been blocked.");
				}
				bool flag3 = product == ProductTypes.DatavizBasicWinForms;
				if (flag3)
				{
					throw new LicenseException(control, instance, "Your Bunifu Dataviz Basic license has been blocked.");
				}
				bool flag4 = product == ProductTypes.DatavizAdvancedWinForms;
				if (flag4)
				{
					throw new LicenseException(control, instance, "Your Bunifu Dataviz Advanced license has been blocked.");
				}
				bool flag5 = product == ProductTypes.Charts;
				if (flag5)
				{
					throw new LicenseException(control, instance, "Your Bunifu Charts license has been blocked.");
				}
			}
			else
			{
				bool flag6 = result == ValidationResults.LicenseExpired;
				if (flag6)
				{
					bool flag7 = product == ProductTypes.UIWinForms;
					if (flag7)
					{
						throw new LicenseException(control, instance, "Your Bunifu UI WinForms license has expired.");
					}
					bool flag8 = product == ProductTypes.DatavizBasicWinForms;
					if (flag8)
					{
						throw new LicenseException(control, instance, "Your Bunifu Dataviz Basic license has expired.");
					}
					bool flag9 = product == ProductTypes.DatavizAdvancedWinForms;
					if (flag9)
					{
						throw new LicenseException(control, instance, "Your Bunifu Dataviz Advanced license has expired.");
					}
					bool flag10 = product == ProductTypes.Charts;
					if (flag10)
					{
						throw new LicenseException(control, instance, "Your Bunifu Charts license has expired.");
					}
				}
				else
				{
					bool flag11 = result == ValidationResults.LicenseNonExistent;
					if (flag11)
					{
						LicenseValidator._activator.ShowDialog();
						bool flag12 = !LicenseActivator.LicenseCreated;
						if (flag12)
						{
							bool flag13 = product == ProductTypes.UIWinForms;
							if (flag13)
							{
								throw new LicenseException(control, instance, "Please ensure you have an active Bunifu UI WinForms license.");
							}
							bool flag14 = product == ProductTypes.DatavizBasicWinForms;
							if (flag14)
							{
								throw new LicenseException(control, instance, "Please ensure you have an active Bunifu Dataviz Basic license.");
							}
							bool flag15 = product == ProductTypes.DatavizAdvancedWinForms;
							if (flag15)
							{
								throw new LicenseException(control, instance, "Please ensure you have an active Bunifu Dataviz Advanced license.");
							}
							bool flag16 = product == ProductTypes.Charts;
							if (flag16)
							{
								throw new LicenseException(control, instance, "Please ensure you have an active Bunifu Charts license.");
							}
						}
					}
				}
			}
		}

		// Token: 0x0600002F RID: 47 RVA: 0x00003FC4 File Offset: 0x000021C4
		private static ValidationResults Validate(ProductTypes product)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, always return a valid result
			return ValidationResults.LicenseActive;
#else
			LicenseValidator.Product = product;
			bool flag = LicenseValidator.LicenseExists();
			ValidationResults validationResults;
			if (flag)
			{
				bool licenseExpired = LicenseValidator.LicenseExpired;
				if (licenseExpired)
				{
					validationResults = ValidationResults.LicenseExpired;
				}
				else
				{
					validationResults = ValidationResults.LicenseActive;
				}
			}
			else
			{
				validationResults = ValidationResults.LicenseNonExistent;
			}
			return validationResults;
#endif
		}

		// Token: 0x06000030 RID: 48 RVA: 0x00003FFC File Offset: 0x000021FC
		internal static string ListProductsLicensed(Record license, ProductTypes primaryProduct, bool excludePrimaryProduct = true)
		{
			string text;
			try
			{
				List<string> list = new List<string>();
				foreach (Product product in license.License.ProductsLicensed)
				{
					if (excludePrimaryProduct)
					{
						bool flag = product.Name != primaryProduct;
						if (flag)
						{
							list.Add(LicenseValidator.CastProductEnum(product.Name));
						}
					}
					else
					{
						list.Add(LicenseValidator.CastProductEnum(product.Name));
					}
				}
				text = string.Join(", ", list);
			}
			catch (Exception)
			{
				text = string.Empty;
			}
			return text;
		}

		// Token: 0x06000031 RID: 49 RVA: 0x000040C4 File Offset: 0x000022C4
		internal static List<string> GetProductsLicensed(Record license, ProductTypes primaryProduct, bool excludePrimaryProduct = true)
		{
			List<string> list2;
			try
			{
				List<string> list = new List<string>();
				foreach (Product product in license.License.ProductsLicensed)
				{
					if (excludePrimaryProduct)
					{
						bool flag = product.Name != primaryProduct;
						if (flag)
						{
							list.Add(LicenseValidator.CastProductEnum(product.Name));
						}
					}
					else
					{
						list.Add(LicenseValidator.CastProductEnum(product.Name));
					}
				}
				list2 = list;
			}
			catch (Exception)
			{
				list2 = new List<string>();
			}
			return list2;
		}

		// Token: 0x06000032 RID: 50 RVA: 0x00004180 File Offset: 0x00002380
		internal static bool IsProductLicenseAvailable(Record license, ProductTypes product)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, always return true
			return true;
#else
			bool flag = false;
			try
			{
				foreach (Product product2 in license.License.ProductsLicensed)
				{
					bool flag2 = product2.Name == product;
					if (flag2)
					{
						flag = true;
					}
				}
			}
			catch (Exception)
			{
			}
			return flag;
#endif
		}

		// Token: 0x06000033 RID: 51 RVA: 0x00004204 File Offset: 0x00002404
		internal static int IsNullInt(JToken value)
		{
			bool flag = value.Type != JTokenType.Null;
			int num;
			if (flag)
			{
				num = Convert.ToInt32(value);
			}
			else
			{
				num = 0;
			}
			return num;
		}

		// Token: 0x06000034 RID: 52 RVA: 0x00004234 File Offset: 0x00002434
		internal static DateTime IsNullDateTime(JToken value)
		{
			bool flag = value.Type != JTokenType.Null;
			DateTime dateTime;
			if (flag)
			{
				dateTime = Convert.ToDateTime(value);
			}
			else
			{
				dateTime = DateTime.MinValue;
			}
			return dateTime;
		}

		// Token: 0x06000035 RID: 53 RVA: 0x00004268 File Offset: 0x00002468
		internal static ProductTypes GetProduct(int productID)
		{
			bool flag = productID == 1;
			ProductTypes productTypes;
			if (flag)
			{
				productTypes = ProductTypes.UIWinForms;
			}
			else
			{
				bool flag2 = productID == 2;
				if (flag2)
				{
					productTypes = ProductTypes.Charts;
				}
				else
				{
					bool flag3 = productID == 3;
					if (flag3)
					{
						productTypes = ProductTypes.DatavizBasicWinForms;
					}
					else
					{
						bool flag4 = productID == 4;
						if (flag4)
						{
							productTypes = ProductTypes.DatavizAdvancedWinForms;
						}
						else
						{
							productTypes = ProductTypes.UIWinForms;
						}
					}
				}
			}
			return productTypes;
		}

		// Token: 0x06000036 RID: 54 RVA: 0x000042B0 File Offset: 0x000024B0
		internal static string GetProductName(ProductTypes product)
		{
			bool flag = product == ProductTypes.UIWinForms;
			string text;
			if (flag)
			{
				text = "Bunifu UI WinForms";
			}
			else
			{
				bool flag2 = product == ProductTypes.DatavizBasicWinForms;
				if (flag2)
				{
					text = "Bunifu Dataviz Basic";
				}
				else
				{
					bool flag3 = product == ProductTypes.DatavizAdvancedWinForms;
					if (flag3)
					{
						text = "Bunifu Dataviz Advanced";
					}
					else
					{
						bool flag4 = product == ProductTypes.Charts;
						if (flag4)
						{
							text = "Bunifu Charts";
						}
						else
						{
							text = product.ToString();
						}
					}
				}
			}
			return text;
		}

		// Token: 0x06000037 RID: 55 RVA: 0x00004314 File Offset: 0x00002514
		internal static LicenseTypes GetTypeEnum(string type)
		{
			type = type.ToLower();
			bool flag = type == "trial";
			LicenseTypes licenseTypes;
			if (flag)
			{
				licenseTypes = LicenseTypes.Trial;
			}
			else
			{
				bool flag2 = type == "premium";
				if (flag2)
				{
					licenseTypes = LicenseTypes.Premium;
				}
				else
				{
					bool flag3 = type == "enterprise";
					if (flag3)
					{
						licenseTypes = LicenseTypes.Enterprise;
					}
					else
					{
						licenseTypes = LicenseTypes.Trial;
					}
				}
			}
			return licenseTypes;
		}

		// Token: 0x06000038 RID: 56 RVA: 0x00004368 File Offset: 0x00002568
		internal static StatusOptions GetStatusEnum(string status)
		{
			status = status.ToLower();
			bool flag = status == "active";
			StatusOptions statusOptions;
			if (flag)
			{
				statusOptions = StatusOptions.Active;
			}
			else
			{
				bool flag2 = status == "expired";
				if (flag2)
				{
					statusOptions = StatusOptions.Expired;
				}
				else
				{
					statusOptions = StatusOptions.Active;
				}
			}
			return statusOptions;
		}

		// Token: 0x06000039 RID: 57 RVA: 0x000043AC File Offset: 0x000025AC
		internal static ProductTypes GetProductEnum(string product)
		{
			product = product.ToLower();
			bool flag = product == "bunifu ui winforms" || product == "bunifu ui";
			ProductTypes productTypes;
			if (flag)
			{
				productTypes = ProductTypes.UIWinForms;
			}
			else
			{
				bool flag2 = product == "bunifu dataviz basic";
				if (flag2)
				{
					productTypes = ProductTypes.DatavizBasicWinForms;
				}
				else
				{
					bool flag3 = product == "bunifu dataviz advanced";
					if (flag3)
					{
						productTypes = ProductTypes.DatavizAdvancedWinForms;
					}
					else
					{
						bool flag4 = product == "bunifu charts";
						if (flag4)
						{
							productTypes = ProductTypes.Charts;
						}
						else
						{
							productTypes = ProductTypes.UIWinForms;
						}
					}
				}
			}
			return productTypes;
		}

		// Token: 0x0600003A RID: 58 RVA: 0x00004428 File Offset: 0x00002628
		internal static string CastProductEnum(ProductTypes product)
		{
			bool flag = product == ProductTypes.UIWinForms;
			string text;
			if (flag)
			{
				text = "Bunifu UI";
			}
			else
			{
				bool flag2 = product == ProductTypes.DatavizBasicWinForms;
				if (flag2)
				{
					text = "Bunifu Dataviz Basic";
				}
				else
				{
					bool flag3 = product == ProductTypes.DatavizAdvancedWinForms;
					if (flag3)
					{
						text = "Bunifu Dataviz Advanced";
					}
					else
					{
						bool flag4 = product == ProductTypes.Charts;
						if (flag4)
						{
							text = "Bunifu Charts";
						}
						else
						{
							text = "Bunifu UI";
						}
					}
				}
			}
			return text;
		}

		// Token: 0x0600003B RID: 59 RVA: 0x00004484 File Offset: 0x00002684
		private static LicenseUsageMode GetContext()
		{
			bool designMode = LicenseValidator.DesignMode2;
			LicenseUsageMode licenseUsageMode;
			if (designMode)
			{
				licenseUsageMode = LicenseUsageMode.Designtime;
			}
			else
			{
				licenseUsageMode = LicenseUsageMode.Runtime;
			}
			return licenseUsageMode;
		}

		// Token: 0x0600003C RID: 60 RVA: 0x000044AC File Offset: 0x000026AC
		private static License GetProductLicense(ProductTypes product, LicenseContext context, Type type)
		{
#if SKIP_LICENSE_CHECK
			// When SKIP_LICENSE_CHECK is defined, return a valid license without any checks
			var license = LicenseBypass.CreateFakeLicense(product);
			_retrievedLicense = license as Record;
			return license;
#else
			LicenseUsageMode context2 = LicenseValidator.GetContext();
			bool flag = context2 == LicenseUsageMode.Designtime;
			License license;
			if (flag)
			{
				LicenseValidator.Product = product;
				LicenseValidator.ReadLicense(false);
				bool flag2 = LicenseValidator.RetrievedLicense != null;
				if (flag2)
				{
					bool flag3 = LicenseValidator.IsDateBackdated();
					if (flag3)
					{
						LicenseValidator.ThrowSystemBackdatedException();
						license = null;
					}
					else
					{
						bool flag4 = LicenseValidator.RetrievedLicense.License.Status == StatusOptions.Expired;
						if (flag4)
						{
							bool flag5 = !LicenseValidator._freeTrialExpiredShown;
							if (flag5)
							{
								LicenseValidator._freeTrialExpiredShown = true;
								int totalDays = LicenseValidator.RetrievedLicense.License.TotalDays;
								string licenseKey = LicenseValidator.RetrievedLicense._licenseKey;
								LicenseValidator.DeleteLicense(false);
								bool flag6 = LicenseValidator.RetrievedLicense.License.Type == LicenseTypes.Trial;
								if (flag6)
								{
									DialogResult dialogResult = LicenseValidator._freeTrialEnded.ShowDialog(totalDays);
									bool flag7 = dialogResult == DialogResult.Cancel;
									if (flag7)
									{
										license = LicenseValidator.InvokeActivation(product, context, type, LicenseValidator.LicenseStatus.Expired, false, true);
									}
									else
									{
										LicenseValidator.ThrowLicenseExpiredException();
										license = null;
									}
								}
								else
								{
									bool flag8 = InformationBoxHelper.Show("It appears your license has expired.\n\nWould you like to renew now?", "License Expired", "", InformationBox.InformationBoxIcons.Alert, "Renew", "Cancel");
									try
									{
										bool flag9 = flag8;
										if (flag9)
										{
											Process.Start(LicenseValidator.GetRenewalLink(licenseKey));
										}
									}
									catch (Exception)
									{
									}
									license = LicenseValidator.InvokeActivation(product, context, type, LicenseValidator.LicenseStatus.Expired, false, true);
								}
							}
							else
							{
								LicenseValidator.ThrowLicenseExpiredException();
								license = null;
							}
						}
						else
						{
							bool flag10 = LicenseValidator.IsLicenseValid(LicenseValidator.RetrievedLicense);
							if (flag10)
							{
								DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(3, 4);
								defaultInterpolatedStringHandler.AppendFormatted<ProductTypes>(product);
								defaultInterpolatedStringHandler.AppendLiteral(",");
								defaultInterpolatedStringHandler.AppendFormatted<LicenseTypes>(LicenseValidator.RetrievedLicense.License.Type);
								defaultInterpolatedStringHandler.AppendLiteral(",");
								defaultInterpolatedStringHandler.AppendFormatted(LicenseValidator.RetrievedLicense.LicenseKey);
								defaultInterpolatedStringHandler.AppendLiteral(",");
								defaultInterpolatedStringHandler.AppendFormatted(type.Name);
								context.SetSavedLicenseKey(type, defaultInterpolatedStringHandler.ToStringAndClear());
								license = LicenseValidator.RetrievedLicense;
							}
							else
							{
								LicenseValidator.DeleteLicense(false);
								license = LicenseValidator.InvokeActivation(product, context, type, LicenseValidator.LicenseStatus.Invalid, false, true);
							}
						}
					}
				}
				else
				{
					bool flag11 = LicenseValidator.LicenseExists();
					if (flag11)
					{
						bool flag12 = LicenseValidator.IsDateBackdated();
						if (flag12)
						{
							LicenseValidator.ThrowSystemBackdatedException();
							license = null;
						}
						else
						{
							bool flag13 = LicenseValidator.IsLicenseValid(LicenseValidator.RetrievedLicense);
							if (flag13)
							{
								DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(3, 4);
								defaultInterpolatedStringHandler.AppendFormatted<ProductTypes>(product);
								defaultInterpolatedStringHandler.AppendLiteral(",");
								defaultInterpolatedStringHandler.AppendFormatted<LicenseTypes>(LicenseValidator.RetrievedLicense.License.Type);
								defaultInterpolatedStringHandler.AppendLiteral(",");
								defaultInterpolatedStringHandler.AppendFormatted(LicenseValidator.RetrievedLicense.LicenseKey);
								defaultInterpolatedStringHandler.AppendLiteral(",");
								defaultInterpolatedStringHandler.AppendFormatted(type.Name);
								context.SetSavedLicenseKey(type, defaultInterpolatedStringHandler.ToStringAndClear());
								license = LicenseValidator.RetrievedLicense;
							}
							else
							{
								LicenseValidator.DeleteLicense(false);
								license = LicenseValidator.InvokeActivation(product, context, type, LicenseValidator.LicenseStatus.Invalid, false, true);
							}
						}
					}
					else
					{
						bool flag14 = context2 == LicenseUsageMode.Designtime;
						if (flag14)
						{
							LicenseValidator.DeleteLicense(false);
							license = LicenseValidator.InvokeActivation(product, context, type, LicenseValidator.LicenseStatus.NonExistent, false, true);
						}
						else
						{
							LicenseValidator.ThrowLicenseNonExistentException();
							license = null;
						}
					}
				}
			}
			else
			{
				license = null;
			}
			return license;
#endif
		}

		// Token: 0x0600003D RID: 61 RVA: 0x00004648 File Offset: 0x00002848
		private static bool DevelopmentMode()
		{
			bool flag;
			try
			{
				flag = LicenseValidator.DesignMode2;
			}
			catch (Exception)
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x04000007 RID: 7
		private static Record _retrievedLicense;

		// Token: 0x04000008 RID: 8
		private static string _url = Resources.BUL;

		// Token: 0x04000009 RID: 9
		private static LicenseActivator _activator = new LicenseActivator();

#if NET5_0_OR_GREATER || NET6_0_OR_GREATER
		private static HttpClient _apiClient = new HttpClient();
#else
		private static HttpClient _apiClient = new HttpClient();
		// HttpClient compatible implementation for .NET Framework
		private static WebClient _webClient = new WebClient();
#endif

		// Token: 0x0400000A RID: 10
		internal static bool _f1ad718eb = true;

		// Token: 0x0400000B RID: 11
		private static bool _trialBoxShown = false;

		// Token: 0x0400000C RID: 12
		private static bool _freeTrialExpiredShown = false;

		// Token: 0x0400000D RID: 13
		private static FreeTrialEnded _freeTrialEnded = new FreeTrialEnded();

		// Token: 0x0400000E RID: 14
		internal static TrialBox _trialBox = new TrialBox();

		// Token: 0x02000040 RID: 64
		private enum LicenseStatus
		{
			// Token: 0x0400019F RID: 415
			NonExistent,
			// Token: 0x040001A0 RID: 416
			Expired,
			// Token: 0x040001A1 RID: 417
			Invalid
		}
	}
}

		// Token: 0x0600003D RID: 61 RVA: 0x00004648 File Offset: 0x00002848