using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Generic;
using Gestor.Common.Security;
using Gestor.Common.Validation;
using Gestor.Infrastructure.Mappers;
using Gestor.Infrastructure.Repository.Interface;
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;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

namespace Gestor.Application.Servicos.Ferramentas
{
	internal class UsuarioServico : BaseServico
	{
		public UsuarioServico()
		{
		}

		public async Task AddCentralSegurado(long id, bool update = true)
		{
			await Task.Run(() => {
				using (UnitOfWork commited = Instancia.Commited)
				{
					commited.get_ClienteRepository().AddCentralSegurado(id, update);
				}
			});
		}

		public async Task<Usuario> BuscarLogin(string login)
		{
			int num = 3;
			Usuario usuario2 = await Task.Run<Usuario>(() => {
				Usuario usuario;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							Empresa empresa = read.get_EmpresaRepository().FindBySerial(ApplicationHelper.NumeroSerial);
							AuthSso result = base.VerificaUsuarioSso(login, empresa.get_Documento()).Result;
							if (result == null || result.get_Code() == 401)
							{
								usuario = new Usuario();
							}
							else
							{
								Usuario usuario1 = read.get_UsuarioRepository().FindUsuario(login);
								usuario = (result.get_Code() == 404 ? usuario1 : CustomMap.FromUserSso(usuario1, result.get_Data().get_User()));
							}
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 134, num, login, true);
						continue;
					}
					return usuario;
				}
				return new Usuario();
			});
			return usuario2;
		}

		public async Task<List<PermissaoAggilizador>> BuscarPermissaoAggilizador()
		{
			List<PermissaoAggilizador> permissaoAggilizadors2 = await Task.Run<List<PermissaoAggilizador>>(() => {
				List<PermissaoAggilizador> permissaoAggilizadors;
				try
				{
					using (UnitOfWork read = Instancia.Read)
					{
						permissaoAggilizadors = read.get_UsuarioRepository().PermissaoAggilizador();
					}
				}
				catch (Exception exception)
				{
					List<PermissaoAggilizador> permissaoAggilizadors1 = new List<PermissaoAggilizador>();
					PermissaoAggilizador permissaoAggilizador = new PermissaoAggilizador();
					permissaoAggilizador.set_Id((long)1);
					permissaoAggilizador.set_Descricao("ADMINISTRADOR");
					permissaoAggilizadors1.Add(permissaoAggilizador);
					PermissaoAggilizador permissaoAggilizador1 = new PermissaoAggilizador();
					permissaoAggilizador1.set_Id((long)2);
					permissaoAggilizador1.set_Descricao("NORMAL");
					permissaoAggilizadors1.Add(permissaoAggilizador1);
					PermissaoAggilizador permissaoAggilizador2 = new PermissaoAggilizador();
					permissaoAggilizador2.set_Id((long)3);
					permissaoAggilizador2.set_Descricao("LIMITADO");
					permissaoAggilizadors1.Add(permissaoAggilizador2);
					permissaoAggilizadors = permissaoAggilizadors1;
				}
				return permissaoAggilizadors;
			});
			return permissaoAggilizadors2;
		}

		internal async Task<Usuario> BuscarUsuarioPorId(long id)
		{
			int num = 3;
			Usuario usuario1 = await Task.Run<Usuario>(() => {
				Usuario usuario;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							usuario = read.get_UsuarioRepository().FindById(id);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 130, num, id, true);
						continue;
					}
					return usuario;
				}
				return new Usuario();
			});
			return usuario1;
		}

		public async Task<Usuario> BuscaUsuarioInicial(string usuario, string senha)
		{
			Usuario usuario2 = await Task.Run<Usuario>(() => {
				Usuario usuario3;
				using (UnitOfWork read = Instancia.Read)
				{
					Empresa empresa = read.get_EmpresaRepository().FindBySerial(ApplicationHelper.NumeroSerial);
					string str = (new Token()).AggerEncrypt(senha);
					AuthSso result = base.BuscaUsuarioSso(usuario, str, empresa.get_Documento()).Result;
					if (result.get_Code() != 401)
					{
						Usuario usuario1 = read.get_UsuarioRepository().FindUsuario(usuario);
						usuario3 = (result.get_Code() != 404 || usuario1 != null ? (result.get_Data() != null || usuario1 == null ? (usuario1 != null || result.get_Data() == null ? usuario1 : CustomMap.ToUsuario(result.get_Data().get_User(), empresa.get_Id())) : usuario1) : new Usuario());
					}
					else
					{
						usuario3 = null;
					}
				}
				return usuario3;
			});
			return usuario2;
		}

		public async Task<bool> Delete(Usuario usuario)
		{
			int num = 3;
			bool flag1 = await Task.Run<bool>(() => {
				bool flag;
				while (num > 0)
				{
					List<RegistroLog> registroLogs = new List<RegistroLog>();
					try
					{
						using (UnitOfWork commited = Instancia.Commited)
						{
							registroLogs.Add(base.CreateLog(usuario.get_Id(), usuario.GetValorOriginal(), 16, 2));
							commited.get_UsuarioRepository().Delete(usuario.get_Id());
							base.SaveLog(registroLogs, commited);
							commited.Commit();
							usuario.set_TokenSso(Recursos.Usuario.get_TokenSso());
							base.DeleteUsuarioSso(usuario, Recursos.Empresa.get_Documento()).Wait();
							flag = true;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 240, num, usuario, true);
						continue;
					}
					return flag;
				}
				return false;
			});
			return flag1;
		}

		public async Task<Usuario> Save(Usuario usuario)
		{
			int num = 3;
			base.Sucesso = true;
			Usuario usuario5 = usuario;
			Usuario usuario6 = await Task.Run<Usuario>(() => {
				Usuario usuario7;
				long? nullable;
				string tokenSso;
				string documento;
				long? nullable1;
				bool flag;
				List<RegistroLog> registroLogs = new List<RegistroLog>();
				while (num > 0)
				{
					usuario = usuario5;
					try
					{
						using (UnitOfWork commited = Instancia.Commited)
						{
							Usuario usuario1 = Recursos.Usuario;
							if (usuario1 != null)
							{
								tokenSso = usuario1.get_TokenSso();
							}
							else
							{
								tokenSso = null;
							}
							string token = tokenSso;
							Empresa empresa = Recursos.Empresa;
							if (empresa != null)
							{
								documento = empresa.get_Documento();
							}
							else
							{
								documento = null;
							}
							string str = documento;
							if (ValidationHelper.IsNullOrEmpty(token))
							{
								Empresa empresa1 = commited.get_EmpresaRepository().FindBySerial(ApplicationHelper.NumeroSerial);
								string senha = usuario.get_Senha();
								if (ValidationHelper.IsNotNullOrEmpty(usuario.get_SenhaAnterior()))
								{
									if ((new Token()).AggerDecrypt(usuario.get_SenhaAnterior()).ToUpper().Contains("AGGER@"))
									{
										Usuario result = this.BuscarLogin(usuario.get_Login()).Result;
										usuario.set_SenhaAnterior(result.get_Senha());
									}
									senha = usuario.get_SenhaAnterior();
								}
								AuthSso authSso = base.BuscaUsuarioSso(usuario.get_Login(), senha, empresa1.get_Documento()).Result;
								if (authSso == null || authSso.get_Code() == 401)
								{
									this.Sucesso = false;
									usuario7 = usuario5;
									return usuario7;
								}
								else
								{
									token = authSso.get_Data().get_Token();
									str = empresa1.get_Documento();
								}
							}
							Usuario usuario2 = usuario;
							if (!usuario.get_PermissaoAggilizador().HasValue)
							{
								Usuario usuario3 = usuario;
								long? nullable2 = new long?((long)2);
								nullable = nullable2;
								usuario3.set_PermissaoAggilizador(nullable2);
								nullable1 = nullable;
							}
							else
							{
								Usuario usuario4 = usuario;
								long? permissaoAggilizador = usuario.get_PermissaoAggilizador();
								nullable = permissaoAggilizador;
								usuario4.set_PermissaoAggilizador(permissaoAggilizador);
								nullable1 = nullable;
							}
							usuario2.set_PermissaoAggilizador(nullable1);
							flag = (usuario.get_Id() == 0 ? false : true);
							if (flag)
							{
								registroLogs.Add(base.CreateLog(usuario.get_Id(), usuario, 16));
							}
							usuario = (usuario.get_Id() == 0 ? commited.get_UsuarioRepository().SaveOrUpdate(usuario) : commited.get_UsuarioRepository().Merge(usuario));
							if (!flag)
							{
								registroLogs.Add(base.CreateLog(usuario.get_Id(), usuario.GetValorOriginal(), 16, 0));
							}
							base.SaveLog(registroLogs, commited);
							commited.Commit();
							usuario.set_TokenSso(token);
							base.AddOrUpdateUsuarioSso(usuario, str, usuario.get_SsoId()).Wait();
							usuario7 = usuario;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 239, num, usuario, true);
						continue;
					}
					return usuario7;
				}
				return usuario5;
			});
			return usuario6;
		}
	}
}