using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using Gestor.Application.Servicos.Ferramentas;
using Gestor.Application.Servicos.Generic;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Validation;
using Gestor.Model.Common;
using Gestor.Model.Domain.Ferramentas;
using Gestor.Model.Domain.Generic;

namespace Gestor.Application.ViewModels.Drawer;

public class AgendaViewModel : BaseSegurosViewModel
{
	private readonly AgendaServico _servico;

	private Agenda _selectedAgenda;

	private ObservableCollection<AgendaTelefone> _telefones = new ObservableCollection<AgendaTelefone>();

	private ObservableCollection<AgendaEmail> _emails = new ObservableCollection<AgendaEmail>();

	private long _ultimoId;

	public Agenda CancelAgenda;

	private ObservableCollection<Agenda> _agendasFiltradas = new ObservableCollection<Agenda>();

	private bool _carregando;

	public Agenda SelectedAgenda
	{
		get
		{
			return _selectedAgenda;
		}
		set
		{
			_selectedAgenda = value;
			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
			OnPropertyChanged("SelectedAgenda");
		}
	}

	public ObservableCollection<AgendaTelefone> Telefones
	{
		get
		{
			return _telefones;
		}
		set
		{
			_telefones = value;
			OnPropertyChanged("Telefones");
		}
	}

	public ObservableCollection<AgendaEmail> Emails
	{
		get
		{
			return _emails;
		}
		set
		{
			_emails = value;
			OnPropertyChanged("Emails");
		}
	}

	public ObservableCollection<Agenda> AgendasFiltradas
	{
		get
		{
			return _agendasFiltradas;
		}
		set
		{
			_agendasFiltradas = value;
			OnPropertyChanged("AgendasFiltradas");
		}
	}

	public List<Agenda> Agendas { get; set; }

	public bool Carregando
	{
		get
		{
			return _carregando;
		}
		set
		{
			_carregando = value;
			base.IsEnabled = !value;
			base.EnableMenu = !value;
			OnPropertyChanged("Carregando");
		}
	}

	public AgendaViewModel()
	{
		_servico = new AgendaServico();
		Seleciona();
	}

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

	private async Task SelecionaAgendas()
	{
		Carregando = true;
		Agendas = (await new BaseServico().BuscarAgendasAsync()).OrderBy((Agenda x) => x.Nome).ToList();
		AgendasFiltradas = new ObservableCollection<Agenda>(Agendas);
		SelectedAgenda = (Agenda)((AgendasFiltradas.Count > 0) ? ((object)AgendasFiltradas.First()) : ((object)new Agenda()));
		Carregando = false;
	}

	public void IncluirTelefone()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		if (SelectedAgenda != null)
		{
			if (Telefones == null)
			{
				Telefones = new ObservableCollection<AgendaTelefone>();
			}
			AgendaTelefone item = new AgendaTelefone
			{
				Agenda = SelectedAgenda,
				Tipo = (TipoTelefone)1
			};
			Telefones.Add(item);
			OnPropertyChanged("IncluirTelefone");
		}
	}

	public void ExcluirEmail(AgendaEmail email)
	{
		Emails.Remove(email);
	}

	public void IncluirEmail()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		if (SelectedAgenda != null)
		{
			if (Emails == null)
			{
				Emails = new ObservableCollection<AgendaEmail>();
			}
			AgendaEmail item = new AgendaEmail
			{
				Agenda = SelectedAgenda
			};
			Emails.Add(item);
			OnPropertyChanged("IncluirEmail");
		}
	}

	public void ExcluirTelefone(AgendaTelefone telefone)
	{
		Telefones.Remove(telefone);
	}

	public void Incluir()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Expected O, but got Unknown
		if (SelectedAgenda != null)
		{
			_ultimoId = ((DomainBase)SelectedAgenda).Id;
		}
		SelectedAgenda = new Agenda();
		Telefones = new ObservableCollection<AgendaTelefone>
		{
			new AgendaTelefone
			{
				Agenda = SelectedAgenda,
				Tipo = (TipoTelefone)1
			}
		};
		Emails = new ObservableCollection<AgendaEmail>
		{
			new AgendaEmail
			{
				Agenda = SelectedAgenda
			}
		};
		Alterar(alterar: true);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar()
	{
		List<KeyValuePair<string, string>> list = SelectedAgenda.Validate();
		List<AgendaTelefone> list2 = Telefones.Where((AgendaTelefone x) => !string.IsNullOrEmpty(((TelefoneBase)x).Numero)).ToList();
		List<AgendaEmail> list3 = Emails.Where((AgendaEmail x) => !string.IsNullOrEmpty(((EmailBase)x).Email)).ToList();
		foreach (AgendaTelefone item in list2)
		{
			list.AddRange(item.Validate());
		}
		foreach (AgendaEmail item2 in list3)
		{
			list.AddRange(item2.Validate());
		}
		if (list.Count > 0)
		{
			return list;
		}
		SelectedAgenda.Telefones = new ObservableCollection<AgendaTelefone>(list2);
		SelectedAgenda.Emails = new ObservableCollection<AgendaEmail>(list3);
		if (((DomainBase)SelectedAgenda).Id == 0L)
		{
			SelectedAgenda = await _servico.Save(SelectedAgenda);
			if (!_servico.Sucesso)
			{
				return null;
			}
			Telefones = new ObservableCollection<AgendaTelefone>(SelectedAgenda.Telefones);
			Emails = new ObservableCollection<AgendaEmail>(SelectedAgenda.Emails);
			Agendas.Add(SelectedAgenda);
			AgendasFiltradas.Insert((_ultimoId != 0L) ? AgendasFiltradas.IndexOf(AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == _ultimoId)) : 0, SelectedAgenda);
		}
		else
		{
			SelectedAgenda = await _servico.Save(SelectedAgenda);
			if (!_servico.Sucesso)
			{
				return null;
			}
			Telefones = new ObservableCollection<AgendaTelefone>(SelectedAgenda.Telefones);
			Emails = new ObservableCollection<AgendaEmail>(SelectedAgenda.Emails);
			DomainBase.Copy<Agenda, Agenda>(Agendas.First((Agenda x) => ((DomainBase)x).Id == ((DomainBase)SelectedAgenda).Id), SelectedAgenda);
			if (AgendasFiltradas.Count > 0 && AgendasFiltradas.Any((Agenda x) => ((DomainBase)x).Id == ((DomainBase)SelectedAgenda).Id))
			{
				DomainBase.Copy<Agenda, Agenda>(AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == ((DomainBase)SelectedAgenda).Id), SelectedAgenda);
			}
			else
			{
				AgendasFiltradas.Add(SelectedAgenda);
			}
		}
		AgendasFiltradas = new ObservableCollection<Agenda>(AgendasFiltradas);
		SelectedAgenda = AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == ((DomainBase)SelectedAgenda).Id);
		Alterar(alterar: false);
		return null;
	}

	public void CancelarAlteracao()
	{
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Expected O, but got Unknown
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Expected O, but got Unknown
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Expected O, but got Unknown
		Carregando = true;
		if (((DomainBase)SelectedAgenda).Id == 0L)
		{
			if (AgendasFiltradas.Count > 0 && AgendasFiltradas.Any((Agenda x) => ((DomainBase)x).Id == _ultimoId))
			{
				SelectedAgenda = AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == _ultimoId);
			}
			else
			{
				if (Agendas.Count <= 0 || !Agendas.Any((Agenda x) => ((DomainBase)x).Id == _ultimoId))
				{
					SelectedAgenda = new Agenda();
					Telefones = new ObservableCollection<AgendaTelefone>
					{
						new AgendaTelefone
						{
							Agenda = SelectedAgenda,
							Tipo = (TipoTelefone)1
						}
					};
					Emails = new ObservableCollection<AgendaEmail>
					{
						new AgendaEmail
						{
							Agenda = SelectedAgenda
						}
					};
					Alterar(alterar: false);
					Carregando = false;
					return;
				}
				AgendasFiltradas.Add(Agendas.First((Agenda x) => ((DomainBase)x).Id == _ultimoId));
				SelectedAgenda = AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == _ultimoId);
			}
		}
		else
		{
			DomainBase.Copy<Agenda, Agenda>(Agendas.First((Agenda x) => ((DomainBase)x).Id == ((DomainBase)CancelAgenda).Id), CancelAgenda);
			if (AgendasFiltradas.Count > 0 && AgendasFiltradas.Any((Agenda x) => ((DomainBase)x).Id == ((DomainBase)CancelAgenda).Id))
			{
				DomainBase.Copy<Agenda, Agenda>(AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == ((DomainBase)CancelAgenda).Id), CancelAgenda);
			}
			else
			{
				AgendasFiltradas.Add(CancelAgenda);
			}
			AgendasFiltradas = new ObservableCollection<Agenda>(AgendasFiltradas);
			SelectedAgenda = AgendasFiltradas.First((Agenda x) => ((DomainBase)x).Id == ((DomainBase)CancelAgenda).Id);
		}
		Alterar(alterar: false);
		Carregando = false;
	}

	public async Task<bool> Excluir()
	{
		if (SelectedAgenda == null || ((DomainBase)SelectedAgenda).Id == 0L)
		{
			return false;
		}
		if (!(await ShowMessage("DESEJA EXCLUIR?", "SIM", "NÃO")))
		{
			return false;
		}
		Carregando = true;
		if (!(await _servico.Delete(SelectedAgenda)))
		{
			Alterar(alterar: false);
			Carregando = false;
			return false;
		}
		int num = AgendasFiltradas.IndexOf(SelectedAgenda);
		Agendas.Remove(SelectedAgenda);
		AgendasFiltradas.Remove(SelectedAgenda);
		AgendasFiltradas = new ObservableCollection<Agenda>(AgendasFiltradas);
		if (AgendasFiltradas.Count > 0)
		{
			if (num >= AgendasFiltradas.Count)
			{
				await SelecionaAgenda(AgendasFiltradas.Last());
			}
			else
			{
				await SelecionaAgenda(AgendasFiltradas.ElementAt(num));
			}
		}
		else
		{
			SelectedAgenda = new Agenda();
			Telefones = new ObservableCollection<AgendaTelefone>();
			Emails = new ObservableCollection<AgendaEmail>();
			Alterar(alterar: false);
		}
		Carregando = false;
		return true;
	}

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

	public List<Agenda> FiltrarAgenda(string filter)
	{
		AgendasFiltradas = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Agenda>(Agendas) : new ObservableCollection<Agenda>(from x in Agendas
			where ValidationHelper.RemoveDiacritics(x.Nome.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter))
			orderby x.Nome
			select x));
		return AgendasFiltradas.ToList();
	}

	public async Task SelecionaAgenda(Agenda agenda = null)
	{
		Carregando = true;
		SelectedAgenda = ((agenda == null) ? AgendasFiltradas.FirstOrDefault() : ((IEnumerable<Agenda>)AgendasFiltradas).FirstOrDefault((Func<Agenda, bool>)((Agenda x) => ((DomainBase)x).Id == ((DomainBase)agenda).Id)));
		if (SelectedAgenda != null)
		{
			Emails = await _servico.BuscarEmailsAsync(((DomainBase)SelectedAgenda).Id);
			Telefones = await _servico.BuscarTelefonesAsync(((DomainBase)SelectedAgenda).Id);
		}
		else
		{
			Emails = null;
			Telefones = null;
		}
		Carregando = false;
	}
}