using ArquivoDigital.Infrastructure.Repository.Interface;
using ArquivoDigital.Infrastructure.UnitOfWork.Generic;
using ArquivoDigital.Infrastructure.UnitOfWork.Logic;
using CsQuery.ExtensionMethods.Internal;
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.API;
using Gestor.Model.Common;
using Gestor.Model.Domain.Aggilizador;
using Gestor.Model.Domain.Common;
using Gestor.Model.Domain.Generic;
using Gestor.Model.License;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

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

		public async Task<List<ArquivoVinculo>> BaixarArquivosPendentes(List<ArquivoVinculo> arquivos)
		{
			string banco = Gestor.Application.Helpers.ArquivoDigital.Banco;
			int num = 3;
			List<ArquivoVinculo> arquivoVinculos1 = await Task.Run<List<ArquivoVinculo>>(() => {
				List<ArquivoVinculo> arquivoVinculos;
				while (num > 0)
				{
					try
					{
						using (Gestor.Application.Helpers.ArquivoDigital.Read)
						{
							foreach (ArquivoVinculo arquivo in arquivos)
							{
								if (arquivo.get_Arquivo() != null || ExtensionMethods.IsNullOrEmpty<char>(arquivo.get_Chave()))
								{
									continue;
								}
								byte[] result = Connection.DownloadFile(arquivo.get_Storage(), arquivo.get_Ano(), Guid.Parse(arquivo.get_Chave()), ".pdf", "aggilizador", false).Result;
								if (result == null)
								{
									continue;
								}
								arquivo.set_Arquivo(result);
							}
							arquivoVinculos = arquivos;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 65, num, new { arquivos = arquivos, banco = banco }, true);
						continue;
					}
					return arquivoVinculos;
				}
				return null;
			});
			return arquivoVinculos1;
		}

		public async Task<List<Gestor.Model.Domain.Common.ArquivoDigital>> Buscar(List<IndiceArquivoDigital> ids)
		{
			int num = 3;
			List<Gestor.Model.Domain.Common.ArquivoDigital> arquivoDigitals4 = await Task.Run<List<Gestor.Model.Domain.Common.ArquivoDigital>>(() => {
				List<Gestor.Model.Domain.Common.ArquivoDigital> arquivoDigitals2;
				while (num > 0)
				{
					try
					{
						List<Gestor.Model.Domain.Common.ArquivoDigital> arquivoDigitals3 = new List<Gestor.Model.Domain.Common.ArquivoDigital>();
						List<IndiceArquivoDigital> indiceArquivoDigitals2 = ids;
						Func<IndiceArquivoDigital, string> u003cu003e9_61 = ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_1;
						if (u003cu003e9_61 == null)
						{
							u003cu003e9_61 = (IndiceArquivoDigital x) => x.get_Bd();
							ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_1 = u003cu003e9_61;
						}
						indiceArquivoDigitals2.GroupBy<IndiceArquivoDigital, string>(u003cu003e9_61).ToList<IGrouping<string, IndiceArquivoDigital>>().ForEach((IGrouping<string, IndiceArquivoDigital> x) => {
							Gestor.Application.Helpers.ArquivoDigital.SetConnection(x.Key);
							IGrouping<string, IndiceArquivoDigital> strs = x;
							Func<IndiceArquivoDigital, bool> u003cu003e9_63 = ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_3;
							if (u003cu003e9_63 == null)
							{
								u003cu003e9_63 = (IndiceArquivoDigital l) => !l.get_Assinado();
								ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_3 = u003cu003e9_63;
							}
							IEnumerable<IndiceArquivoDigital> indiceArquivoDigitals = strs.Where<IndiceArquivoDigital>(u003cu003e9_63);
							Func<IndiceArquivoDigital, long> u003cu003e9_64 = ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_4;
							if (u003cu003e9_64 == null)
							{
								u003cu003e9_64 = (IndiceArquivoDigital l) => l.get_IdArquivoDigital();
								ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_4 = u003cu003e9_64;
							}
							List<long> list = indiceArquivoDigitals.Select<IndiceArquivoDigital, long>(u003cu003e9_64).ToList<long>();
							IGrouping<string, IndiceArquivoDigital> strs1 = x;
							Func<IndiceArquivoDigital, bool> u003cu003e9_65 = ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_5;
							if (u003cu003e9_65 == null)
							{
								u003cu003e9_65 = (IndiceArquivoDigital l) => l.get_Assinado();
								ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_5 = u003cu003e9_65;
							}
							IEnumerable<IndiceArquivoDigital> indiceArquivoDigitals1 = strs1.Where<IndiceArquivoDigital>(u003cu003e9_65);
							Func<IndiceArquivoDigital, long> u003cu003e9_66 = ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_6;
							if (u003cu003e9_66 == null)
							{
								u003cu003e9_66 = (IndiceArquivoDigital l) => l.get_Id();
								ArquivoDigitalServico.u003cu003ec.u003cu003e9__6_6 = u003cu003e9_66;
							}
							List<long> nums = indiceArquivoDigitals1.Select<IndiceArquivoDigital, long>(u003cu003e9_66).ToList<long>();
							if (nums.Any<long>())
							{
								List<Gestor.Model.Domain.Common.ArquivoDigital> arquivoDigitals = new List<Gestor.Model.Domain.Common.ArquivoDigital>();
								using (Gestor.Infrastructure.UnitOfWork.Logic.UnitOfWork read = Instancia.Read)
								{
									nums.ForEach((long a) => {
										Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital = read.get_IndiceArquivoDigitalRepository().FindAssinatura(a);
										if (arquivoDigital.get_AzureGuid().HasValue)
										{
											arquivoDigital.set_Arquivo(Connection.DownloadFile(arquivoDigital.get_AzureStorage(), arquivoDigital.get_DataCriacao().Value.Year, arquivoDigital.get_AzureGuid().Value, Path.GetExtension(arquivoDigital.get_Descricao()), "siggner", false).Result);
										}
										if (arquivoDigital.get_Arquivo() != null)
										{
											arquivoDigitals.Add(arquivoDigital);
										}
									});
								}
								arquivoDigitals3.AddRange(arquivoDigitals);
							}
							if (list.Any<long>())
							{
								List<Gestor.Model.Domain.Common.ArquivoDigital> arquivoDigitals1 = new List<Gestor.Model.Domain.Common.ArquivoDigital>();
								using (ArquivoDigital.Infrastructure.UnitOfWork.Logic.UnitOfWork unitOfWork = Gestor.Application.Helpers.ArquivoDigital.Read)
								{
									list.ForEach((long a) => {
										Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital = unitOfWork.get_ArquivoDigitalRepository().FindById(a, true);
										if (arquivoDigital.get_AzureGuid().HasValue)
										{
											arquivoDigital.set_Arquivo(Connection.DownloadFile(arquivoDigital.get_AzureStorage(), arquivoDigital.get_DataCriacao().Value.Year, arquivoDigital.get_AzureGuid().Value, arquivoDigital.get_Extensao(), "ad", false).Result);
										}
										if (arquivoDigital.get_Arquivo() != null)
										{
											arquivoDigitals1.Add(arquivoDigital);
										}
									});
								}
								arquivoDigitals3.AddRange(arquivoDigitals1);
							}
						});
						arquivoDigitals2 = arquivoDigitals3;
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 66, num, ids, true);
						continue;
					}
					return arquivoDigitals2;
				}
				return new List<Gestor.Model.Domain.Common.ArquivoDigital>();
			});
			return arquivoDigitals4;
		}

		public async Task<Gestor.Model.Domain.Common.ArquivoDigital> BuscarPorId(long id, string banco)
		{
			int num = 3;
			Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital2 = await Task.Run<Gestor.Model.Domain.Common.ArquivoDigital>(() => {
				Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital;
				while (num > 0)
				{
					try
					{
						Gestor.Application.Helpers.ArquivoDigital.SetConnection(banco);
						if (string.IsNullOrEmpty(banco))
						{
							banco = Gestor.Application.Helpers.ArquivoDigital.Banco;
						}
						using (ArquivoDigital.Infrastructure.UnitOfWork.Logic.UnitOfWork read = Gestor.Application.Helpers.ArquivoDigital.Read)
						{
							Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital1 = read.get_ArquivoDigitalRepository().FindById(id, true);
							if (arquivoDigital1 != null)
							{
								if (arquivoDigital1.get_AzureGuid().HasValue)
								{
									byte[] result = Connection.DownloadFile(arquivoDigital1.get_AzureStorage(), arquivoDigital1.get_DataCriacao().Value.Year, arquivoDigital1.get_AzureGuid().Value, arquivoDigital1.get_Extensao(), "ad", false).Result;
									if (result != null)
									{
										arquivoDigital1.set_Arquivo(result);
									}
									else
									{
										arquivoDigital = null;
										return arquivoDigital;
									}
								}
								arquivoDigital = arquivoDigital1;
							}
							else
							{
								arquivoDigital = null;
							}
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 65, num, new { id = id, banco = banco }, true);
						continue;
					}
					return arquivoDigital;
				}
				return null;
			});
			return arquivoDigital2;
		}

		public async Task<Gestor.Model.Domain.Common.ArquivoDigital> BuscarPorId(long id)
		{
			int num = 3;
			Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital2 = await Task.Run<Gestor.Model.Domain.Common.ArquivoDigital>(() => {
				Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital;
				while (num > 0)
				{
					try
					{
						using (Gestor.Infrastructure.UnitOfWork.Logic.UnitOfWork read = Instancia.Read)
						{
							Gestor.Model.Domain.Common.ArquivoDigital arquivoDigital1 = read.get_IndiceArquivoDigitalRepository().FindAssinatura(id);
							if (arquivoDigital1.get_AzureGuid().HasValue)
							{
								byte[] result = Connection.DownloadFile(arquivoDigital1.get_AzureStorage(), arquivoDigital1.get_DataCriacao().Value.Year, arquivoDigital1.get_AzureGuid().Value, Path.GetExtension(arquivoDigital1.get_Descricao()), "siggner", false).Result;
								if (result != null)
								{
									arquivoDigital1.set_Arquivo(result);
								}
								else
								{
									arquivoDigital = null;
									return arquivoDigital;
								}
							}
							arquivoDigital = arquivoDigital1;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 64, num, id, true);
						continue;
					}
					return arquivoDigital;
				}
				return null;
			});
			return arquivoDigital2;
		}

		public async Task<List<IndiceArquivoDigital>> BuscarPorTipo(TipoArquivoDigital tipo, long id)
		{
			int num2 = 3;
			long num3 = Recursos.Usuario.get_Id();
			List<IndiceArquivoDigital> indiceArquivoDigitals1 = await Task.Run<List<IndiceArquivoDigital>>(() => {
				List<IndiceArquivoDigital> indiceArquivoDigitals;
				while (num2 > 0)
				{
					try
					{
						using (Gestor.Infrastructure.UnitOfWork.Logic.UnitOfWork read = Instancia.Read)
						{
							IIndiceArquivoDigitalRepository indiceArquivoDigitalRepository = read.get_IndiceArquivoDigitalRepository();
							TipoArquivoDigital tipoArquivoDigital = tipo;
							long num = id;
							long num1 = num3;
							List<Licenca> produtos = LicenseHelper.Produtos;
							Func<Licenca, bool> u003cu003e9_01 = ArquivoDigitalServico.u003cu003ec.u003cu003e9__0_1;
							if (u003cu003e9_01 == null)
							{
								u003cu003e9_01 = (Licenca x) => {
									if (x.get_Produto() != 86)
									{
										return false;
									}
									return x.get_Status() != 3;
								};
								ArquivoDigitalServico.u003cu003ec.u003cu003e9__0_1 = u003cu003e9_01;
							}
							indiceArquivoDigitals = indiceArquivoDigitalRepository.Find(tipoArquivoDigital, num, num1, produtos.Any<Licenca>(u003cu003e9_01));
						}
					}
					catch (Exception exception)
					{
						num2 = base.Registrar(exception, 64, num2, new { tipo = tipo, id = id }, true);
						continue;
					}
					return indiceArquivoDigitals;
				}
				return new List<IndiceArquivoDigital>();
			});
			return indiceArquivoDigitals1;
		}

		public async Task Criar()
		{
			int num = 3;
			await Task.Run(() => {
				while (num > 0)
				{
					try
					{
						using (ArquivoDigital.Infrastructure.UnitOfWork.Logic.UnitOfWork read = Gestor.Application.Helpers.ArquivoDigital.Read)
						{
							read.get_ArquivoDigitalRepository().FindById((long)1, false);
							break;
						}
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 288, num, null, true);
					}
				}
			});
		}

		public async Task<bool> DeleteAttachment(IndiceArquivoDigital indice)
		{
			int num = 3;
			DateTime networkTime = Funcoes.GetNetworkTime();
			bool flag1 = await Task.Run<bool>(() => {
				bool flag;
				while (num > 0)
				{
					List<RegistroLog> registroLogs = new List<RegistroLog>();
					try
					{
						using (Gestor.Infrastructure.UnitOfWork.Logic.UnitOfWork commited = Instancia.Commited)
						{
							indice.set_Excluido(true);
							List<Diferenca> diferencas = new List<Diferenca>();
							Diferenca diferenca = new Diferenca();
							diferenca.set_Campo("Id");
							diferenca.set_Descricao("ID");
							diferenca.set_ValorAtual(indice.get_Id().ToString());
							diferencas.Add(diferenca);
							Diferenca diferenca1 = new Diferenca();
							diferenca1.set_Campo("Descricao");
							diferenca1.set_Descricao("DESCRIÇÃO");
							diferenca1.set_ValorAtual(indice.get_Descricao());
							diferencas.Add(diferenca1);
							List<Diferenca> diferencas1 = diferencas;
							if (indice.get_AzureGuid().HasValue && Connection.DeleteFile(indice.get_AzureStorage(), indice.get_DataCriacao().Value.Year, indice.get_AzureGuid().Value, indice.get_Extensao(), "ad").Result)
							{
								Diferenca diferenca2 = new Diferenca();
								diferenca2.set_Campo("AzureGuid");
								diferenca2.set_Descricao("AzureGuid");
								diferenca2.set_ValorAtual(indice.get_AzureGuid().ToString());
								diferencas1.Add(diferenca2);
							}
							registroLogs.Add(base.CreateLog(indice.get_Id(), diferencas1, 6, 2));
							indice.set_DataAtualizacao(new DateTime?(networkTime));
							if (!indice.get_DataCriacao().HasValue || indice.get_DataCriacao().Value.Year < 1754)
							{
								indice.set_DataCriacao(new DateTime?(networkTime));
							}
							commited.get_IndiceArquivoDigitalRepository().Merge(indice);
							base.SaveLog(registroLogs, commited);
							commited.Commit();
						}
						flag = true;
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 253, num, indice, true);
						continue;
					}
					return flag;
				}
				return false;
			});
			return flag1;
		}

		public async Task<List<IndiceArquivoDigital>> Insert(List<Gestor.Model.Domain.Common.ArquivoDigital> files)
		{
			int num = 3;
			base.Sucesso = true;
			DateTime networkTime = Funcoes.GetNetworkTime();
			List<Gestor.Model.Domain.Common.ArquivoDigital> arquivoDigitals = files;
			List<IndiceArquivoDigital> indiceArquivoDigitals2 = await Task.Run<List<IndiceArquivoDigital>>(() => {
				List<IndiceArquivoDigital> indiceArquivoDigitals;
				while (num > 0)
				{
					List<RegistroLog> registroLogs = new List<RegistroLog>();
					files = arquivoDigitals;
					try
					{
						List<IndiceArquivoDigital> indiceArquivoDigitals1 = new List<IndiceArquivoDigital>();
						files.ForEach((Gestor.Model.Domain.Common.ArquivoDigital file) => {
							file.set_UsuarioCriacao(Recursos.Usuario.get_Id());
							file.set_DataCriacao(new DateTime?(networkTime));
							file.set_DataAtualizacao(null);
							UploadFile uploadFile = new UploadFile();
							uploadFile.set_Ano(networkTime.Year);
							uploadFile.set_Id(Guid.NewGuid());
							uploadFile.set_Extensao(file.get_Extensao().Replace(".", string.Empty));
							uploadFile.set_Arquivo(file.get_Arquivo());
							UploadFile uploadFile1 = uploadFile;
							if (Connection.ConnectionAddress.get_UsaAzureStorage() && Connection.UploadFile(uploadFile1, "ad").Result)
							{
								file.set_AzureGuid(new Guid?(uploadFile1.get_Id()));
								file.set_Arquivo(null);
								file.set_AzureStorage(Connection.ConnectionAddress.get_AzureStorage());
							}
							IndiceArquivoDigital indiceArquivoDigital = new IndiceArquivoDigital();
							indiceArquivoDigital.set_Descricao(file.get_Descricao());
							indiceArquivoDigital.set_Bd(Gestor.Application.Helpers.ArquivoDigital.Banco);
							indiceArquivoDigital.set_Extensao(file.get_Extensao());
							indiceArquivoDigital.set_IdCliente(file.get_IdCliente());
							indiceArquivoDigital.set_IdDocumento(file.get_IdDocumento());
							indiceArquivoDigital.set_IdEmpresa(file.get_IdEmpresa());
							indiceArquivoDigital.set_IdParcela(file.get_IdParcela());
							indiceArquivoDigital.set_IdItem(file.get_IdItem());
							indiceArquivoDigital.set_IdExtrato(file.get_IdExtrato());
							indiceArquivoDigital.set_IdSinistro(file.get_IdSinistro());
							indiceArquivoDigital.set_IdSeguradora(file.get_IdSeguradora());
							indiceArquivoDigital.set_IdVendedor(file.get_IdVendedor());
							indiceArquivoDigital.set_IdUsuario(file.get_IdUsuario());
							indiceArquivoDigital.set_IdLancamento(file.get_IdLancamento());
							indiceArquivoDigital.set_IdFornecedor(file.get_IdFornecedor());
							indiceArquivoDigital.set_IdProspeccao(file.get_IdProspeccao());
							indiceArquivoDigital.set_IdSocio(file.get_IdSocio());
							indiceArquivoDigital.set_IdTarefa(file.get_IdTarefa());
							indiceArquivoDigital.set_IdNotaFiscal(file.get_IdNotaFiscal());
							indiceArquivoDigital.set_IdEstipulante(file.get_IdEstipulante());
							indiceArquivoDigital.set_Excluido(file.get_Excluido());
							indiceArquivoDigital.set_UsuarioCriacao(file.get_UsuarioCriacao());
							indiceArquivoDigital.set_DataCriacao(file.get_DataCriacao());
							indiceArquivoDigital.set_DataAtualizacao(file.get_DataAtualizacao());
							indiceArquivoDigital.set_AzureGuid(file.get_AzureGuid());
							indiceArquivoDigital.set_AzureStorage(file.get_AzureStorage());
							IndiceArquivoDigital indiceArquivoDigital1 = indiceArquivoDigital;
							Gestor.Application.Helpers.ArquivoDigital.SetConnection("");
							indiceArquivoDigital1.set_Bd(Gestor.Application.Helpers.ArquivoDigital.Banco);
							using (ArquivoDigital.Infrastructure.UnitOfWork.Logic.UnitOfWork commited = Gestor.Application.Helpers.ArquivoDigital.Commited)
							{
								file = commited.get_ArquivoDigitalRepository().SaveOrUpdate(file);
								indiceArquivoDigital1.set_IdArquivoDigital(file.get_Id());
								commited.Commit();
							}
							using (Gestor.Infrastructure.UnitOfWork.Logic.UnitOfWork unitOfWork = Instancia.Commited)
							{
								indiceArquivoDigital1 = unitOfWork.get_IndiceArquivoDigitalRepository().SaveOrUpdate(indiceArquivoDigital1);
								List<Diferenca> diferencas = new List<Diferenca>();
								Diferenca diferenca = new Diferenca();
								diferenca.set_Campo("Descricao");
								diferenca.set_Descricao("DESCRIÇÃO");
								diferenca.set_ValorAtual(indiceArquivoDigital1.get_Descricao());
								diferencas.Add(diferenca);
								registroLogs.Add(base.CreateLog(indiceArquivoDigital1.get_Id(), diferencas, 6, 0));
								base.SaveLog(registroLogs, unitOfWork);
								unitOfWork.Commit();
							}
							indiceArquivoDigitals1.Add(indiceArquivoDigital1);
						});
						indiceArquivoDigitals = indiceArquivoDigitals1;
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 252, num, files, true);
						continue;
					}
					return indiceArquivoDigitals;
				}
				return new List<IndiceArquivoDigital>();
			});
			return indiceArquivoDigitals2;
		}

		public async Task<IndiceArquivoDigital> Save(IndiceArquivoDigital indice)
		{
			int num = 3;
			base.Sucesso = true;
			IndiceArquivoDigital indiceArquivoDigital1 = indice;
			DateTime networkTime = Funcoes.GetNetworkTime();
			IndiceArquivoDigital indiceArquivoDigital2 = await Task.Run<IndiceArquivoDigital>(() => {
				IndiceArquivoDigital indiceArquivoDigital;
				while (num > 0)
				{
					indice = indiceArquivoDigital1;
					List<RegistroLog> registroLogs = new List<RegistroLog>();
					try
					{
						using (Gestor.Infrastructure.UnitOfWork.Logic.UnitOfWork commited = Instancia.Commited)
						{
							TipoAcao tipoAcao = (indice.get_Id() == 0 ? 0 : 1);
							indice.set_DataAtualizacao(new DateTime?(networkTime));
							indice.set_UsuarioAtualizacao(Recursos.Usuario.get_Id());
							indice.set_Excluido(false);
							if (tipoAcao == 1)
							{
								registroLogs.Add(base.CreateLog(indice.get_Id(), indice, 6));
							}
							indice = (tipoAcao == 1 ? commited.get_IndiceArquivoDigitalRepository().Merge(indice) : commited.get_IndiceArquivoDigitalRepository().SaveOrUpdate(indice));
							if (tipoAcao != 1)
							{
								List<Diferenca> diferencas = new List<Diferenca>();
								Diferenca diferenca = new Diferenca();
								diferenca.set_Campo("Descricao");
								diferenca.set_Descricao("DESCRIÇÃO");
								diferenca.set_ValorAtual(indice.get_Descricao());
								diferencas.Add(diferenca);
								registroLogs.Add(base.CreateLog(indice.get_Id(), diferencas, 6, tipoAcao));
							}
							base.SaveLog(registroLogs, commited);
							commited.Commit();
						}
						indiceArquivoDigital = indice;
					}
					catch (Exception exception)
					{
						num = base.Registrar(exception, 252, num, indice, true);
						continue;
					}
					return indiceArquivoDigital;
				}
				return indiceArquivoDigital1;
			});
			return indiceArquivoDigital2;
		}
	}
}