using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
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.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;

namespace Gestor.Application.Servicos;

public class ArquivoDigitalServico : BaseServico
{
	public async Task<List<IndiceArquivoDigital>> BuscarPorTipo(TipoArquivoDigital tipo, long id)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		int tries = 3;
		long usuario = ((DomainBase)Recursos.Usuario).Id;
		return await Task.Run(delegate
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.IndiceArquivoDigitalRepository.Find(tipo, id, usuario, LicenseHelper.Produtos.Any((Licenca x) => (int)x.Produto == 86 && x.Status != 3));
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)64, tries, new { tipo, id });
				}
			}
			return new List<IndiceArquivoDigital>();
		});
	}

	public async Task<ArquivoDigital> BuscarPorId(long id, string banco)
	{
		int tries = 3;
		return await Task.Run((Func<ArquivoDigital>)delegate
		{
			while (tries > 0)
			{
				try
				{
					Gestor.Application.Helpers.ArquivoDigital.SetConnection(banco);
					if (string.IsNullOrEmpty(banco))
					{
						banco = Gestor.Application.Helpers.ArquivoDigital.Banco;
					}
					UnitOfWork read = Gestor.Application.Helpers.ArquivoDigital.Read;
					try
					{
						ArquivoDigital val = read.ArquivoDigitalRepository.FindById(id, true);
						if (val == null)
						{
							return (ArquivoDigital)null;
						}
						if (val.AzureGuid.HasValue)
						{
							byte[] result = Connection.DownloadFile(val.AzureStorage, val.DataCriacao.Value.Year, val.AzureGuid.Value, val.Extensao).Result;
							if (result == null)
							{
								return (ArquivoDigital)null;
							}
							val.Arquivo = result;
						}
						return val;
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)65, tries, new { id, banco });
				}
			}
			return (ArquivoDigital)null;
		});
	}

	public async Task<ArquivoDigital> BuscarPorId(long id)
	{
		int tries = 3;
		return await Task.Run((Func<ArquivoDigital>)delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						ArquivoDigital val = read.IndiceArquivoDigitalRepository.FindAssinatura(id);
						if (val.AzureGuid.HasValue)
						{
							byte[] result = Connection.DownloadFile(val.AzureStorage, val.DataCriacao.Value.Year, val.AzureGuid.Value, Path.GetExtension(val.Descricao), "siggner").Result;
							if (result == null)
							{
								return (ArquivoDigital)null;
							}
							val.Arquivo = result;
						}
						return val;
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)64, tries, id);
				}
			}
			return (ArquivoDigital)null;
		});
	}

	public async Task<bool> DeleteAttachment(IndiceArquivoDigital indice)
	{
		int tries = 3;
		DateTime now = Funcoes.GetNetworkTime();
		return await Task.Run(delegate
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			while (tries > 0)
			{
				List<RegistroLog> list = new List<RegistroLog>();
				try
				{
					UnitOfWork commited = Instancia.Commited;
					try
					{
						indice.Excluido = true;
						List<Diferenca> list2 = new List<Diferenca>
						{
							new Diferenca
							{
								Campo = "Id",
								Descricao = "ID",
								ValorAtual = ((DomainBase)indice).Id.ToString()
							},
							new Diferenca
							{
								Campo = "Descricao",
								Descricao = "DESCRIÇÃO",
								ValorAtual = indice.Descricao
							}
						};
						if (indice.AzureGuid.HasValue && Connection.DeleteFile(indice.AzureStorage, indice.DataCriacao.Value.Year, indice.AzureGuid.Value, indice.Extensao).Result)
						{
							list2.Add(new Diferenca
							{
								Campo = "AzureGuid",
								Descricao = "AzureGuid",
								ValorAtual = indice.AzureGuid.ToString()
							});
						}
						list.Add(CreateLog(((DomainBase)indice).Id, list2, (TipoTela)6, (TipoAcao)2));
						indice.DataAtualizacao = now;
						if (!indice.DataCriacao.HasValue || indice.DataCriacao.Value.Year < 1754)
						{
							indice.DataCriacao = now;
						}
						commited.IndiceArquivoDigitalRepository.Merge(indice);
						SaveLog(list, commited);
						((GenericUnitOfWork)commited).Commit();
					}
					finally
					{
						((IDisposable)commited)?.Dispose();
					}
					return true;
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)253, tries, indice);
				}
			}
			return false;
		});
	}

	public async Task<IndiceArquivoDigital> Save(IndiceArquivoDigital indice)
	{
		int tries = 3;
		base.Sucesso = true;
		IndiceArquivoDigital indiceOriginal = indice;
		DateTime now = Funcoes.GetNetworkTime();
		return await Task.Run((Func<IndiceArquivoDigital>)delegate
		{
			//IL_002e: 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_0068: Invalid comparison between Unknown and I4
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Invalid comparison between Unknown and I4
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			while (tries > 0)
			{
				indice = indiceOriginal;
				List<RegistroLog> list = new List<RegistroLog>();
				try
				{
					UnitOfWork commited = Instancia.Commited;
					try
					{
						TipoAcao val = (TipoAcao)(((DomainBase)indice).Id != 0L);
						indice.DataAtualizacao = now;
						indice.UsuarioAtualizacao = ((DomainBase)Recursos.Usuario).Id;
						indice.Excluido = false;
						if ((int)val == 1)
						{
							list.Add(CreateLog(((DomainBase)indice).Id, indice, (TipoTela)6));
						}
						indice = (((int)val == 1) ? commited.IndiceArquivoDigitalRepository.Merge(indice) : commited.IndiceArquivoDigitalRepository.SaveOrUpdate(indice));
						if ((int)val != 1)
						{
							List<Diferenca> diferenca = new List<Diferenca>
							{
								new Diferenca
								{
									Campo = "Descricao",
									Descricao = "DESCRIÇÃO",
									ValorAtual = indice.Descricao
								}
							};
							list.Add(CreateLog(((DomainBase)indice).Id, diferenca, (TipoTela)6, val));
						}
						SaveLog(list, commited);
						((GenericUnitOfWork)commited).Commit();
					}
					finally
					{
						((IDisposable)commited)?.Dispose();
					}
					return indice;
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)252, tries, indice);
				}
			}
			return indiceOriginal;
		});
	}

	public async Task<List<IndiceArquivoDigital>> Insert(List<ArquivoDigital> files)
	{
		int tries = 3;
		base.Sucesso = true;
		DateTime now = Funcoes.GetNetworkTime();
		List<ArquivoDigital> filesOriginal = files;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				List<RegistroLog> logs = new List<RegistroLog>();
				files = filesOriginal;
				try
				{
					List<IndiceArquivoDigital> indices = new List<IndiceArquivoDigital>();
					files.ForEach(delegate(ArquivoDigital file)
					{
						//IL_0035: Unknown result type (might be due to invalid IL or missing references)
						//IL_003a: 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_005b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0076: Unknown result type (might be due to invalid IL or missing references)
						//IL_0083: Expected O, but got Unknown
						//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
						//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
						//IL_00da: Unknown result type (might be due to invalid IL or missing references)
						//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
						//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
						//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
						//IL_0109: Unknown result type (might be due to invalid IL or missing references)
						//IL_0115: Unknown result type (might be due to invalid IL or missing references)
						//IL_0121: Unknown result type (might be due to invalid IL or missing references)
						//IL_012d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0139: Unknown result type (might be due to invalid IL or missing references)
						//IL_0145: Unknown result type (might be due to invalid IL or missing references)
						//IL_0151: Unknown result type (might be due to invalid IL or missing references)
						//IL_015d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0169: Unknown result type (might be due to invalid IL or missing references)
						//IL_0175: Unknown result type (might be due to invalid IL or missing references)
						//IL_0181: Unknown result type (might be due to invalid IL or missing references)
						//IL_018d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0199: Unknown result type (might be due to invalid IL or missing references)
						//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
						//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
						//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
						//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
						//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
						//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
						//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
						//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
						//IL_0206: Expected O, but got Unknown
						//IL_0268: Unknown result type (might be due to invalid IL or missing references)
						//IL_026d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0278: Unknown result type (might be due to invalid IL or missing references)
						//IL_0283: Unknown result type (might be due to invalid IL or missing references)
						//IL_0294: Expected O, but got Unknown
						file.UsuarioCriacao = ((DomainBase)Recursos.Usuario).Id;
						file.DataCriacao = now;
						file.DataAtualizacao = null;
						UploadFile val = new UploadFile
						{
							Ano = now.Year,
							Id = Guid.NewGuid(),
							Extensao = file.Extensao.Replace(".", string.Empty),
							Arquivo = file.Arquivo
						};
						if (Connection.ConnectionAddress.UsaAzureStorage && Connection.UploadFile(val).Result)
						{
							file.AzureGuid = val.Id;
							file.Arquivo = null;
							file.AzureStorage = Connection.ConnectionAddress.AzureStorage;
						}
						IndiceArquivoDigital val2 = new IndiceArquivoDigital
						{
							Descricao = file.Descricao,
							Bd = Gestor.Application.Helpers.ArquivoDigital.Banco,
							Extensao = file.Extensao,
							IdCliente = file.IdCliente,
							IdDocumento = file.IdDocumento,
							IdEmpresa = file.IdEmpresa,
							IdParcela = file.IdParcela,
							IdItem = file.IdItem,
							IdExtrato = file.IdExtrato,
							IdSinistro = file.IdSinistro,
							IdSeguradora = file.IdSeguradora,
							IdVendedor = file.IdVendedor,
							IdUsuario = file.IdUsuario,
							IdLancamento = file.IdLancamento,
							IdFornecedor = file.IdFornecedor,
							IdProspeccao = file.IdProspeccao,
							IdSocio = file.IdSocio,
							IdTarefa = file.IdTarefa,
							IdNotaFiscal = file.IdNotaFiscal,
							IdEstipulante = file.IdEstipulante,
							Excluido = file.Excluido,
							UsuarioCriacao = file.UsuarioCriacao,
							DataCriacao = file.DataCriacao,
							DataAtualizacao = file.DataAtualizacao,
							AzureGuid = file.AzureGuid,
							AzureStorage = file.AzureStorage
						};
						Gestor.Application.Helpers.ArquivoDigital.SetConnection();
						val2.Bd = Gestor.Application.Helpers.ArquivoDigital.Banco;
						UnitOfWork commited = Gestor.Application.Helpers.ArquivoDigital.Commited;
						try
						{
							file = commited.ArquivoDigitalRepository.SaveOrUpdate(file);
							val2.IdArquivoDigital = ((DomainBase)file).Id;
							((GenericUnitOfWork)commited).Commit();
						}
						finally
						{
							((IDisposable)commited)?.Dispose();
						}
						UnitOfWork commited2 = Instancia.Commited;
						try
						{
							val2 = commited2.IndiceArquivoDigitalRepository.SaveOrUpdate(val2);
							List<Diferenca> diferenca = new List<Diferenca>
							{
								new Diferenca
								{
									Campo = "Descricao",
									Descricao = "DESCRIÇÃO",
									ValorAtual = val2.Descricao
								}
							};
							logs.Add(CreateLog(((DomainBase)val2).Id, diferenca, (TipoTela)6, (TipoAcao)0));
							SaveLog(logs, commited2);
							((GenericUnitOfWork)commited2).Commit();
						}
						finally
						{
							((IDisposable)commited2)?.Dispose();
						}
						indices.Add(val2);
					});
					return indices;
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)252, tries, files);
				}
			}
			return new List<IndiceArquivoDigital>();
		});
	}

	public async Task<List<ArquivoDigital>> Buscar(List<IndiceArquivoDigital> ids)
	{
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					List<ArquivoDigital> arquivos = new List<ArquivoDigital>();
					(from x in ids
						group x by x.Bd).ToList().ForEach(delegate(IGrouping<string, IndiceArquivoDigital> x)
					{
						Gestor.Application.Helpers.ArquivoDigital.SetConnection(x.Key);
						List<long> list = (from l in x
							where !l.Assinado
							select l.IdArquivoDigital).ToList();
						List<long> list2 = (from l in x
							where l.Assinado
							select ((DomainBase)l).Id).ToList();
						if (list2.Any())
						{
							List<ArquivoDigital> _arquivos2 = new List<ArquivoDigital>();
							UnitOfWork unitOfWork2 = Instancia.Read;
							try
							{
								list2.ForEach(delegate(long a)
								{
									ArquivoDigital val2 = unitOfWork2.IndiceArquivoDigitalRepository.FindAssinatura(a);
									if (val2.AzureGuid.HasValue)
									{
										val2.Arquivo = Connection.DownloadFile(val2.AzureStorage, val2.DataCriacao.Value.Year, val2.AzureGuid.Value, Path.GetExtension(val2.Descricao), "siggner").Result;
									}
									if (val2.Arquivo != null)
									{
										_arquivos2.Add(val2);
									}
								});
							}
							finally
							{
								if (unitOfWork2 != null)
								{
									((IDisposable)unitOfWork2).Dispose();
								}
							}
							arquivos.AddRange(_arquivos2);
						}
						if (list.Any())
						{
							List<ArquivoDigital> _arquivos = new List<ArquivoDigital>();
							UnitOfWork unitOfWork = Gestor.Application.Helpers.ArquivoDigital.Read;
							try
							{
								list.ForEach(delegate(long a)
								{
									ArquivoDigital val = unitOfWork.ArquivoDigitalRepository.FindById(a, true);
									if (val.AzureGuid.HasValue)
									{
										val.Arquivo = Connection.DownloadFile(val.AzureStorage, val.DataCriacao.Value.Year, val.AzureGuid.Value, val.Extensao).Result;
									}
									if (val.Arquivo != null)
									{
										_arquivos.Add(val);
									}
								});
							}
							finally
							{
								if (unitOfWork != null)
								{
									((IDisposable)unitOfWork).Dispose();
								}
							}
							arquivos.AddRange(_arquivos);
						}
					});
					return arquivos;
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)66, tries, ids);
				}
			}
			return new List<ArquivoDigital>();
		});
	}

	public async Task Criar()
	{
		int tries = 3;
		await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Gestor.Application.Helpers.ArquivoDigital.Read;
					try
					{
						read.ArquivoDigitalRepository.FindById(1L, false);
						break;
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)288, tries);
				}
			}
		});
	}

	public async Task<List<ArquivoVinculo>> BaixarArquivosPendentes(List<ArquivoVinculo> arquivos)
	{
		string banco = Gestor.Application.Helpers.ArquivoDigital.Banco;
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Gestor.Application.Helpers.ArquivoDigital.Read;
					try
					{
						foreach (ArquivoVinculo arquivo in arquivos)
						{
							if (arquivo.Arquivo == null && !ExtensionMethods.IsNullOrEmpty<char>((IEnumerable<char>)arquivo.Chave))
							{
								byte[] result = Connection.DownloadFile(arquivo.Storage, arquivo.Ano, Guid.Parse(arquivo.Chave), ".pdf", "aggilizador").Result;
								if (result != null)
								{
									arquivo.Arquivo = result;
								}
							}
						}
						return arquivos;
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)65, tries, new { arquivos, banco });
				}
			}
			return (List<ArquivoVinculo>)null;
		});
	}
}