using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Generic;
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.Generic;
using Gestor.Model.Domain.Seguros;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

namespace Gestor.Application.Servicos
{
	public class RestricaoUsuarioServico : BaseServico
	{
		public RestricaoUsuarioServico()
		{
		}

		public RestricaoUsuario BuscarRestricao(Usuario usuario, TipoRestricao restricao)
		{
			RestricaoUsuario restricaoUsuario;
			int num = 3;
			while (num > 0)
			{
				try
				{
					using (UnitOfWork read = Instancia.Read)
					{
						restricaoUsuario = read.get_RestricaoUsuarioRepository().FindRestricao(usuario.get_Id(), restricao);
					}
				}
				catch (Exception exception1)
				{
					Exception exception = exception1;
					num = base.Registrar(exception, 89, num, new { usuario = usuario, restricao = restricao }, true);
					continue;
				}
				return restricaoUsuario;
			}
			return null;
		}

		public async Task<List<RestricaoUsuario>> BuscarRestricoes(long id)
		{
			int num = 3;
			List<RestricaoUsuario> restricaoUsuarios1 = await Task.Run<List<RestricaoUsuario>>(() => {
				List<RestricaoUsuario> restricaoUsuarios;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							restricaoUsuarios = read.get_RestricaoUsuarioRepository().FindByUsuario(id);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 90, num, id, true);
						continue;
					}
					return restricaoUsuarios;
				}
				return new List<RestricaoUsuario>();
			});
			return restricaoUsuarios1;
		}

		public async Task<List<RestricaoUsuarioCamposRelatorios>> BuscarRestricoesCamposRelatorios(long id)
		{
			int num = 3;
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios1 = await Task.Run<List<RestricaoUsuarioCamposRelatorios>>(() => {
				List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios;
				while (num > 0)
				{
					try
					{
						using (UnitOfWork read = Instancia.Read)
						{
							restricaoUsuarioCamposRelatorios = read.get_RestricaoUsuarioCamposRelatoriosRepository().FindByUsuario(id);
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 90, num, id, true);
						continue;
					}
					return restricaoUsuarioCamposRelatorios;
				}
				return new List<RestricaoUsuarioCamposRelatorios>();
			});
			return restricaoUsuarioCamposRelatorios1;
		}

		public async Task<List<RestricaoUsuario>> SaveRestri(List<RestricaoUsuario> restricoes, List<RestricaoUsuario> prev)
		{
			int num = 3;
			base.Sucesso = true;
			List<RestricaoUsuario> restricaoUsuarios1 = restricoes;
			List<RestricaoUsuario> restricaoUsuarios2 = prev;
			List<RestricaoUsuario> restricaoUsuarios3 = await Task.Run<List<RestricaoUsuario>>(() => {
				List<RestricaoUsuario> restricaoUsuarios;
				while (num > 0)
				{
					List<Diferenca> diferencas = new List<Diferenca>();
					List<RegistroLog> registroLogs = new List<RegistroLog>();
					restricoes = restricaoUsuarios1;
					prev = restricaoUsuarios2;
					try
					{
						using (UnitOfWork commited = Instancia.Commited)
						{
							restricoes.ForEach((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = x;
								RestricaoUsuario restricaoUsuario1 = prev.FirstOrDefault<RestricaoUsuario>((RestricaoUsuario y) => {
									if (restricaoUsuario.get_Id() != 0)
									{
										return y.get_Id() == restricaoUsuario.get_Id();
									}
									return y.get_Tipo() == restricaoUsuario.get_Tipo();
								});
								if (restricaoUsuario1 != null && restricaoUsuario1.get_Restricao() == restricaoUsuario.get_Restricao())
								{
									return;
								}
								if (restricaoUsuario1 != null)
								{
									registroLogs.Add(base.CreateLog(restricaoUsuario.get_Usuario().get_Id(), restricaoUsuario.Compare(restricaoUsuario1.GetValorOriginal()), 43, 1));
								}
								else
								{
									registroLogs.Add(base.CreateLog(restricaoUsuario.get_Usuario().get_Id(), restricaoUsuario.GetValorOriginal(), 43, 0));
								}
								restricaoUsuario = (restricaoUsuario.get_Id() == 0 ? commited.get_RestricaoUsuarioRepository().SaveOrUpdate(restricaoUsuario) : commited.get_RestricaoUsuarioRepository().Merge(restricaoUsuario));
							});
							base.SaveLog(registroLogs, commited);
							commited.Commit();
							restricaoUsuarios = restricoes;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 261, num, new { restricoes = restricoes, prev = prev }, true);
						continue;
					}
					return restricaoUsuarios;
				}
				return restricaoUsuarios1;
			});
			return restricaoUsuarios3;
		}

		public async Task<List<RestricaoUsuarioCamposRelatorios>> SaveRestriCamposRelatorios(List<RestricaoUsuarioCamposRelatorios> restricoes, List<RestricaoUsuarioCamposRelatorios> prev)
		{
			int num = 3;
			base.Sucesso = true;
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios1 = restricoes;
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios2 = prev;
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios3 = await Task.Run<List<RestricaoUsuarioCamposRelatorios>>(() => {
				List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios;
				while (num > 0)
				{
					List<Diferenca> diferencas = new List<Diferenca>();
					List<RegistroLog> registroLogs = new List<RegistroLog>();
					restricoes = restricaoUsuarioCamposRelatorios1;
					prev = restricaoUsuarioCamposRelatorios2;
					try
					{
						using (UnitOfWork commited = Instancia.Commited)
						{
							restricoes.ForEach((RestricaoUsuarioCamposRelatorios x) => {
								RestricaoUsuarioCamposRelatorios restricaoUsuarioCamposRelatorio = x;
								RestricaoUsuarioCamposRelatorios restricaoUsuarioCamposRelatorio1 = prev.FirstOrDefault<RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios y) => {
									if (y.get_Id() != 0)
									{
										return y.get_Id() == restricaoUsuarioCamposRelatorio.get_Id();
									}
									if (y.get_Campo() != restricaoUsuarioCamposRelatorio.get_Campo())
									{
										return false;
									}
									return y.get_Relatorio() == restricaoUsuarioCamposRelatorio.get_Relatorio();
								});
								if (restricaoUsuarioCamposRelatorio1 != null && restricaoUsuarioCamposRelatorio1.get_Restricao() == restricaoUsuarioCamposRelatorio.get_Restricao())
								{
									return;
								}
								if (restricaoUsuarioCamposRelatorio1 != null)
								{
									registroLogs.Add(base.CreateLog(restricaoUsuarioCamposRelatorio.get_Usuario().get_Id(), restricaoUsuarioCamposRelatorio.Compare(restricaoUsuarioCamposRelatorio1.GetValorOriginal()), 43, 1));
								}
								else
								{
									registroLogs.Add(base.CreateLog(restricaoUsuarioCamposRelatorio.get_Usuario().get_Id(), restricaoUsuarioCamposRelatorio.GetValorOriginal(), 43, 0));
								}
								restricaoUsuarioCamposRelatorio = (restricaoUsuarioCamposRelatorio.get_Id() == 0 ? commited.get_RestricaoUsuarioCamposRelatoriosRepository().SaveOrUpdate(restricaoUsuarioCamposRelatorio) : commited.get_RestricaoUsuarioCamposRelatoriosRepository().Merge(restricaoUsuarioCamposRelatorio));
							});
							base.SaveLog(registroLogs, commited);
							commited.Commit();
							restricaoUsuarioCamposRelatorios = restricoes;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 261, num, new { restricoes = restricoes, prev = prev }, true);
						continue;
					}
					return restricaoUsuarioCamposRelatorios;
				}
				return restricaoUsuarioCamposRelatorios1;
			});
			return restricaoUsuarioCamposRelatorios3;
		}
	}
}