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

namespace Gestor.Application.ViewModels.Ferramentas;

public class EmpresaViewModel : BaseSegurosViewModel
{
	private readonly EmpresaServico _servico;

	public Empresa CancelEmpresa;

	private Empresa _selectedEmpresa = new Empresa();

	private string _logoLabel = "ANEXAR LOGOTIPO";

	private bool _passWordReadOnly;

	private bool _enableConsultaEspaco = true;

	private double _espaco;

	private string _senha;

	private string _confirmaSenha;

	private ObservableCollection<Empresa> _empresasFiltradas = new ObservableCollection<Empresa>();

	private bool _isExpanded;

	public ICommand ConsultarEspacoCommand { get; set; }

	public List<Empresa> Empresas { get; set; }

	public Empresa SelectedEmpresa
	{
		get
		{
			return _selectedEmpresa;
		}
		set
		{
			_selectedEmpresa = value;
			object senha;
			if (value == null)
			{
				senha = null;
			}
			else
			{
				string senhaAdmin = value.SenhaAdmin;
				senha = ((senhaAdmin != null) ? EncryptionHelper.Decrypt(senhaAdmin) : null);
			}
			Senha = (string)senha;
			ConfirmaSenha = string.Empty;
			WorkOnSelectedEmpresa(value);
			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
			OnPropertyChanged("SelectedEmpresa");
		}
	}

	public string LogoLabel
	{
		get
		{
			return _logoLabel;
		}
		set
		{
			_logoLabel = value;
			OnPropertyChanged("LogoLabel");
		}
	}

	public bool PassWordReadOnly
	{
		get
		{
			return _passWordReadOnly;
		}
		set
		{
			_passWordReadOnly = value && (Recursos.Usuario.Administrador || ((DomainBase)Recursos.Usuario).Id == 0);
			OnPropertyChanged("PassWordReadOnly");
		}
	}

	public bool EnableConsultaEspaco
	{
		get
		{
			return _enableConsultaEspaco;
		}
		set
		{
			_enableConsultaEspaco = value;
			OnPropertyChanged("EnableConsultaEspaco");
		}
	}

	public double Espaco
	{
		get
		{
			return _espaco;
		}
		set
		{
			_espaco = value;
			OnPropertyChanged("Espaco");
		}
	}

	public string Senha
	{
		get
		{
			return _senha;
		}
		set
		{
			_senha = value;
			OnPropertyChanged("Senha");
		}
	}

	public string ConfirmaSenha
	{
		get
		{
			return _confirmaSenha;
		}
		set
		{
			_confirmaSenha = value;
			OnPropertyChanged("ConfirmaSenha");
		}
	}

	public ObservableCollection<Empresa> EmpresasFiltradas
	{
		get
		{
			return _empresasFiltradas;
		}
		set
		{
			_empresasFiltradas = value;
			IsExpanded = value != null && value.Count > 0;
			OnPropertyChanged("EmpresasFiltradas");
		}
	}

	private Visibility _visualizacaoMatriz { get; set; } = (Visibility)2;


	public Visibility VisualizacaoMatriz
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _visualizacaoMatriz;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			_visualizacaoMatriz = value;
			OnPropertyChanged("VisualizacaoMatriz");
		}
	}

	private Visibility _confirmacaoSenha { get; set; } = (Visibility)2;


	public Visibility ConfirmacaoSenha
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _confirmacaoSenha;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			_confirmacaoSenha = value;
			OnPropertyChanged("ConfirmacaoSenha");
		}
	}

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

	public EmpresaViewModel()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		ConsultarEspacoCommand = new RelayCommand(async delegate
		{
			await ConsultaEspacoUsadoClienteInGb();
		});
		_servico = new EmpresaServico();
		base.EnableMenu = true;
		PassWordReadOnly = Recursos.Usuario.Administrador && base.EnableFields;
		Seleciona();
	}

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

	private async Task SelecionaEmpresas()
	{
		Loading(isLoading: true);
		Empresas = (from x in await new BaseServico().BuscarEmpresasAsync()
			where Recursos.Usuario.IdEmpresa == 1 || ((DomainBase)x).Id == Recursos.Usuario.IdEmpresa
			orderby x.Nome
			select x).ToList();
		EmpresasFiltradas = new ObservableCollection<Empresa>(Empresas);
		if (EmpresasFiltradas.Count > 0)
		{
			SelecionaEmpresa(EmpresasFiltradas.First());
		}
		else
		{
			SelectedEmpresa = new Empresa();
			Alterar(alterar: false);
			base.EnableMenu = false;
		}
		Loading(isLoading: false);
	}

	public void Incluir()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		Empresa selectedEmpresa = new Empresa();
		SelectedEmpresa = selectedEmpresa;
		Alterar(alterar: true);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar()
	{
		List<KeyValuePair<string, string>> list = SelectedEmpresa.Validate();
		if ((int)VisualizacaoMatriz != 2 && ConfirmaSenha != Senha)
		{
			list.Add(new KeyValuePair<string, string>("SenhaAdmin|SENHA ADM", "A SENHA E A CONFIRMAÇÃO DA SENHA DEVEM SER IGUAIS."));
		}
		if (list.Count > 0)
		{
			return list;
		}
		if (((DomainBase)SelectedEmpresa).Id == 1)
		{
			SelectedEmpresa.SenhaAdmin = EncryptionHelper.Encrypt(Senha);
		}
		string acao = ((((DomainBase)SelectedEmpresa).Id == 0L) ? "INCLUIU" : "ALTEROU");
		Empresa value = await _servico.Save(SelectedEmpresa);
		if (!_servico.Sucesso)
		{
			return null;
		}
		RegistrarAcao(acao + " EMPRESA \"" + value.Nome + "\"", ((DomainBase)value).Id, (TipoTela)18, $"EMPRESA \"{value.Nome}\", ID: {((DomainBase)value).Id}");
		if (Empresas.Any((Empresa x) => ((DomainBase)x).Id == ((DomainBase)value).Id))
		{
			DomainBase.Copy<Empresa, Empresa>(Empresas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)value).Id), value);
		}
		else
		{
			Empresas.Add(value);
		}
		if (EmpresasFiltradas.Any((Empresa x) => ((DomainBase)x).Id == ((DomainBase)value).Id))
		{
			DomainBase.Copy<Empresa, Empresa>(EmpresasFiltradas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)value).Id), value);
		}
		else
		{
			EmpresasFiltradas.Add(value);
		}
		EmpresasFiltradas = new ObservableCollection<Empresa>(EmpresasFiltradas);
		Recursos.Empresas = Empresas;
		WorkOnSelectedEmpresa(value, registrar: false);
		Alterar(alterar: false);
		ToggleSnackBar("EMPRESA SALVA COM SUCESSO");
		return null;
	}

	public void CancelarAlteracao()
	{
		if (CancelEmpresa != null && Empresas.Any((Empresa x) => ((DomainBase)x).Id == ((DomainBase)CancelEmpresa).Id))
		{
			DomainBase.Copy<Empresa, Empresa>(Empresas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)CancelEmpresa).Id), CancelEmpresa);
			if (EmpresasFiltradas.Count > 0 && EmpresasFiltradas.Any((Empresa x) => ((DomainBase)x).Id == ((DomainBase)CancelEmpresa).Id))
			{
				DomainBase.Copy<Empresa, Empresa>(EmpresasFiltradas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)CancelEmpresa).Id), CancelEmpresa);
			}
			else
			{
				EmpresasFiltradas.Add(CancelEmpresa);
			}
			EmpresasFiltradas = new ObservableCollection<Empresa>(EmpresasFiltradas);
			SelectedEmpresa = EmpresasFiltradas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)CancelEmpresa).Id);
		}
		else
		{
			Incluir();
		}
		Alterar(alterar: false);
	}

	private void WorkOnSelectedEmpresa(Empresa value, bool registrar = true)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Invalid comparison between Unknown and I4
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		CancelEmpresa = (Empresa)((value == null || ((DomainBase)value).Id == 0L) ? ((object)CancelEmpresa) : ((object)(Empresa)((DomainBase)value).Clone()));
		if (value == null || ((DomainBase)value).Id == 0L || (LastAccessId == ((DomainBase)value).Id && (int)LastAccessTela == 18))
		{
			return;
		}
		if (registrar)
		{
			RegistrarAcao("ACESSOU EMPRESA \"" + value.Nome + "\"", ((DomainBase)value).Id, (TipoTela)18, $"ID EMPRESA: {((DomainBase)value).Id}");
		}
		LastAccessId = ((DomainBase)value).Id;
		LastAccessTela = (TipoTela)18;
		Empresa selectedEmpresa = SelectedEmpresa;
		if (((selectedEmpresa != null) ? new long?(((DomainBase)selectedEmpresa).Id) : null) != ((DomainBase)value).Id)
		{
			SelectedEmpresa = ((IEnumerable<Empresa>)EmpresasFiltradas).FirstOrDefault((Func<Empresa, bool>)((Empresa x) => ((DomainBase)x).Id == ((DomainBase)value).Id));
		}
		Empresa selectedEmpresa2 = SelectedEmpresa;
		LogoLabel = ((((selectedEmpresa2 != null) ? selectedEmpresa2.Logo : null) == null) ? "ANEXAR LOGOTIPO" : "ALTERAR LOGOTIPO");
		VisualizacaoMatriz = (Visibility)((((DomainBase)SelectedEmpresa).Id != 1) ? 2 : 0);
	}

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

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

	public async void SelecionaEmpresa(Empresa empresa)
	{
		Empresa val = await _servico.BuscarEmpresaPorId(((DomainBase)empresa).Id);
		DomainBase.Copy<Empresa, Empresa>(EmpresasFiltradas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)empresa).Id), val);
		SelectedEmpresa = EmpresasFiltradas.First((Empresa x) => ((DomainBase)x).Id == ((DomainBase)empresa).Id);
	}

	public async Task AnexarLogo()
	{
		string text = "";
		OpenFileDialog val = new OpenFileDialog();
		try
		{
			val.Multiselect = false;
			((FileDialog)val).Filter = "Imagens|*.jpg;*.jpeg;*.png;";
			((FileDialog)val).InitialDirectory = Environment.SpecialFolder.Desktop.ToString();
			if (1 != (int)((CommonDialog)val).ShowDialog())
			{
				return;
			}
			text = ((FileDialog)val).FileName;
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
		try
		{
			using MemoryStream memoryStream = new MemoryStream(File.ReadAllBytes(text));
			byte[] array = new byte[memoryStream.Length];
			memoryStream.Position = 0L;
			memoryStream.Read(array, 0, array.Length);
			SelectedEmpresa.Logo = array;
		}
		catch (Exception)
		{
			await ShowMessage("NÃO FOI POSSÍVEL CARREGAR O ARQUIVO " + text + "." + Environment.NewLine + "O ARQUIVO ESTÁ INACESSÍVEL OU SENDO UTILIZADO POR OUTRO PROCESSO.");
		}
	}

	public async Task ConsultaEspacoUsadoClienteInGb()
	{
		EnableConsultaEspaco = false;
		Loading(isLoading: true);
		double espacoBanco = await _servico.ConsultaEspacoBancoInGb();
		double espacoStorageInGB = 0.0;
		if (Connection.ConnectionAddress.UsaAzureStorage)
		{
			double num = await Connection.EspacoUsadoAzureInBytes();
			if (num > 0.0)
			{
				espacoStorageInGB = num / 1024.0 / 1024.0 / 1024.0;
			}
		}
		Espaco = espacoBanco + espacoStorageInGB;
		if (Espaco == 0.0)
		{
			EnableConsultaEspaco = true;
		}
		Loading(isLoading: false);
	}
}