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.Domain.Financeiro;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Seguros;
using Gestor.Model.Helper;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows.Media;

namespace Gestor.Application.ViewModels.Financeiro
{
	public class BancosContasViewModel : BaseFinanceiroViewModel
	{
		private readonly BancosContasServico _bancosContasServico;

		public Gestor.Model.Domain.Financeiro.BancosContas CancelBancosContas;

		private long _ultimoId;

		private Gestor.Model.Domain.Financeiro.BancosContas _selectedBancosContas;

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

		private ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> _bancosContasFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.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<Gestor.Model.Domain.Financeiro.BancosContas> BancosContas
		{
			get;
			set;
		}

		public ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> BancosContasFiltrados
		{
			get
			{
				return this._bancosContasFiltrados;
			}
			set
			{
				this._bancosContasFiltrados = value;
				this.IsExpanded = (value != null ? value.Count > 0 : false);
				base.OnPropertyChanged("BancosContasFiltrados");
			}
		}

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

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

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

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

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

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

		public ObservableCollection<Saldo> Saldos
		{
			get
			{
				return this._saldos;
			}
			set
			{
				this._saldos = value;
				if (value != null && value.Count > 0)
				{
					this.SelectedSaldo = value.FirstOrDefault<Saldo>((Saldo x) => !x.get_DataFinal().HasValue);
					if (this.SelectedSaldo == null)
					{
						this.UltimoSladoNaoAberto();
					}
				}
				base.OnPropertyChanged("Saldos");
			}
		}

		public Gestor.Model.Domain.Financeiro.BancosContas SelectedBancosContas
		{
			get
			{
				return this._selectedBancosContas;
			}
			set
			{
				long? nullable;
				this._selectedBancosContas = value;
				this.CarregarSaldos(value);
				if (value != null)
				{
					nullable = new long?(value.get_Id());
				}
				else
				{
					nullable = null;
				}
				base.VerificarEnables(nullable);
				this.Incluindo = (value == null ? false : value.get_Id() == (long)0);
				base.OnPropertyChanged("SelectedBancosContas");
			}
		}

		public Saldo SelectedSaldo
		{
			get
			{
				return this._selectedSaldo;
			}
			set
			{
				bool id;
				this._selectedSaldo = value;
				if (value == null || value.get_DataFinal().HasValue)
				{
					id = false;
				}
				else
				{
					Usuario usuario = Recursos.Usuario;
					if (usuario != null)
					{
						id = usuario.get_Id() > (long)0;
					}
					else
					{
						id = false;
					}
				}
				this.HabilitarFecharSaldo = id;
				base.OnPropertyChanged("SelectedSaldo");
				Saldo selectedSaldo = this.SelectedSaldo;
				if (selectedSaldo == null)
				{
					return;
				}
				selectedSaldo.Initialize();
			}
		}

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

		public BancosContasViewModel()
		{
			this._bancosContasServico = new BancosContasServico();
			this.Seleciona();
		}

		public async Task<decimal> CalcularValor()
		{
			decimal? valorFinal = await this._bancosContasServico.FecharSaldo(this.SelectedSaldo).get_ValorFinal();
			return valorFinal.GetValueOrDefault();
		}

		public async void CancelarAlteracao()
		{
			base.Loading(true);
			if (this.SelectedBancosContas.get_Id() > (long)0)
			{
				await this.SelecionaBancosDeContas();
			}
			BancosContasViewModel bancosContasViewModel = this;
			Gestor.Model.Domain.Financeiro.BancosContas bancosConta = this.BancosContasFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.BancosContas>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == this._ultimoId);
			if (bancosConta == null)
			{
				bancosConta = this.BancosContasFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.BancosContas>();
			}
			bancosContasViewModel.SelecionaBancosContas(bancosConta);
			base.Alterar(false);
			base.Loading(false);
		}

		public async void CarregarSaldos(Gestor.Model.Domain.Financeiro.BancosContas banco)
		{
			if (banco != null && banco.get_Id() != 0)
			{
				List<Saldo> saldos = await this._bancosContasServico.BuscarSaldos(banco.get_Id());
				this.CorDoSaldo = new SolidColorBrush(Colors.Green);
				this.SaldoAtual = string.Empty;
				BancosContasViewModel observableCollection = this;
				List<Saldo> saldos1 = saldos;
				observableCollection.Saldos = new ObservableCollection<Saldo>(
					from x in saldos1
					orderby x.get_DataInicio() descending
					select x);
				if (this.Saldos.FirstOrDefault<Saldo>() != null)
				{
					Saldo saldo = new Saldo();
					saldo.set_Conta(this.Saldos.First<Saldo>().get_Conta());
					saldo.set_ValorInicio(this.Saldos.First<Saldo>().get_ValorInicio());
					saldo.set_DataInicio(this.Saldos.First<Saldo>().get_DataInicio());
					saldo.set_DataFinal(new DateTime?(Funcoes.GetNetworkTime()));
					Saldo saldo1 = saldo;
					saldo1 = await this._bancosContasServico.FecharSaldo(saldo1);
					decimal? valorFinal = saldo1.get_ValorFinal();
					decimal num = new decimal();
					if ((valorFinal.GetValueOrDefault() < num) & valorFinal.HasValue)
					{
						this.CorDoSaldo = new SolidColorBrush(Colors.Red);
					}
					valorFinal = saldo1.get_ValorFinal();
					this.SaldoAtual = string.Format("SALDO: {0:c}", Math.Round(valorFinal.GetValueOrDefault(), 2));
				}
			}
		}

		public async void Excluir()
		{
			if (this.SelectedBancosContas != null && this.SelectedBancosContas.get_Id() != 0)
			{
				if (await (new BaseServico()).BancosContasUtilizado(this.SelectedBancosContas.get_Id()))
				{
					await base.ShowMessage("NÃO PODE SER EXCLUÍDO POIS ESTÁ SENDO UTILIZADO EM UM LANÇAMENTO.", "OK", "", false);
				}
				else if (await base.ShowMessage(string.Concat("DESEJA REALMENTE EXCLUIR A CONTA ", this.SelectedBancosContas.get_Descricao(), " PERMANENTEMENTE?"), "SIM", "NÃO", false))
				{
					base.Loading(true);
					if (await this._bancosContasServico.Delete(this.SelectedBancosContas))
					{
						await this.SelecionaBancosDeContas();
						base.Loading(false);
						base.ToggleSnackBar("CONTA EXCLUÍDA COM SUCESSO", true);
					}
					else
					{
						base.Loading(false);
					}
				}
			}
		}

		public async void ExcluirSaldo()
		{
			if (this.SelectedSaldo != null && this.SelectedSaldo.get_Id() != 0)
			{
				if (this.Saldos.Count <= 1)
				{
					await base.ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO INICIAL DA CONTA.", "OK", "", false);
				}
				else if (await base.ShowMessage("DESEJA REALMENTE EXCLUIR O SALDO PERMANENTEMENTE?", "SIM", "NÃO", false))
				{
					base.Loading(true);
					Saldo saldo = this.Saldos.FirstOrDefault<Saldo>((Saldo x) => {
						DateTime? dataFinal = x.get_DataFinal();
						DateTime? dataInicio = this.SelectedSaldo.get_DataInicio();
						if (dataFinal.HasValue != dataInicio.HasValue)
						{
							return false;
						}
						if (!dataFinal.HasValue)
						{
							return true;
						}
						return dataFinal.GetValueOrDefault() == dataInicio.GetValueOrDefault();
					});
					if (saldo != null)
					{
						saldo.set_DataFinal(null);
						saldo.set_ValorFinal(null);
						await this._bancosContasServico.Save(saldo);
						if (!this._bancosContasServico.Sucesso)
						{
							base.Loading(false);
						}
						else if (await this._bancosContasServico.DeleteSaldo(this.SelectedSaldo))
						{
							this.CarregarSaldos(this.SelectedBancosContas);
							base.Loading(false);
							base.ToggleSnackBar("SALDO EXCLUÍDO COM SUCESSO", true);
							base.Loading(false);
						}
						else
						{
							base.Loading(false);
						}
					}
					else
					{
						base.Loading(false);
						await base.ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO DA CONTA.", "OK", "", false);
					}
				}
			}
		}

		public async Task FecharSaldo()
		{
			this.SelectedSaldo = await this._bancosContasServico.Save(this.SelectedSaldo);
			if (this._bancosContasServico.Sucesso)
			{
				DateTime? dataFinal = this.SelectedSaldo.get_DataFinal();
				if (dataFinal.HasValue)
				{
					decimal? valorFinal = this.SelectedSaldo.get_ValorFinal();
					if (valorFinal.HasValue)
					{
						Saldo saldo = new Saldo();
						saldo.set_Conta(this.SelectedSaldo.get_Conta());
						dataFinal = null;
						saldo.set_DataFinal(dataFinal);
						dataFinal = this.SelectedSaldo.get_DataFinal();
						saldo.set_DataInicio(new DateTime?(dataFinal.Value));
						valorFinal = null;
						saldo.set_ValorFinal(valorFinal);
						valorFinal = this.SelectedSaldo.get_ValorFinal();
						saldo.set_ValorInicio(valorFinal.Value);
						await this._bancosContasServico.Save(saldo);
						if (!this._bancosContasServico.Sucesso)
						{
							return;
						}
					}
				}
				this.CarregarSaldos(this.SelectedBancosContas);
				base.ToggleSnackBar("SALDO FECHADO COM SUCESSO", true);
			}
		}

		internal async Task<List<Gestor.Model.Domain.Financeiro.BancosContas>> Filtrar(string value)
		{
			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas = await Task.Run<List<Gestor.Model.Domain.Financeiro.BancosContas>>(() => this.FiltrarBancosContas(value));
			return bancosContas;
		}

		public List<Gestor.Model.Domain.Financeiro.BancosContas> FiltrarBancosContas(string filter)
		{
			this.BancosContasFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(this.BancosContas) : new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(
				from x in this.BancosContas
				where Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Descricao().Trim()).ToUpper().Contains(Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(filter))
				orderby x.get_Ativo() descending, x.get_Descricao()
				select x));
			return this.BancosContasFiltrados.ToList<Gestor.Model.Domain.Financeiro.BancosContas>();
		}

		public void Incluir()
		{
			this._ultimoId = this.SelectedBancosContas.get_Id();
			this.DataAbertura = null;
			this.ValorAbertura = new decimal?(new decimal());
			this.SaldoAtual = "";
			Gestor.Model.Domain.Financeiro.BancosContas bancosConta = new Gestor.Model.Domain.Financeiro.BancosContas();
			bancosConta.set_Ativo(true);
			this.SelectedBancosContas = bancosConta;
			this.Saldos = new ObservableCollection<Saldo>();
			this.SelectedSaldo = null;
			base.Alterar(true);
		}

		public async Task<List<KeyValuePair<string, string>>> Salvar()
		{
			List<KeyValuePair<string, string>> keyValuePairs;
			Gestor.Model.Domain.Financeiro.BancosContas bancosConta;
			List<KeyValuePair<string, string>> keyValuePairs1 = this.SelectedBancosContas.Validate();
			keyValuePairs1.AddRange(this.Validate());
			if (keyValuePairs1.Count <= 0)
			{
				bancosConta = await this._bancosContasServico.Save(this.SelectedBancosContas);
				if (this._bancosContasServico.Sucesso)
				{
					if (this.SelectedBancosContas.get_Id() == 0 && this.DataAbertura.HasValue && this.ValorAbertura.HasValue)
					{
						Saldo saldo = new Saldo();
						saldo.set_Conta(bancosConta);
						saldo.set_DataInicio(new DateTime?(this.DataAbertura.Value));
						saldo.set_ValorInicio(this.ValorAbertura.Value);
						await this._bancosContasServico.Save(saldo);
						if (!this._bancosContasServico.Sucesso)
						{
							keyValuePairs = null;
							bancosConta = null;
							return keyValuePairs;
						}
					}
					await this.SelecionaBancosDeContas();
					this.SelecionaBancosContas(bancosConta);
					Recursos.BancosContas = this.BancosContas;
					base.Alterar(false);
					base.ToggleSnackBar("CONTA SALVA COM SUCESSO", true);
					keyValuePairs = null;
				}
				else
				{
					keyValuePairs = null;
				}
			}
			else
			{
				keyValuePairs = keyValuePairs1;
			}
			bancosConta = null;
			return keyValuePairs;
		}

		private async void Seleciona()
		{
			base.Loading(true);
			await base.PermissaoTela(26);
			await this.SelecionaBancosDeContas();
			base.Loading(false);
		}

		public void SelecionaBancosContas(Gestor.Model.Domain.Financeiro.BancosContas bancosContas)
		{
			base.Loading(true);
			this.SelectedBancosContas = this.BancosContasFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.BancosContas>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == bancosContas.get_Id());
			base.Loading(false);
		}

		private async Task SelecionaBancosDeContas()
		{
			base.Loading(true);
			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas = await this._bancosContasServico.BuscarBancos();
			BancosContasViewModel list = this;
			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas1 = bancosContas;
			IOrderedEnumerable<Gestor.Model.Domain.Financeiro.BancosContas> ativo = 
				from x in bancosContas1
				orderby x.get_Ativo() descending
				select x;
			list.BancosContas = ativo.ThenBy<Gestor.Model.Domain.Financeiro.BancosContas, string>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Descricao()).ToList<Gestor.Model.Domain.Financeiro.BancosContas>();
			this.BancosContasFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(this.BancosContas);
			if (this.BancosContasFiltrados.Count <= 0)
			{
				this.SelectedBancosContas = new Gestor.Model.Domain.Financeiro.BancosContas();
				this.Saldos = new ObservableCollection<Saldo>();
				this.DataAbertura = null;
				this.ValorAbertura = new decimal?(new decimal());
				this.SaldoAtual = "";
				base.Alterar(false);
				base.EnableMenu = false;
			}
			else
			{
				this.SelecionaBancosContas(this.BancosContasFiltrados.First<Gestor.Model.Domain.Financeiro.BancosContas>());
			}
			Recursos.BancosContas = bancosContas;
			base.Loading(false);
		}

		private async void UltimoSladoNaoAberto()
		{
			Saldo saldo = this.Saldos.ToList<Saldo>().Find((Saldo x) => {
				DateTime? dataInicio = x.get_DataInicio();
				DateTime? nullable = this.Saldos.Max<Saldo, DateTime?>((Saldo r) => r.get_DataInicio());
				if (dataInicio.HasValue != nullable.HasValue)
				{
					return false;
				}
				if (!dataInicio.HasValue)
				{
					return true;
				}
				return dataInicio.GetValueOrDefault() == nullable.GetValueOrDefault();
			});
			DateTime? dataFinal = saldo.get_DataFinal();
			bool hasValue = dataFinal.HasValue;
			if (hasValue)
			{
				hasValue = await base.ShowMessage("O ÚLTIMO SALDO NÃO ESTÁ ABERTO. DESEJA ABRÍ-LO AGORA?", "SIM", "NÃO", false);
			}
			if (hasValue)
			{
				dataFinal = null;
				saldo.set_DataFinal(dataFinal);
				saldo.set_ValorFinal(null);
				this.SelectedSaldo = await this._bancosContasServico.Save(saldo);
				this.SelectedBancosContas = this.SelectedBancosContas;
			}
			saldo = null;
		}

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