using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using Assinador.Infrastructure.Helpers;
using ClosedXML.Excel;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Financeiro;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Validation;
using Gestor.Model.Common;
using Gestor.Model.Domain.Configuracoes;
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 FornecedorViewModel : BaseFinanceiroViewModel
{
	private readonly FornecedorServico _servico;

	private List<Planos> _planos;

	private ObservableCollection<Planos> _planosFiltrados;

	private List<BancosContas> _contas;

	private ObservableCollection<BancosContas> _contasFiltradas;

	private List<Centro> _centros;

	private ObservableCollection<Centro> _centrosFiltrados;

	private ObservableCollection<Fornecedor> _fornecedorFiltrados = new ObservableCollection<Fornecedor>();

	private bool _isExpanded;

	private Fornecedor _selectedFornecedor;

	private string _anotacoes;

	private long _ultimoId;

	public Fornecedor CancelProduto;

	public List<Planos> Planos
	{
		get
		{
			return _planos;
		}
		set
		{
			_planos = value;
			OnPropertyChanged("Planos");
		}
	}

	public ObservableCollection<Planos> PlanosFiltrados
	{
		get
		{
			return _planosFiltrados;
		}
		set
		{
			_planosFiltrados = value;
			OnPropertyChanged("PlanosFiltrados");
		}
	}

	public List<BancosContas> Contas
	{
		get
		{
			return _contas;
		}
		set
		{
			_contas = value;
			OnPropertyChanged("Contas");
		}
	}

	public ObservableCollection<BancosContas> ContasFiltradas
	{
		get
		{
			return _contasFiltradas;
		}
		set
		{
			_contasFiltradas = value;
			OnPropertyChanged("ContasFiltradas");
		}
	}

	public List<Centro> Centros
	{
		get
		{
			return _centros;
		}
		set
		{
			_centros = value;
			OnPropertyChanged("Centros");
		}
	}

	public ObservableCollection<Centro> CentrosFiltrados
	{
		get
		{
			return _centrosFiltrados;
		}
		set
		{
			_centrosFiltrados = value;
			OnPropertyChanged("CentrosFiltrados");
		}
	}

	public ObservableCollection<Fornecedor> FornecedorFiltrados
	{
		get
		{
			return _fornecedorFiltrados;
		}
		set
		{
			_fornecedorFiltrados = value;
			IsExpanded = value != null && value.Count > 0;
			OnPropertyChanged("FornecedorFiltrados");
		}
	}

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

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

	public Fornecedor SelectedFornecedor
	{
		get
		{
			return _selectedFornecedor;
		}
		set
		{
			_selectedFornecedor = value;
			VerificarEnables((value != null) ? new long?(value.Id) : null);
			Anotacoes = string.Empty;
			_ultimoId = ((value != null && value.Id > 0) ? value.Id : _ultimoId);
			OnPropertyChanged("SelectedFornecedor");
		}
	}

	public string Anotacoes
	{
		get
		{
			return _anotacoes;
		}
		set
		{
			_anotacoes = value;
			OnPropertyChanged("Anotacoes");
		}
	}

	public FornecedorViewModel()
	{
		_servico = new FornecedorServico();
		base.EnableMenu = true;
		BuscaIncial();
	}

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

	public List<Fornecedor> FiltrarFornecedor(string filter)
	{
		FornecedorFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Fornecedor>(Fornecedor) : new ObservableCollection<Fornecedor>(from x in Fornecedor
			where ValidationHelper.RemoveDiacritics(x.Nome.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter)) || (x.Documento != null && ValidationHelper.RemoveDiacritics(x.Documento.Trim()).Contains(filter)) || (x.Telefone1 != null && ValidationHelper.RemoveDiacritics(x.Telefone1.Trim()).Contains(filter)) || (x.Telefone2 != null && ValidationHelper.RemoveDiacritics(x.Telefone2.Trim()).Contains(filter)) || (x.Email != null && ValidationHelper.RemoveDiacritics(x.Email.Trim()).Contains(filter))
			orderby x.Nome descending
			select x));
		if (FornecedorFiltrados.Count == 1)
		{
			SelectedFornecedor = FornecedorFiltrados.First();
		}
		return FornecedorFiltrados.ToList();
	}

	private async void BuscaIncial()
	{
		Loading(isLoading: true);
		await PermissaoTela((TipoTela)24);
		Planos = await new PlanoServico().BuscarPlanos();
		PlanosFiltrados = new ObservableCollection<Planos>(from x in Planos
			where x.Ativo
			orderby x.Descricao
			select x);
		Contas = await new BancosContasServico().BuscarBancos();
		ContasFiltradas = new ObservableCollection<BancosContas>(from x in Contas
			where x.Ativo
			orderby x.Descricao
			select x);
		Centros = await new CentroServico().BuscarCentros();
		CentrosFiltrados = new ObservableCollection<Centro>(from x in Centros
			where x.Ativo
			orderby x.Descricao
			select x);
		await SelecionaFornecedor();
		SelectedFornecedor = FornecedorFiltrados.FirstOrDefault();
		Loading(isLoading: false);
	}

	private async Task SelecionaFornecedor()
	{
		Fornecedor = await _servico.BuscarFornecedores();
		FornecedorFiltrados = new ObservableCollection<Fornecedor>(Fornecedor.OrderBy((Fornecedor x) => x.Nome));
	}

	public void Incluir()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected O, but got Unknown
		Fornecedor selectedFornecedor = SelectedFornecedor;
		_ultimoId = ((selectedFornecedor != null) ? selectedFornecedor.Id : 0);
		SelectedFornecedor = new Fornecedor
		{
			IdEmpresa = 1L,
			Ativo = true
		};
		Alterar(alterar: true);
	}

	public async void CancelarAlteracao()
	{
		Loading(isLoading: true);
		Alterar(alterar: false);
		if (SelectedFornecedor.Id > 0)
		{
			await SelecionaFornecedor();
		}
		SelectedFornecedor = ((IEnumerable<Fornecedor>)FornecedorFiltrados).FirstOrDefault((Func<Fornecedor, bool>)((Fornecedor x) => x.Id == _ultimoId));
		Loading(isLoading: false);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar()
	{
		List<KeyValuePair<string, string>> erros = SelectedFornecedor.Validate();
		List<KeyValuePair<string, string>> list = erros;
		list.AddRange(await Validate());
		if (erros.Count > 0)
		{
			return erros;
		}
		if (!SelectedFornecedor.TipoPagamento.HasValue)
		{
			SelectedFornecedor.TipoPagamento = (TipoPagamento)12;
		}
		if (!string.IsNullOrWhiteSpace(Anotacoes))
		{
			SelectedFornecedor.Observacao = $"{Recursos.Usuario.Nome}, ID: {((DomainBase)Recursos.Usuario).Id}, {Funcoes.GetNetworkTime():g}{Environment.NewLine}{Anotacoes}{Environment.NewLine}{Environment.NewLine}{SelectedFornecedor.Observacao}";
		}
		Fornecedor fornecedor = await _servico.Save(SelectedFornecedor);
		if (!_servico.Sucesso)
		{
			return null;
		}
		await SelecionaFornecedor();
		SelectedFornecedor = FornecedorFiltrados.First((Fornecedor x) => x.Id == fornecedor.Id);
		ToggleSnackBar("FORNECEDOR SALVO COM SUCESSO");
		Alterar(alterar: false);
		return null;
	}

	public async Task<List<KeyValuePair<string, string>>> Validate()
	{
		List<KeyValuePair<string, string>> errors = ValidationHelper.AddValue();
		if (!string.IsNullOrWhiteSpace(SelectedFornecedor.Documento))
		{
			List<Fornecedor> list = (await _servico.BuscarFornecedores()).Where((Fornecedor x) => x.Id != SelectedFornecedor.Id && ValidationHelper.DocumentoFornecedor(x.Documento) == ValidationHelper.DocumentoFornecedor(SelectedFornecedor.Documento)).ToList();
			if (list.Count > 0)
			{
				ValidationHelper.AddValue<string, string>(errors, "DOCUMENTO", "DOCUMENTO JÁ CADASTRADO PARA OUTROS FORNECEDORES " + string.Join(" | ", list.Select((Fornecedor x) => x.Nome)), true);
			}
		}
		return errors;
	}

	public async Task Delete()
	{
		if (SelectedFornecedor != null && SelectedFornecedor.Id != 0L && await ShowMessage("DESEJA REALMENTE EXCLUIR O FORNECEDOR " + SelectedFornecedor.Nome + "?", "SIM", "NÃO"))
		{
			Loading(isLoading: true);
			if (await new FinanceiroServico().TemLancamentosPorFornecedor(SelectedFornecedor.Id))
			{
				await ShowMessage("IMPOSSÍVEL REAIZAR A EXCLUSÃO POIS EXISTEM LANCAMENTOS PARA ESSE FORNECEDOR. PROCESSO INTERROMPIDO");
				Loading(isLoading: false);
				return;
			}
			if (!(await _servico.Delete(SelectedFornecedor)))
			{
				Loading(isLoading: false);
				return;
			}
			await SelecionaFornecedor();
			SelectedFornecedor = FornecedorFiltrados.FirstOrDefault();
			ToggleSnackBar("FORNECEDOR EXCLUÍDO COM SUCESSO");
			Loading(isLoading: false);
		}
	}

	public void Copiar(Cliente cliente)
	{
		if (SelectedFornecedor == null)
		{
			Incluir();
		}
		SelectedFornecedor.Nome = cliente.Nome;
		SelectedFornecedor.Documento = cliente.Documento;
		Fornecedor selectedFornecedor = SelectedFornecedor;
		object cep;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			cep = null;
		}
		else
		{
			ClienteEndereco obj = cliente.Enderecos.First();
			cep = ((obj == null) ? null : ((EnderecoBase)obj).Cep?.Trim());
		}
		((EnderecoBase)selectedFornecedor).Cep = (string)cep;
		Fornecedor selectedFornecedor2 = SelectedFornecedor;
		object endereco;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			endereco = null;
		}
		else
		{
			ClienteEndereco obj2 = cliente.Enderecos.First();
			endereco = ((obj2 == null) ? null : ((EnderecoBase)obj2).Endereco?.Trim());
		}
		((EnderecoBase)selectedFornecedor2).Endereco = (string)endereco;
		Fornecedor selectedFornecedor3 = SelectedFornecedor;
		object numero;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			numero = null;
		}
		else
		{
			ClienteEndereco obj3 = cliente.Enderecos.First();
			numero = ((obj3 == null) ? null : ((EnderecoBase)obj3).Numero?.Trim());
		}
		((EnderecoBase)selectedFornecedor3).Numero = (string)numero;
		Fornecedor selectedFornecedor4 = SelectedFornecedor;
		object complemento;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			complemento = null;
		}
		else
		{
			ClienteEndereco obj4 = cliente.Enderecos.First();
			complemento = ((obj4 == null) ? null : ((EnderecoBase)obj4).Complemento?.Trim());
		}
		((EnderecoBase)selectedFornecedor4).Complemento = (string)complemento;
		Fornecedor selectedFornecedor5 = SelectedFornecedor;
		object bairro;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			bairro = null;
		}
		else
		{
			ClienteEndereco obj5 = cliente.Enderecos.First();
			bairro = ((obj5 == null) ? null : ((EnderecoBase)obj5).Bairro?.Trim());
		}
		((EnderecoBase)selectedFornecedor5).Bairro = (string)bairro;
		Fornecedor selectedFornecedor6 = SelectedFornecedor;
		object cidade;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			cidade = null;
		}
		else
		{
			ClienteEndereco obj6 = cliente.Enderecos.First();
			cidade = ((obj6 == null) ? null : ((EnderecoBase)obj6).Cidade?.Trim());
		}
		((EnderecoBase)selectedFornecedor6).Cidade = (string)cidade;
		Fornecedor selectedFornecedor7 = SelectedFornecedor;
		object estado;
		if (cliente.Enderecos == null || !cliente.Enderecos.Any())
		{
			estado = null;
		}
		else
		{
			ClienteEndereco obj7 = cliente.Enderecos.First();
			estado = ((obj7 == null) ? null : ((EnderecoBase)obj7).Estado?.Trim());
		}
		((EnderecoBase)selectedFornecedor7).Estado = (string)estado;
		SelectedFornecedor.TipoTelefone1 = ((cliente.Telefones != null && cliente.Telefones.Any()) ? ((TelefoneBase)cliente.Telefones.First()).Tipo : null);
		SelectedFornecedor.Prefixo1 = ((cliente.Telefones == null || !cliente.Telefones.Any()) ? null : ((TelefoneBase)cliente.Telefones.First()).Prefixo?.Trim());
		SelectedFornecedor.Telefone1 = ((cliente.Telefones == null || !cliente.Telefones.Any()) ? null : ((TelefoneBase)cliente.Telefones.First()).Numero?.Trim());
		SelectedFornecedor.TipoTelefone2 = ((cliente.Telefones != null && cliente.Telefones.Any() && cliente.Telefones.Count > 2) ? ((TelefoneBase)cliente.Telefones[1]).Tipo : null);
		SelectedFornecedor.Prefixo2 = ((cliente.Telefones == null || cliente.Telefones.Count <= 2) ? null : ((TelefoneBase)cliente.Telefones[1]).Prefixo?.Trim());
		SelectedFornecedor.Telefone2 = ((cliente.Telefones == null || cliente.Telefones.Count <= 2) ? null : ((TelefoneBase)cliente.Telefones[1]).Numero?.Trim());
		SelectedFornecedor.Email = ((cliente.Emails == null || !cliente.Emails.Any() || cliente.Emails.Count <= 0) ? null : ((EmailBase)cliente.Emails.First()).Email?.Trim());
		OnPropertyChanged("SelectedFornecedor");
	}

	public async void Excel()
	{
		XLWorkbook xlWorkbook = new XLWorkbook();
		string nome = "RELAÓRIO DE FORNECEDOR";
		xlWorkbook = await Funcoes.GerarXls(xlWorkbook, nome, FornecedorFiltrados.ToList());
		string text = "";
		string text2;
		if (Recursos.Configuracoes.Any((ConfiguracaoSistema x) => (int)x.Configuracao == 41))
		{
			FolderBrowserDialog val = new FolderBrowserDialog();
			try
			{
				if (1 != (int)((CommonDialog)val).ShowDialog())
				{
					return;
				}
				text = val.SelectedPath + "\\";
				Directory.CreateDirectory(text);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			text2 = text + nome + " " + Functions.GetNetworkTime().Date.ToShortDateString().Replace("/", "") + ".xlsx";
		}
		else
		{
			text = Path.GetTempPath();
			text2 = $"{text}{Guid.NewGuid()}.xlsx";
		}
		xlWorkbook.SaveAs(text2);
		Process.Start(text2);
	}

	public async void Imprimir()
	{
		await ImprimirFornecedor(FornecedorFiltrados.ToList());
	}
}