using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Generic;
using Gestor.Application.ViewModels;
using Gestor.Infrastructure.Repository.Interface;
using Gestor.Infrastructure.UnitOfWork.Generic;
using Gestor.Infrastructure.UnitOfWork.Logic;
using Gestor.Model.Common;
using Gestor.Model.Domain.Common;
using Gestor.Model.Domain.Configuracoes;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Seguros;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

namespace Gestor.Application.Servicos.Seguros
{
	internal class CriticaApoliceServico : BaseServico
	{
		private bool _carregando;

		public CriticaApoliceServico()
		{
		}

		internal async Task<Cliente> BuscarCliente(long id)
		{
			int num = 3;
			Cliente cliente1 = await Task.Run<Cliente>(() => {
				Cliente cliente;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							cliente = read.get_ClienteRepository().FindById(id);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 27, num, id, true);
						continue;
					}
					return cliente;
				}
				return new Cliente();
			});
			return cliente1;
		}

		public async Task<List<CriticaApolice>> BuscarCritica(long usuario, DateTime inicio, DateTime fim, long id = 0L, bool criticado = false, List<VendedorUsuario> vinculos = null)
		{
			List<CriticaApolice> criticaApolices1;
			if (!this._carregando)
			{
				int num3 = 3;
				criticaApolices1 = await Task.Run<List<CriticaApolice>>(() => {
					List<CriticaApolice> criticaApolices;
					long num;
					while (num3 > 0)
					{
						try
						{
							this._carregando = true;
							using (UnitOfWork read = Instancia.Read)
							{
								id = read.get_VendedorRepository().FindCorretora().get_Id();
								ICriticaApoliceRepository criticaApoliceRepository = read.get_CriticaApoliceRepository();
								long num1 = usuario;
								DateTime dateTime = inicio;
								DateTime dateTime1 = fim;
								long num2 = id;
								bool flag = criticado;
								num = (Recursos.Usuario.get_IdEmpresa() == (long)1 ? (long)0 : Recursos.Usuario.get_IdEmpresa());
								List<VendedorUsuario> vendedorUsuarios = vinculos;
								List<ConfiguracaoSistema> configuracoes = Recursos.Configuracoes;
								Func<ConfiguracaoSistema, bool> u003cu003e9_21 = CriticaApoliceServico.u003cu003ec.u003cu003e9__2_1;
								if (u003cu003e9_21 == null)
								{
									u003cu003e9_21 = (ConfiguracaoSistema x) => x.get_Configuracao() == 43;
									CriticaApoliceServico.u003cu003ec.u003cu003e9__2_1 = u003cu003e9_21;
								}
								bool flag1 = configuracoes.Any<ConfiguracaoSistema>(u003cu003e9_21);
								List<ConfiguracaoSistema> configuracaoSistemas = Recursos.Configuracoes;
								Func<ConfiguracaoSistema, bool> u003cu003e9_22 = CriticaApoliceServico.u003cu003ec.u003cu003e9__2_2;
								if (u003cu003e9_22 == null)
								{
									u003cu003e9_22 = (ConfiguracaoSistema x) => x.get_Configuracao() == 38;
									CriticaApoliceServico.u003cu003ec.u003cu003e9__2_2 = u003cu003e9_22;
								}
								this._carregando = false;
								criticaApolices = criticaApoliceRepository.Find(num1, dateTime, dateTime1, num2, flag, num, vendedorUsuarios, flag1, configuracaoSistemas.Any<ConfiguracaoSistema>(u003cu003e9_22));
							}
						}
						catch (Exception exception)
						{
							num3 = base.Registrar(exception, 43, num3, new { usuario = usuario, inicio = inicio, fim = fim, criticado = criticado }, true);
							continue;
						}
						return criticaApolices;
					}
					this._carregando = false;
					return new List<CriticaApolice>();
				});
			}
			else
			{
				criticaApolices1 = new List<CriticaApolice>();
			}
			return criticaApolices1;
		}

		public async Task<List<CriticaApolice>> BuscarCritica(DateTime inicio, DateTime fim)
		{
			int num = 3;
			List<CriticaApolice> criticaApolices1 = await Task.Run<List<CriticaApolice>>(() => {
				List<CriticaApolice> criticaApolices;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							criticaApolices = read.get_CriticaApoliceRepository().Find(inicio, fim, (Recursos.Usuario.get_IdEmpresa() == (long)1 ? (long)0 : Recursos.Usuario.get_IdEmpresa()));
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 43, num, new { inicio = inicio, fim = fim }, true);
						continue;
					}
					return criticaApolices;
				}
				return new List<CriticaApolice>();
			});
			return criticaApolices1;
		}

		public async Task<List<CriticaApolice>> BuscarCritica(long id)
		{
			int num = 3;
			List<CriticaApolice> criticaApolices1 = await Task.Run<List<CriticaApolice>>(() => {
				List<CriticaApolice> criticaApolices;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							criticaApolices = read.get_CriticaApoliceRepository().Find(id);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 44, num, id, true);
						continue;
					}
					return criticaApolices;
				}
				return new List<CriticaApolice>();
			});
			return criticaApolices1;
		}

		public async Task<List<CriticaApolice>> BuscarImportacao(long id)
		{
			int num = 3;
			List<CriticaApolice> criticaApolices1 = await Task.Run<List<CriticaApolice>>(() => {
				List<CriticaApolice> criticaApolices;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							criticaApolices = read.get_CriticaApoliceRepository().FindImport(id);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 45, num, id, true);
						continue;
					}
					return criticaApolices;
				}
				return new List<CriticaApolice>();
			});
			return criticaApolices1;
		}

		public async Task<List<CriticaApolice>> BuscarSeguroCombinado(long id, DateTime vigencia)
		{
			int num = 3;
			List<CriticaApolice> criticaApolices1 = await Task.Run<List<CriticaApolice>>(() => {
				List<CriticaApolice> criticaApolices;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							criticaApolices = read.get_CriticaApoliceRepository().FindDuo(id, vigencia);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 44, num, id, true);
						continue;
					}
					return criticaApolices;
				}
				return new List<CriticaApolice>();
			});
			return criticaApolices1;
		}

		public async Task<List<Usuario>> BuscarUsuarioCritica(DateTime inicio, DateTime fim, bool criticado = false)
		{
			int num = 3;
			List<Usuario> usuarios1 = await Task.Run<List<Usuario>>(() => {
				List<Usuario> list;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							List<Usuario> usuarios = read.get_CriticaApoliceRepository().BuscarUsuarioCritica(inicio, fim, criticado, (Recursos.Usuario.get_IdEmpresa() == (long)1 ? (long)0 : Recursos.Usuario.get_IdEmpresa()));
							Func<Usuario, string> u003cu003e9_41 = CriticaApoliceServico.u003cu003ec.u003cu003e9__4_1;
							if (u003cu003e9_41 == null)
							{
								u003cu003e9_41 = (Usuario x) => x.get_Nome();
								CriticaApoliceServico.u003cu003ec.u003cu003e9__4_1 = u003cu003e9_41;
							}
							list = usuarios.OrderBy<Usuario, string>(u003cu003e9_41).ToList<Usuario>();
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 43, num, new { inicio = inicio, fim = fim, criticado = criticado }, true);
						continue;
					}
					return list;
				}
				return new List<Usuario>();
			});
			return usuarios1;
		}

		public async Task<CriticaApolice> Save(CriticaApolice critica)
		{
			int num = 3;
			base.Sucesso = true;
			CriticaApolice criticaApolouse2 = critica;
			CriticaApolice criticaApolouse3 = await Task.Run<CriticaApolice>(() => {
				CriticaApolice criticaApolouse;
				string str;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork commited = Instancia.Commited)
						{
							TipoAcao tipoAcao = (criticaApolouse2.get_Id() == 0 ? 0 : 1);
							criticaApolouse2 = commited.get_CriticaApoliceRepository().Merge(criticaApolouse2);
							IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
							RegistroLog registroLog = new RegistroLog();
							registroLog.set_Acao(tipoAcao);
							registroLog.set_Usuario(Recursos.Usuario);
							registroLog.set_DataHora(Funcoes.GetNetworkTime());
							CriticaApolice criticaApolouse1 = criticaApolouse2;
							JsonSerializerSettings jsonSerializerSetting = new JsonSerializerSettings();
							jsonSerializerSetting.set_ReferenceLoopHandling(1);
							registroLog.set_Descricao(JsonConvert.SerializeObject(criticaApolouse1, jsonSerializerSetting));
							registroLog.set_EntidadeId(criticaApolouse2.get_Id());
							registroLog.set_Tela(20);
							registroLog.set_Versao(LoginViewModel.VersaoAtual);
							registroLog.set_NomeMaquina(Environment.MachineName);
							registroLog.set_UsuarioMaquina(Environment.UserName);
							IPAddress[] addressList = hostEntry.AddressList;
							Func<IPAddress, bool> u003cu003e9_81 = CriticaApoliceServico.u003cu003ec.u003cu003e9__8_1;
							if (u003cu003e9_81 == null)
							{
								u003cu003e9_81 = (IPAddress ip) => ip.AddressFamily == AddressFamily.InterNetwork;
								CriticaApoliceServico.u003cu003ec.u003cu003e9__8_1 = u003cu003e9_81;
							}
							IPAddress pAddress = ((IEnumerable<IPAddress>)addressList).FirstOrDefault<IPAddress>(u003cu003e9_81);
							if (pAddress != null)
							{
								str = pAddress.ToString();
							}
							else
							{
								str = null;
							}
							registroLog.set_Ip(str);
							base.SaveLog(registroLog, commited);
							commited.Commit();
							criticaApolouse = criticaApolouse2;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 173, num, critica, true);
						continue;
					}
					return criticaApolouse;
				}
				return critica;
			});
			return criticaApolouse3;
		}
	}
}