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

namespace Gestor.Application.ViewModels.Ferramentas;

public class CadastroEmailViewModel : BaseSegurosViewModel
{
	private readonly EmailServico _servico;

	public Credencial CancelCredencial;

	private Credencial _selectedCredencial;

	private ObservableCollection<Credencial> _credenciaisFiltrados = new ObservableCollection<Credencial>();

	private bool _isExpanded;

	public Credencial SelectedCredencial
	{
		get
		{
			return _selectedCredencial;
		}
		set
		{
			_selectedCredencial = value;
			WorkOnSelectedCredencial(value);
			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
			OnPropertyChanged("SelectedCredencial");
		}
	}

	public ObservableCollection<Credencial> CredenciaisFiltrados
	{
		get
		{
			return _credenciaisFiltrados;
		}
		set
		{
			_credenciaisFiltrados = value;
			IsExpanded = value != null && value.Count > 0;
			OnPropertyChanged("CredenciaisFiltrados");
		}
	}

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

	public List<Credencial> Credenciais { get; set; }

	public CadastroEmailViewModel()
	{
		_servico = new EmailServico();
		base.EnableMenu = true;
		Seleciona();
	}

	public void Incluir()
	{
		//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_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		SelectedCredencial = new Credencial
		{
			IdEmpresa = Recursos.Usuario.IdEmpresa,
			IdUsuario = ((DomainBase)Recursos.Usuario).Id
		};
		Alterar(alterar: true);
	}

	public async Task CancelarAlteracao()
	{
		await CarregarCredenciais();
		if (CredenciaisFiltrados.Any())
		{
			Credencial cancelCredencial = CancelCredencial;
			long id = ((cancelCredencial != null) ? ((DomainBase)cancelCredencial).Id : 0);
			SelectedCredencial = ((IEnumerable<Credencial>)CredenciaisFiltrados).FirstOrDefault((Func<Credencial, bool>)((Credencial x) => ((DomainBase)x).Id == id));
		}
		else
		{
			SelectedCredencial = new Credencial();
			Alterar(alterar: false);
			base.EnableMenu = false;
		}
		Alterar(alterar: false);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar()
	{
		List<KeyValuePair<string, string>> list = SelectedCredencial.Validate();
		list.AddRange(Validate());
		if (list.Count > 0)
		{
			return list;
		}
		SelectedCredencial.Assinatura = SelectedCredencial.Assinatura.GetBody();
		SelectedCredencial.Cabecalho = SelectedCredencial.Cabecalho.GetBody();
		if (SelectedCredencial.Senha == null)
		{
			SelectedCredencial.Senha = "";
		}
		string acao = ((((DomainBase)SelectedCredencial).Id == 0L) ? "INCLUIU" : "ALTEROU");
		Credencial value = await _servico.Save(SelectedCredencial);
		if (!_servico.Sucesso)
		{
			return null;
		}
		RegistrarAcao(acao + " E-MAIL \"" + value.Email + "\"", ((DomainBase)value).Id, (TipoTela)17, $"E-MAIL: {value.Email}\nID: {((DomainBase)value).Id}");
		await CarregarCredenciais();
		SelectedCredencial = ((IEnumerable<Credencial>)CredenciaisFiltrados).FirstOrDefault((Func<Credencial, bool>)((Credencial x) => ((DomainBase)x).Id == ((DomainBase)value).Id));
		Alterar(alterar: false);
		ToggleSnackBar("E-MAIL SALVO COM SUCESSO");
		return null;
	}

	public async Task Excluir()
	{
		if (SelectedCredencial == null || ((DomainBase)SelectedCredencial).Id == 0L || !(await ShowMessage("DESEJA REALMENTE EXCLUIR O E-MAIL " + SelectedCredencial.Email + " PERMANENTEMENTE?", "SIM", "NÃO")))
		{
			return;
		}
		Loading(isLoading: true);
		if (!(await _servico.Delete(SelectedCredencial)))
		{
			Loading(isLoading: false);
			return;
		}
		RegistrarAcao("EXCLUIU E-MAIL \"" + SelectedCredencial.Email + "\"", ((DomainBase)SelectedCredencial).Id, (TipoTela)17, $"E-MAIL: {SelectedCredencial.Email}\nID: {((DomainBase)SelectedCredencial).Id}");
		await CarregarCredenciais();
		if (CredenciaisFiltrados.Any())
		{
			SelectedCredencial = CredenciaisFiltrados.FirstOrDefault();
		}
		else
		{
			SelectedCredencial = new Credencial();
			Alterar(alterar: false);
			base.EnableMenu = false;
		}
		Loading(isLoading: false);
		ToggleSnackBar("E-MAIL EXCLUÍDO COM SUCESSO");
	}

	public List<KeyValuePair<string, string>> Validate()
	{
		List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
		if (Credenciais.Any((Credencial x) => ((DomainBase)x).Id != ((DomainBase)SelectedCredencial).Id && x.Descricao == SelectedCredencial.Descricao))
		{
			list.Add(new KeyValuePair<string, string>("Descricao", "UM E-MAIL COM A MESMA DESCRIÇÃO/NOME JÁ EXISTE."));
		}
		return list;
	}

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

	public async Task SelecionaCredenciais()
	{
		Loading(isLoading: true);
		await CarregarCredenciais();
		SelectedCredencial = CredenciaisFiltrados.FirstOrDefault();
		Loading(isLoading: false);
	}

	private async Task CarregarCredenciais()
	{
		List<Credencial> list = await new BaseServico().BuscarCredenciais();
		foreach (Credencial item in list)
		{
			if (item.Email.Contains("@gmail.com"))
			{
				item.Tipo = (TipoEmail)1;
			}
			item.Senha = EncryptionHelper.Decrypt(item.Senha);
		}
		Credenciais = list.OrderBy((Credencial x) => x.Descricao).ToList();
		CredenciaisFiltrados = new ObservableCollection<Credencial>(Credenciais);
	}

	private void WorkOnSelectedCredencial(Credencial value, bool registrar = true)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Invalid comparison between Unknown and I4
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		CancelCredencial = (Credencial)((value == null || ((DomainBase)value).Id == 0L) ? ((object)CancelCredencial) : ((object)(Credencial)((DomainBase)value).Clone()));
		if (value == null || ((DomainBase)value).Id == 0L || (LastAccessId == ((DomainBase)value).Id && (int)LastAccessTela == 17))
		{
			return;
		}
		if (registrar)
		{
			RegistrarAcao("ACESSOU E-MAIL \"" + value.Email + "\"", ((DomainBase)value).Id, (TipoTela)17, $"ID E-MAIL: {((DomainBase)value).Id}");
		}
		LastAccessId = ((DomainBase)value).Id;
		LastAccessTela = (TipoTela)17;
		Credencial selectedCredencial = SelectedCredencial;
		if (((selectedCredencial != null) ? new long?(((DomainBase)selectedCredencial).Id) : null) != ((DomainBase)value).Id)
		{
			SelectedCredencial = ((IEnumerable<Credencial>)CredenciaisFiltrados).FirstOrDefault((Func<Credencial, bool>)((Credencial x) => ((DomainBase)x).Id == ((DomainBase)value).Id));
		}
	}

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

	public List<Credencial> FiltrarCredenciais(string filter)
	{
		CredenciaisFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Credencial>(Credenciais) : new ObservableCollection<Credencial>(Credenciais.Where((Credencial x) => ValidationHelper.RemoveDiacritics(x.Descricao.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter)))));
		SelectedCredencial = CredenciaisFiltrados.FirstOrDefault();
		return CredenciaisFiltrados.ToList();
	}

	public void SelecionaCredencial(Credencial credencial)
	{
		SelectedCredencial = CredenciaisFiltrados.First((Credencial x) => ((DomainBase)x).Id == ((DomainBase)credencial).Id);
	}

	public async Task<bool> EnviarTesteEmail()
	{
		if (SelectedCredencial == null)
		{
			await ShowMessage("NECESSÁRIO CRIAR UM E-MAIL DE ENVIO PARA PROSSEGUIR.");
			return false;
		}
		TipoEmail tipo = SelectedCredencial.Tipo;
		if ((int)tipo != 0)
		{
			if (tipo - 1 <= 1 && string.IsNullOrWhiteSpace(SelectedCredencial.Email))
			{
				await ShowMessage("NECESSÁRIO PREENCHER O E-MAIL PARA ENVIAR UM E-MAIL DE TESTE");
				return false;
			}
		}
		else if (string.IsNullOrWhiteSpace(SelectedCredencial.Email) || !SelectedCredencial.Porta.HasValue || string.IsNullOrWhiteSpace(SelectedCredencial.Dominio))
		{
			await ShowMessage("NECESSÁRIO PREENCHER O E-MAIL, PORTA E DOMÍNIO PARA ENVIAR UM E-MAIL DE TESTE");
			return false;
		}
		LogEnvio val = await new MailHelper().SendAsync(destinatario: new Destinatario
		{
			Assunto = "TESTE ENVIO E-MAIL",
			Corpo = "TESTE DE ENVIO DE E-MAIL",
			Email = SelectedCredencial.Email,
			Nome = SelectedCredencial.Descricao
		}, credencial: SelectedCredencial, filtro: null, maladireta: null, tela: (TipoTela)0);
		if (!val.Enviado)
		{
			await ShowMessage(val.Erro);
			return false;
		}
		return true;
	}
}