using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Data.SqlClient;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Agger.Registro;
using Gestor.Application.Migration;
using Gestor.Common.Exceptions;

namespace Gestor.Application.Helpers;

public class ConnectionHelper
{
	public static bool BancoAtualizado { get; set; }

	private static async Task<string> Get(string command, bool autorizar = true)
	{
		Uri uri = new Uri(Address.GestorApi(), command);
		HttpClient val = new HttpClient
		{
			Timeout = new TimeSpan(0, 2, 0)
		};
		if (autorizar)
		{
			val.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", Connection.BasicKey());
		}
		ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
		try
		{
			HttpResponseMessage val2 = await val.GetAsync(uri).ConfigureAwait(continueOnCapturedContext: false);
			if (val2.StatusCode != HttpStatusCode.OK)
			{
				return await val2.Content.ReadAsStringAsync();
			}
			return null;
		}
		catch (Exception)
		{
			return "ERRO INTERNO";
		}
	}

	private static async Task<string> Post(string command)
	{
		Uri uri = new Uri(Address.GestorApi(), command);
		HttpClient val = new HttpClient();
		val.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", Connection.BasicKey());
		ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
		try
		{
			HttpResponseMessage val2 = await val.PostAsync(uri, (HttpContent)null);
			if (val2.StatusCode != HttpStatusCode.OK)
			{
				return await val2.Content.ReadAsStringAsync();
			}
			return null;
		}
		catch (Exception)
		{
			return "ERRO INTERNO";
		}
	}

	private static async Task<string> DatabaseTest()
	{
		return await Get("Data/Verify");
	}

	public async Task<string> AtualizarBanco()
	{
		bool num = await new Migrator().Execute();
		BancoAtualizado = num;
		return num ? null : "HOUVE UM PROBLEMA AO ATUALIZAR O BANCO DE DADOS.";
	}

	internal static async Task<bool> TryConnect(string connectionString, int retryCount = 1)
	{
		return await Task.Run(delegate
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			List<Exception> list = new List<Exception>();
			for (int i = 0; i < retryCount; i++)
			{
				try
				{
					SqlConnection val = new SqlConnection(connectionString + "Connection Timeout=5");
					try
					{
						((DbConnection)(object)val).Open();
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
					return true;
				}
				catch (Exception item)
				{
					list.Add(item);
				}
			}
			return list.Count == 0;
		});
	}

	internal static async Task<bool> HasLogin(string connectionString)
	{
		return await Task.Run(delegate
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			List<Exception> list = new List<Exception>();
			try
			{
				SqlConnection val = new SqlConnection(connectionString);
				try
				{
					((DbConnection)(object)val).Open();
					SqlCommand val2 = val.CreateCommand();
					try
					{
						((DbCommand)(object)val2).CommandText = "SELECT 1 FROM [dbo].[usuario] WHERE [removido] IS NULL OR [removido] = '0'";
						SqlDataReader val3 = val2.ExecuteReader();
						if (!((DbDataReader)(object)val3).HasRows)
						{
							return false;
						}
						((DbDataReader)(object)val3).Close();
						((DbCommand)(object)val2).CommandText = "SELECT 1 FROM [dbo].[empresa] WHERE [idempresa] = 1";
						val3 = val2.ExecuteReader();
						if (!((DbDataReader)(object)val3).HasRows)
						{
							return false;
						}
						((DbDataReader)(object)val3).Close();
						((DbCommand)(object)val2).CommandText = "SELECT 1 FROM [dbo].[vendedor] WHERE [corretora] = '1'";
						val3 = val2.ExecuteReader();
						if (!((DbDataReader)(object)val3).HasRows)
						{
							return false;
						}
						((DbDataReader)(object)val3).Close();
						return true;
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception item)
			{
				list.Add(item);
			}
			return list.Count == 0;
		});
	}

	public async Task<Tuple<bool, bool>> PrimeiroAcesso()
	{
		string conn = Connection.GetConnection(tryconnect: false);
		if (!(await TryConnect(conn)))
		{
			if (!(await DatabaseExists()))
			{
				return new Tuple<bool, bool>(item1: false, item2: false);
			}
			bool flag = !(await LoginExists());
			if (flag)
			{
				flag = !(await CreateLogin());
			}
			if (flag)
			{
				return new Tuple<bool, bool>(item1: false, item2: false);
			}
			flag = !(await UserExists());
			if (flag)
			{
				flag = !(await CreateUser());
			}
			if (flag)
			{
				return new Tuple<bool, bool>(item1: false, item2: false);
			}
		}
		return (!(await HasLogin(conn))) ? new Tuple<bool, bool>(item1: true, item2: false) : new Tuple<bool, bool>(item1: true, item2: true);
	}

	public bool BDConvertido()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		try
		{
			SqlConnection val = new SqlConnection(Connection.GetConnection(tryconnect: false));
			try
			{
				((DbConnection)(object)val).Open();
				SqlCommand val2 = val.CreateCommand();
				try
				{
					((DbCommand)(object)val2).CommandText = "SELECT OBJECT_ID('dbo.AtualizacaoDados', 'U')";
					if (((DbCommand)(object)val2).ExecuteScalar() == DBNull.Value)
					{
						return true;
					}
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
				SqlCommand val3 = val.CreateCommand();
				try
				{
					((DbCommand)(object)val3).CommandText = "SELECT COUNT(IdArquivo) FROM AtualizacaoDados";
					return (int)((DbCommand)(object)val3).ExecuteScalar() == 0;
				}
				finally
				{
					((IDisposable)val3)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch
		{
		}
		return true;
	}

	public bool ExisteEmpresa()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		try
		{
			SqlConnection val = new SqlConnection(Connection.GetConnection(tryconnect: false));
			try
			{
				((DbConnection)(object)val).Open();
				SqlCommand val2 = val.CreateCommand();
				try
				{
					((DbCommand)(object)val2).CommandText = "SELECT OBJECT_ID (N'empresa', N'U')";
					if (((DbCommand)(object)val2).ExecuteScalar() == DBNull.Value)
					{
						return false;
					}
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
				SqlCommand val3 = val.CreateCommand();
				try
				{
					((DbCommand)(object)val3).CommandText = "SELECT COUNT(idempresa) FROM empresa WHERE idempresa = 1";
					return (int)((DbCommand)(object)val3).ExecuteScalar() > 0;
				}
				finally
				{
					((IDisposable)val3)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch
		{
		}
		return true;
	}

	public async Task<string> VerifyConnection()
	{
		_ = 3;
		try
		{
			if (await TryConnect(Connection.GetConnection(tryconnect: false)))
			{
				return null;
			}
			string text = await DatabaseTest();
			if (text != null)
			{
				return text;
			}
			string text2 = Connection.ConnectionAddress.Catalog + ".cfg";
			string path = AppDomain.CurrentDomain.BaseDirectory + "Data_" + text2;
			string path2 = AppDomain.CurrentDomain.BaseDirectory + "Files_" + text2;
			string path3 = AppDomain.CurrentDomain.BaseDirectory + "Sign_" + text2;
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			if (File.Exists(path2))
			{
				File.Delete(path2);
			}
			if (File.Exists(path3))
			{
				File.Delete(path3);
			}
			string returnMessage = await CheckDatabase();
			await Task.Delay(2000);
			return returnMessage;
		}
		catch (Exception)
		{
			return "ERRO AO CONECTAR NO BANCO DE DADOS DA CORRETORA";
		}
	}

	public static async Task<string> CheckDatabase()
	{
		_ = 5;
		try
		{
			bool hasDatabase = await DatabaseExists();
			bool hasLogin = await LoginExists();
			bool hasUser = await UserExists();
			bool created = false;
			if (hasDatabase && hasLogin && hasUser)
			{
				return null;
			}
			if (!hasDatabase)
			{
				hasDatabase = await CreateDatabase();
			}
			if (!hasDatabase)
			{
				return "ERRO AO CRIAR BANCO DE DADOS";
			}
			if (!hasLogin)
			{
				bool num = await CreateLogin();
				bool flag = num;
				created = num;
				hasLogin = flag;
			}
			if (!hasLogin)
			{
				return "ERRO AO CRIAR LOGIN";
			}
			if (!hasUser)
			{
				hasUser = await CreateUser();
			}
			if (created)
			{
				int num2 = 10;
				while (num2 > 1)
				{
					try
					{
						SqlConnection val = new SqlConnection(Connection.GetConnection());
						try
						{
							((DbConnection)(object)val).Open();
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					catch
					{
						Thread.Sleep(10000);
						num2--;
						continue;
					}
					break;
				}
			}
			return (!hasUser) ? "ERRO AO CRIAR USUÁRIO" : null;
		}
		catch (ValidationException val2)
		{
			return ((Exception)val2).Message;
		}
		catch (Exception)
		{
			return "ERRO AO CRIAR BANCO DE DADOS";
		}
	}

	private static async Task<bool> CreateDatabase()
	{
		string text = Uri.EscapeDataString(ApplicationHelper.NumeroSerial);
		if (await Post("Data/CreateData?token=" + text) == "ERRO INTERNO")
		{
			return false;
		}
		int tries = 0;
		bool flag = false;
		while (tries < 24 && !flag)
		{
			await Task.Delay(5000);
			tries++;
			flag = await DatabaseExists();
		}
		return flag;
	}

	private static async Task<bool> CreateLogin()
	{
		if (await Post("Data/CreateLogin") == "ERRO INTERNO")
		{
			return false;
		}
		int tries = 0;
		bool flag = false;
		while (tries < 24 && !flag)
		{
			await Task.Delay(5000);
			tries++;
			flag = await Get("Data/ServerLoginExists") == null;
		}
		return flag;
	}

	private static async Task<bool> CreateUser()
	{
		if (await Post("Data/CreateUser") == "ERRO INTERNO")
		{
			return false;
		}
		int tries = 0;
		bool flag = false;
		while (tries < 24 && !flag)
		{
			await Task.Delay(5000);
			tries++;
			flag = await Get("Data/UserExists") == null;
		}
		return flag;
	}

	private static async Task<bool> DatabaseExists()
	{
		return await Get("Data/DataExists") == null;
	}

	private static async Task<bool> LoginExists()
	{
		return await Get("Data/ServerLoginExists") == null;
	}

	private static async Task<bool> UserExists()
	{
		return await Get("Data/UserExists") == null;
	}
}