using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Media;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Financeiro;
using Gestor.Application.Servicos.Generic;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Validation;
using Gestor.Model.Common;
using Gestor.Model.Domain.Financeiro;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Seguros;
using Gestor.Model.Helper;

namespace Gestor.Application.ViewModels.Financeiro;

public class BancosContasViewModel : BaseFinanceiroViewModel
{
	private readonly BancosContasServico _bancosContasServico;

	public BancosContas CancelBancosContas;

	private long _ultimoId;

	private BancosContas _selectedBancosContas;

	private SolidColorBrush _corDoSaldo = new SolidColorBrush(Colors.Green);

	private ObservableCollection<BancosContas> _bancosContasFiltrados = new ObservableCollection<BancosContas>();

	private bool _isExpanded;

	private ObservableCollection<Saldo> _saldos = new ObservableCollection<Saldo>();

	private bool _habilitarFecharSaldo;

	private Saldo _selectedSaldo = new Saldo();

	private string _saldoAtual;

	private decimal? _valorAbertura;

	private DateTime? _dataAbertura;

	private bool _incluindo;

	public List<BancosContas> BancosContas { get; set; }

	public BancosContas SelectedBancosContas
	{
		get
		{
			return _selectedBancosContas;
		}
		set
		{
			_selectedBancosContas = value;
			CarregarSaldos(value);
			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
			Incluindo = value != null && ((DomainBase)value).Id == 0;
			OnPropertyChanged("SelectedBancosContas");
		}
	}

	public SolidColorBrush CorDoSaldo
	{
		get
		{
			return _corDoSaldo;
		}
		set
		{
			_corDoSaldo = value;
			OnPropertyChanged("CorDoSaldo");
		}
	}

	public ObservableCollection<BancosContas> BancosContasFiltrados
	{
		get
		{
			return _bancosContasFiltrados;
		}
		set
		{
			_bancosContasFiltrados = value;
			IsExpanded = value != null && value.Count > 0;
			OnPropertyChanged("BancosContasFiltrados");
		}
	}

	public bool IsExpanded
	{
		get
		{
			return _isExpanded;
		}
		set
		{
			_isExpanded = value;
			OnPropertyChanged("IsExpanded");
		}
	}

	public ObservableCollection<Saldo> Saldos
	{
		get
		{
			return _saldos;
		}
		set
		{
			_saldos = value;
			if (value != null && value.Count > 0)
			{
				SelectedSaldo = ((IEnumerable<Saldo>)value).FirstOrDefault((Func<Saldo, bool>)((Saldo x) => !x.DataFinal.HasValue));
				if (SelectedSaldo == null)
				{
					UltimoSladoNaoAberto();
				}
			}
			OnPropertyChanged("Saldos");
		}
	}

	public bool HabilitarFecharSaldo
	{
		get
		{
			return _habilitarFecharSaldo;
		}
		set
		{
			_habilitarFecharSaldo = value;
			OnPropertyChanged("HabilitarFecharSaldo");
		}
	}

	public Saldo SelectedSaldo
	{
		get
		{
			return _selectedSaldo;
		}
		set
		{
			_selectedSaldo = value;
			int habilitarFecharSaldo;
			if (value != null && !value.DataFinal.HasValue)
			{
				Usuario usuario = Recursos.Usuario;
				habilitarFecharSaldo = ((usuario != null && ((DomainBase)usuario).Id > 0) ? 1 : 0);
			}
			else
			{
				habilitarFecharSaldo = 0;
			}
			HabilitarFecharSaldo = (byte)habilitarFecharSaldo != 0;
			OnPropertyChanged("SelectedSaldo");
			Saldo selectedSaldo = SelectedSaldo;
			if (selectedSaldo != null)
			{
				((DomainBase)selectedSaldo).Initialize();
			}
		}
	}

	public string SaldoAtual
	{
		get
		{
			return _saldoAtual;
		}
		set
		{
			_saldoAtual = value;
			OnPropertyChanged("SaldoAtual");
		}
	}

	public decimal? ValorAbertura
	{
		get
		{
			return _valorAbertura;
		}
		set
		{
			_valorAbertura = value;
			OnPropertyChanged("ValorAbertura");
		}
	}

	public DateTime? DataAbertura
	{
		get
		{
			return _dataAbertura;
		}
		set
		{
			_dataAbertura = value;
			OnPropertyChanged("DataAbertura");
		}
	}

	public bool Incluindo
	{
		get
		{
			return _incluindo;
		}
		set
		{
			_incluindo = value;
			OnPropertyChanged("Incluindo");
		}
	}

	public BancosContasViewModel()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		_bancosContasServico = new BancosContasServico();
		Seleciona();
	}

	public async void CarregarSaldos(BancosContas banco)
	{
		if (banco == null || ((DomainBase)banco).Id == 0L)
		{
			return;
		}
		List<Saldo> source = await _bancosContasServico.BuscarSaldos(((DomainBase)banco).Id);
		CorDoSaldo = new SolidColorBrush(Colors.Green);
		SaldoAtual = string.Empty;
		Saldos = new ObservableCollection<Saldo>(source.OrderByDescending((Saldo x) => x.DataInicio));
		if (Saldos.FirstOrDefault() != null)
		{
			Saldo saldo = new Saldo
			{
				Conta = Saldos.First().Conta,
				ValorInicio = Saldos.First().ValorInicio,
				DataInicio = Saldos.First().DataInicio,
				DataFinal = Funcoes.GetNetworkTime()
			};
			saldo = await _bancosContasServico.FecharSaldo(saldo);
			decimal? valorFinal = saldo.ValorFinal;
			if ((valorFinal.GetValueOrDefault() < default(decimal)) & valorFinal.HasValue)
			{
				CorDoSaldo = new SolidColorBrush(Colors.Red);
			}
			SaldoAtual = $"SALDO: {Math.Round(saldo.ValorFinal.GetValueOrDefault(), 2):c}";
		}
	}

	private async void UltimoSladoNaoAberto()
	{
		Saldo ultimoSaldo = Saldos.ToList().Find(delegate(Saldo x)
		{
			DateTime? dataInicio = x.DataInicio;
			DateTime? dateTime = Saldos.Max((Saldo r) => r.DataInicio);
			if (dataInicio.HasValue != dateTime.HasValue)
			{
				return false;
			}
			return !dataInicio.HasValue || dataInicio.GetValueOrDefault() == dateTime.GetValueOrDefault();
		});
		bool flag = ultimoSaldo.DataFinal.HasValue;
		if (flag)
		{
			flag = await ShowMessage("O ÚLTIMO SALDO NÃO ESTÁ ABERTO. DESEJA ABRÍ-LO AGORA?", "SIM", "NÃO");
		}
		if (flag)
		{
			ultimoSaldo.DataFinal = null;
			ultimoSaldo.ValorFinal = null;
			SelectedSaldo = await _bancosContasServico.Save(ultimoSaldo);
			SelectedBancosContas = SelectedBancosContas;
		}
	}

	private async void Seleciona()
	{
		Loading(isLoading: true);
		await PermissaoTela((TipoTela)26);
		await SelecionaBancosDeContas();
		Loading(isLoading: false);
	}

	private async Task SelecionaBancosDeContas()
	{
		Loading(isLoading: true);
		List<BancosContas> list = await _bancosContasServico.BuscarBancos();
		BancosContas = (from x in list
			orderby x.Ativo descending, x.Descricao
			select x).ToList();
		BancosContasFiltrados = new ObservableCollection<BancosContas>(BancosContas);
		if (BancosContasFiltrados.Count > 0)
		{
			SelecionaBancosContas(BancosContasFiltrados.First());
		}
		else
		{
			SelectedBancosContas = new BancosContas();
			Saldos = new ObservableCollection<Saldo>();
			DataAbertura = null;
			ValorAbertura = default(decimal);
			SaldoAtual = "";
			Alterar(alterar: false);
			base.EnableMenu = false;
		}
		Recursos.BancosContas = list;
		Loading(isLoading: false);
	}

	public void Incluir()
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		_ultimoId = ((DomainBase)SelectedBancosContas).Id;
		DataAbertura = null;
		ValorAbertura = default(decimal);
		SaldoAtual = "";
		SelectedBancosContas = new BancosContas
		{
			Ativo = true
		};
		Saldos = new ObservableCollection<Saldo>();
		SelectedSaldo = null;
		Alterar(alterar: true);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar()
	{
		List<KeyValuePair<string, string>> list = SelectedBancosContas.Validate();
		list.AddRange(Validate());
		if (list.Count > 0)
		{
			return list;
		}
		BancosContas conta = await _bancosContasServico.Save(SelectedBancosContas);
		if (!_bancosContasServico.Sucesso)
		{
			return null;
		}
		if (((DomainBase)SelectedBancosContas).Id == 0L && DataAbertura.HasValue && ValorAbertura.HasValue)
		{
			Saldo saldo = new Saldo
			{
				Conta = conta,
				DataInicio = DataAbertura.Value,
				ValorInicio = ValorAbertura.Value
			};
			await _bancosContasServico.Save(saldo);
			if (!_bancosContasServico.Sucesso)
			{
				return null;
			}
		}
		await SelecionaBancosDeContas();
		SelecionaBancosContas(conta);
		Recursos.BancosContas = BancosContas;
		Alterar(alterar: false);
		ToggleSnackBar("CONTA SALVA COM SUCESSO");
		return null;
	}

	public List<KeyValuePair<string, string>> Validate()
	{
		List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
		if (BancosContas.Where((BancosContas x) => x.Descricao == SelectedBancosContas.Descricao && ((DomainBase)x).Id != ((DomainBase)SelectedBancosContas).Id).Any())
		{
			ValidationHelper.AddValue<string, string>(list, "Descricao|DESCRIÇÃO", "NÃO É POSSÍVEL SALVAR MAIS DE UMA CONTA COM A MESMA DESCRIÇÃO.", true);
		}
		if (((DomainBase)SelectedBancosContas).Id == 0L)
		{
			if (!DataAbertura.HasValue)
			{
				ValidationHelper.AddValue<string, string>(list, "DataAbertura|ABERTURA", "É NECESSÁRIO PREENCHER A DATA DE ABERTURA DA CONTA.", true);
			}
			else if (DateTime.Compare(DataAbertura.Value, new DateTime(1753, 1, 1)) < 0 || DateTime.Compare(DataAbertura.Value, new DateTime(9999, 12, 31)) > 0)
			{
				ValidationHelper.AddValue<string, string>(list, "DataAbertura|ABERTURA", "DATA INVÁLIDA", true);
			}
			if (!ValorAbertura.HasValue)
			{
				ValidationHelper.AddValue<string, string>(list, "ValorAbertura|VALOR", "É NECESSÁRIO PREENCHER O VALOR DE ABERTURA DA CONTA.", true);
			}
		}
		return list;
	}

	public async void CancelarAlteracao()
	{
		Loading(isLoading: true);
		if (((DomainBase)SelectedBancosContas).Id > 0)
		{
			await SelecionaBancosDeContas();
		}
		SelecionaBancosContas(((IEnumerable<BancosContas>)BancosContasFiltrados).FirstOrDefault((Func<BancosContas, bool>)((BancosContas x) => ((DomainBase)x).Id == _ultimoId)) ?? BancosContasFiltrados.FirstOrDefault());
		Alterar(alterar: false);
		Loading(isLoading: false);
	}

	public async void Excluir()
	{
		if (SelectedBancosContas == null || ((DomainBase)SelectedBancosContas).Id == 0L)
		{
			return;
		}
		if (await new BaseServico().BancosContasUtilizado(((DomainBase)SelectedBancosContas).Id))
		{
			await ShowMessage("NÃO PODE SER EXCLUÍDO POIS ESTÁ SENDO UTILIZADO EM UM LANÇAMENTO.");
		}
		else if (await ShowMessage("DESEJA REALMENTE EXCLUIR A CONTA " + SelectedBancosContas.Descricao + " PERMANENTEMENTE?", "SIM", "NÃO"))
		{
			Loading(isLoading: true);
			if (!(await _bancosContasServico.Delete(SelectedBancosContas)))
			{
				Loading(isLoading: false);
				return;
			}
			await SelecionaBancosDeContas();
			Loading(isLoading: false);
			ToggleSnackBar("CONTA EXCLUÍDA COM SUCESSO");
		}
	}

	public async void ExcluirSaldo()
	{
		if (SelectedSaldo == null || ((DomainBase)SelectedSaldo).Id == 0L)
		{
			return;
		}
		if (Saldos.Count <= 1)
		{
			await ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO INICIAL DA CONTA.");
		}
		else
		{
			if (!(await ShowMessage("DESEJA REALMENTE EXCLUIR O SALDO PERMANENTEMENTE?", "SIM", "NÃO")))
			{
				return;
			}
			Loading(isLoading: true);
			Saldo val = ((IEnumerable<Saldo>)Saldos).FirstOrDefault((Func<Saldo, bool>)delegate(Saldo x)
			{
				DateTime? dataFinal = x.DataFinal;
				DateTime? dataInicio = SelectedSaldo.DataInicio;
				if (dataFinal.HasValue != dataInicio.HasValue)
				{
					return false;
				}
				return !dataFinal.HasValue || dataFinal.GetValueOrDefault() == dataInicio.GetValueOrDefault();
			});
			if (val == null)
			{
				Loading(isLoading: false);
				await ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO DA CONTA.");
				return;
			}
			val.DataFinal = null;
			val.ValorFinal = null;
			await _bancosContasServico.Save(val);
			if (!_bancosContasServico.Sucesso)
			{
				Loading(isLoading: false);
				return;
			}
			if (!(await _bancosContasServico.DeleteSaldo(SelectedSaldo)))
			{
				Loading(isLoading: false);
				return;
			}
			CarregarSaldos(SelectedBancosContas);
			Loading(isLoading: false);
			ToggleSnackBar("SALDO EXCLUÍDO COM SUCESSO");
			Loading(isLoading: false);
		}
	}

	public void SelecionaBancosContas(BancosContas bancosContas)
	{
		Loading(isLoading: true);
		SelectedBancosContas = ((IEnumerable<BancosContas>)BancosContasFiltrados).FirstOrDefault((Func<BancosContas, bool>)((BancosContas x) => ((DomainBase)x).Id == ((DomainBase)bancosContas).Id));
		Loading(isLoading: false);
	}

	internal async Task<List<BancosContas>> Filtrar(string value)
	{
		return await Task.Run(() => FiltrarBancosContas(value));
	}

	public List<BancosContas> FiltrarBancosContas(string filter)
	{
		BancosContasFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<BancosContas>(BancosContas) : new ObservableCollection<BancosContas>(from x in BancosContas
			where ValidationHelper.RemoveDiacritics(x.Descricao.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter))
			orderby x.Ativo descending, x.Descricao
			select x));
		return BancosContasFiltrados.ToList();
	}

	public async Task FecharSaldo()
	{
		SelectedSaldo = await _bancosContasServico.Save(SelectedSaldo);
		if (!_bancosContasServico.Sucesso)
		{
			return;
		}
		if (SelectedSaldo.DataFinal.HasValue && SelectedSaldo.ValorFinal.HasValue)
		{
			Saldo saldo = new Saldo
			{
				Conta = SelectedSaldo.Conta,
				DataFinal = null,
				DataInicio = SelectedSaldo.DataFinal.Value,
				ValorFinal = null,
				ValorInicio = SelectedSaldo.ValorFinal.Value
			};
			await _bancosContasServico.Save(saldo);
			if (!_bancosContasServico.Sucesso)
			{
				return;
			}
		}
		CarregarSaldos(SelectedBancosContas);
		ToggleSnackBar("SALDO FECHADO COM SUCESSO");
	}

	public async Task<decimal> CalcularValor()
	{
		return (await _bancosContasServico.FecharSaldo(SelectedSaldo)).ValorFinal.GetValueOrDefault();
	}
}