using System;
using System.Collections.Generic;
using System.Threading.Tasks;
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.Common;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Relatorios;
using Gestor.Model.Domain.Seguros;

namespace Gestor.Application.Servicos.Seguros;

internal class SinistroServico : BaseServico
{
	internal async Task<List<ControleSinistro>> BuscarControles(long id)
	{
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.ControleSinistroRepository.FindByIdItem(id);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)48, tries, id);
				}
			}
			return new List<ControleSinistro>();
		});
	}

	public async Task<Sinistro> BuscarSinistro(long id)
	{
		int tries = 3;
		return await Task.Run((Func<Sinistro>)delegate
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.SinistroRepository.FindById(id);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)49, tries, id);
				}
			}
			return new Sinistro();
		});
	}

	public async Task<bool> Delete(Sinistro sinistro)
	{
		int tries = 3;
		base.Sucesso = true;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				List<RegistroLog> list = new List<RegistroLog>();
				try
				{
					UnitOfWork commited = Instancia.Commited;
					try
					{
						list.Add(CreateLog(((DomainBase)sinistro).Id, ((DomainBase)sinistro).GetValorOriginal(), (TipoTela)26, (TipoAcao)2));
						SinistroAuto val = commited.SinistroAutoRepository.FindBySinistroId(((DomainBase)sinistro).Id);
						SinistroVida val2 = commited.SinistroVidaRepository.FindBySinistroId(((DomainBase)sinistro).Id);
						if (val != null)
						{
							commited.SinistroAutoRepository.Delete(((DomainBase)val).Id);
						}
						if (val2 != null)
						{
							commited.SinistroVidaRepository.Delete(((DomainBase)val2).Id);
						}
						commited.SinistroRepository.Delete(((DomainBase)sinistro).Id);
						SaveLog(list, commited);
						((GenericUnitOfWork)commited).Commit();
						return true;
					}
					finally
					{
						((IDisposable)commited)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)174, tries, sinistro);
				}
			}
			return false;
		});
	}

	public async Task<bool> DeleteControle(ControleSinistro controle, bool atualizarItem)
	{
		int tries = 3;
		base.Sucesso = true;
		return await Task.Run(async delegate
		{
			while (tries > 0)
			{
				List<RegistroLog> logs = new List<RegistroLog>();
				try
				{
					UnitOfWork unitOfWork = Instancia.Commited;
					try
					{
						if (atualizarItem)
						{
							Item val = unitOfWork.ItemRepository.FindById(((DomainBase)controle.Item).Id);
							val.Sinistrado = false;
							unitOfWork.ItemRepository.Merge(val);
						}
						List<Sinistro> list = unitOfWork.SinistroRepository.FindByControleId(((DomainBase)controle).Id);
						foreach (Sinistro item in list)
						{
							logs.Add(CreateLog(((DomainBase)item).Id, ((DomainBase)item).GetValorOriginal(), (TipoTela)26, (TipoAcao)2));
							if (!(await Delete(item)))
							{
								return false;
							}
						}
						unitOfWork.ControleSinistroRepository.Delete(((DomainBase)controle).Id);
						SaveLog(logs, unitOfWork);
						((GenericUnitOfWork)unitOfWork).Commit();
						return true;
					}
					finally
					{
						((IDisposable)unitOfWork)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)174, tries, controle);
				}
			}
			return false;
		});
	}

	public async Task<Sinistro> Save(Sinistro sinistro, long idramo)
	{
		int tries = 3;
		base.Sucesso = true;
		Sinistro sinistroSalvo = sinistro;
		Funcoes.GetNetworkTime();
		return await Task.Run((Func<Sinistro>)delegate
		{
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			while (tries > 0)
			{
				List<RegistroLog> list = new List<RegistroLog>();
				try
				{
					UnitOfWork commited = Instancia.Commited;
					try
					{
						Item val = commited.ItemRepository.FindById(((DomainBase)sinistro.ControleSinistro.Item).Id);
						val.Sinistrado = true;
						sinistroSalvo.ControleSinistro.Item = commited.ItemRepository.Merge(val);
						bool num = ((DomainBase)sinistroSalvo.ControleSinistro).Id == 0;
						SinistroAuto sinistroAuto = sinistroSalvo.SinistroAuto;
						SinistroVida val2 = sinistroSalvo.SinistroVida;
						if (num)
						{
							sinistroSalvo.ControleSinistro = commited.ControleSinistroRepository.SaveOrUpdate(sinistroSalvo.ControleSinistro);
							sinistroSalvo = commited.SinistroRepository.SaveOrUpdate(sinistroSalvo);
							list.Add(CreateLog(((DomainBase)sinistroSalvo).Id, ((DomainBase)sinistroSalvo).GetValorOriginal(), (TipoTela)7, (TipoAcao)0));
							long num2 = idramo;
							long num3 = num2 - 5;
							if ((ulong)num3 <= 5uL)
							{
								switch (num3)
								{
								case 0L:
									goto IL_012e;
								case 1L:
								case 2L:
								case 4L:
								case 5L:
									goto IL_0158;
								case 3L:
									goto IL_02d6;
								}
							}
							if (num2 == 37)
							{
								goto IL_012e;
							}
							if (num2 == 53)
							{
								goto IL_0158;
							}
						}
						else
						{
							list.Add(CreateLog(((DomainBase)sinistroSalvo).Id, sinistroSalvo, (TipoTela)7));
							sinistroSalvo.ControleSinistro = commited.ControleSinistroRepository.Merge(sinistroSalvo.ControleSinistro);
							sinistroSalvo = ((((DomainBase)sinistroSalvo).Id == 0L) ? commited.SinistroRepository.SaveOrUpdate(sinistroSalvo) : commited.SinistroRepository.Merge(sinistroSalvo));
							long num2 = idramo;
							long num4 = num2 - 5;
							if ((ulong)num4 <= 5uL)
							{
								switch (num4)
								{
								case 0L:
									goto IL_0247;
								case 1L:
								case 2L:
								case 4L:
								case 5L:
									goto IL_028a;
								case 3L:
									goto IL_02d6;
								}
							}
							if (num2 == 37)
							{
								goto IL_0247;
							}
							if (num2 == 53)
							{
								goto IL_028a;
							}
						}
						goto IL_02d6;
						IL_0247:
						if (sinistroAuto != null)
						{
							sinistroAuto.Sinistro = sinistroSalvo;
							sinistroAuto = ((((DomainBase)sinistroAuto).Id == 0L) ? commited.SinistroAutoRepository.SaveOrUpdate(sinistroAuto) : commited.SinistroAutoRepository.Merge(sinistroAuto));
							sinistroSalvo.SinistroAuto = sinistroAuto;
						}
						goto IL_02d6;
						IL_028a:
						if (val2 == null)
						{
							val2 = new SinistroVida();
						}
						val2.Sinistro = sinistroSalvo;
						val2 = ((((DomainBase)val2).Id == 0L) ? commited.SinistroVidaRepository.SaveOrUpdate(val2) : commited.SinistroVidaRepository.Merge(val2));
						sinistroSalvo.SinistroVida = val2;
						goto IL_02d6;
						IL_012e:
						sinistroAuto.Sinistro = sinistroSalvo;
						sinistroAuto = commited.SinistroAutoRepository.SaveOrUpdate(sinistroAuto);
						sinistroSalvo.SinistroAuto = sinistroAuto;
						goto IL_02d6;
						IL_0158:
						val2.Sinistro = sinistroSalvo;
						val2 = commited.SinistroVidaRepository.SaveOrUpdate(val2);
						sinistroSalvo.SinistroVida = val2;
						goto IL_02d6;
						IL_02d6:
						SaveLog(list, commited);
						((GenericUnitOfWork)commited).Commit();
						return sinistroSalvo;
					}
					finally
					{
						((IDisposable)commited)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)175, tries, sinistro);
				}
			}
			return sinistro;
		});
	}

	public async Task<List<Sinistro>> BuscarSinistro(Filtros filtro)
	{
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.SinistroRepository.FindByData(filtro, false);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)176, tries, filtro);
				}
			}
			return new List<Sinistro>();
		});
	}

	public async Task<List<Sinistro>> BuscarSinistroPendente(Filtros filtro)
	{
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.SinistroRepository.FindByData(filtro, true);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)176, tries, filtro);
				}
			}
			return new List<Sinistro>();
		});
	}

	public async Task<List<Sinistro>> BuscarSinistros(string numero)
	{
		int tries = 3;
		return await Task.Run(delegate
		{
			while (tries > 0)
			{
				try
				{
					UnitOfWork read = Instancia.Read;
					try
					{
						return read.SinistroRepository.FindNumeroSinistro(numero);
					}
					finally
					{
						((IDisposable)read)?.Dispose();
					}
				}
				catch (Exception e)
				{
					tries = Registrar(e, (TipoErro)177, tries, numero);
				}
			}
			return new List<Sinistro>();
		});
	}
}