using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Generic;
using Gestor.Common.Security;
using Gestor.Common.Validation;
using Gestor.Infrastructure.Mappers;
using Gestor.Infrastructure.UnitOfWork.Generic;
using Gestor.Infrastructure.UnitOfWork.Logic;
using Gestor.Model.API;
using Gestor.Model.Common;
using Gestor.Model.Domain.Common;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Seguros;

namespace Gestor.Application.Servicos.Ferramentas;

internal class UsuarioServico : BaseServico
{
	internal async Task<Usuario> BuscarUsuarioPorId(long id)
	{
		int tries = 3;
		return await Task.Run((Func<Usuario>)delegate
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.UsuarioRepository.FindById(id);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)130, tries, id);
				}
			}
			return new Usuario();
		});
	}

	public async Task<Usuario> Save(Usuario usuario)
	{
		int tries = 3;
		base.Sucesso = true;
		Usuario usuarioOriginal = usuario;
		return await Task.Run((Func<Usuario>)delegate
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			List<RegistroLog> list = new List<RegistroLog>();
			while (tries > 0)
			{
				usuario = usuarioOriginal;
				try
				{
					UnitOfWork commited = Instancia.Commited;
					try
					{
						Usuario usuario2 = Recursos.Usuario;
						string text = ((usuario2 != null) ? usuario2.TokenSso : null);
						Empresa empresa = Recursos.Empresa;
						string documentoEmpresa = ((empresa != null) ? empresa.Documento : null);
						if (ValidationHelper.IsNullOrEmpty(text))
						{
							Empresa val = commited.EmpresaRepository.FindBySerial(ApplicationHelper.NumeroSerial);
							string password = usuario.Senha;
							if (ValidationHelper.IsNotNullOrEmpty(usuario.SenhaAnterior))
							{
								if (new Token().AggerDecrypt(usuario.SenhaAnterior).ToUpper().Contains("AGGER@"))
								{
									Usuario result = BuscarLogin(usuario.Login).Result;
									usuario.SenhaAnterior = result.Senha;
								}
								password = usuario.SenhaAnterior;
							}
							AuthSso result2 = BuscaUsuarioSso(usuario.Login, password, val.Documento).Result;
							if (result2 == null || result2.Code == 401)
							{
								base.Sucesso = false;
								return usuarioOriginal;
							}
							text = result2.Data.Token;
							documentoEmpresa = val.Documento;
						}
						Usuario obj = usuario;
						long? permissaoAggilizador2;
						if (usuario.PermissaoAggilizador.HasValue)
						{
							long? num = (usuario.PermissaoAggilizador = usuario.PermissaoAggilizador);
							permissaoAggilizador2 = num;
						}
						else
						{
							long? num = (usuario.PermissaoAggilizador = 2L);
							permissaoAggilizador2 = num;
						}
						obj.PermissaoAggilizador = permissaoAggilizador2;
						bool num3 = ((DomainBase)usuario).Id != 0L;
						if (num3)
						{
							list.Add(CreateLog(((DomainBase)usuario).Id, usuario, (TipoTela)16));
						}
						usuario = ((((DomainBase)usuario).Id == 0L) ? commited.UsuarioRepository.SaveOrUpdate(usuario) : commited.UsuarioRepository.Merge(usuario));
						if (!num3)
						{
							list.Add(CreateLog(((DomainBase)usuario).Id, ((DomainBase)usuario).GetValorOriginal(), (TipoTela)16, (TipoAcao)0));
						}
						SaveLog(list, commited);
						((GenericUnitOfWork)commited).Commit();
						usuario.TokenSso = text;
						AddOrUpdateUsuarioSso(usuario, documentoEmpresa, usuario.SsoId).Wait();
						return usuario;
					}
					finally
					{
						((IDisposable)commited)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)239, tries, usuario);
				}
			}
			return usuarioOriginal;
		});
	}

	public async Task<bool> Delete(Usuario usuario)
	{
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				List<RegistroLog> list = new List<RegistroLog>();
				try
				{
					UnitOfWork commited = Instancia.Commited;
					try
					{
						list.Add(CreateLog(((DomainBase)usuario).Id, ((DomainBase)usuario).GetValorOriginal(), (TipoTela)16, (TipoAcao)2));
						commited.UsuarioRepository.Delete(((DomainBase)usuario).Id);
						SaveLog(list, commited);
						((GenericUnitOfWork)commited).Commit();
						usuario.TokenSso = Recursos.Usuario.TokenSso;
						DeleteUsuarioSso(usuario, Recursos.Empresa.Documento).Wait();
						return true;
					}
					finally
					{
						((IDisposable)commited)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)240, tries, usuario);
				}
			}
			return false;
		});
	}

	public async Task<List<PermissaoAggilizador>> BuscarPermissaoAggilizador()
	{
		return await Task.Run(delegate
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			try
			{
				UnitOfWork read = Instancia.Read;
				try
				{
					return read.UsuarioRepository.PermissaoAggilizador();
				}
				finally
				{
					((IDisposable)read)?.Dispose();
				}
			}
			catch (Exception)
			{
				return new List<PermissaoAggilizador>
				{
					new PermissaoAggilizador
					{
						Id = 1L,
						Descricao = "ADMINISTRADOR"
					},
					new PermissaoAggilizador
					{
						Id = 2L,
						Descricao = "NORMAL"
					},
					new PermissaoAggilizador
					{
						Id = 3L,
						Descricao = "LIMITADO"
					}
				};
			}
		});
	}

	public async Task<Usuario> BuscarLogin(string login)
	{
		int tries = 3;
		return await Task.Run((Func<Usuario>)delegate
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						Empresa val = read.EmpresaRepository.FindBySerial(ApplicationHelper.NumeroSerial);
						AuthSso result = VerificaUsuarioSso(login, val.Documento).Result;
						if (result == null || result.Code == 401)
						{
							return new Usuario();
						}
						Usuario val2 = read.UsuarioRepository.FindUsuario(login);
						return (result.Code == 404) ? val2 : CustomMap.FromUserSso(val2, result.Data.User);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)134, tries, login);
				}
			}
			return new Usuario();
		});
	}

	public async Task AddCentralSegurado(long id, bool update = true)
	{
		await Task.Run(delegate
		{
			UnitOfWork commited = Instancia.Commited;
			try
			{
				commited.ClienteRepository.AddCentralSegurado(id, update);
			}
			finally
			{
				((IDisposable)commited)?.Dispose();
			}
		});
	}

	public async Task<Usuario> BuscaUsuarioInicial(string usuario, string senha)
	{
		return await Task.Run((Func<Usuario>)delegate
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			UnitOfWork read = Instancia.Read;
			try
			{
				Empresa val = read.EmpresaRepository.FindBySerial(ApplicationHelper.NumeroSerial);
				string password = new Token().AggerEncrypt(senha);
				AuthSso result = BuscaUsuarioSso(usuario, password, val.Documento).Result;
				if (result.Code == 401)
				{
					return (Usuario)null;
				}
				Usuario val2 = read.UsuarioRepository.FindUsuario(usuario);
				if (result.Code == 404 && val2 == null)
				{
					return new Usuario();
				}
				if (result.Data == null && val2 != null)
				{
					return val2;
				}
				if (val2 == null && result.Data != null)
				{
					return CustomMap.ToUsuario(result.Data.User, ((DomainBase)val).Id);
				}
				return val2;
			}
			finally
			{
				((IDisposable)read)?.Dispose();
			}
		});
	}
}