using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Media;
using ClosedXML.Excel;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Financeiro;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Helpers;
using Gestor.Model.Common;
using Gestor.Model.Domain.Configuracoes;
using Gestor.Model.Domain.Financeiro;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Relatorios;

namespace Gestor.Application.ViewModels.Financeiro;

public class ExtratoContaViewModel : BaseFinanceiroViewModel
{
	private Geometry _maximizeRestore = Geometry.Parse((string)Application.Current.Resources[(object)"Restore"]);

	private string _head;

	private readonly FinanceiroServico _servico;

	private ObservableCollection<BancosContas> _contas;

	private ObservableCollection<BancosContas> _contasFilter;

	private BancosContas _selectedConta;

	private DateTime? _inicio = new DateTime(Funcoes.GetNetworkTime().Date.Year, Funcoes.GetNetworkTime().Date.Month, 1);

	private DateTime? _fim = Funcoes.GetNetworkTime();

	private static ObservableCollection<string> _bancosContas = new ObservableCollection<string> { "TODOS", "ATIVOS", "INATIVOS" };

	private string _selectedBancosContas = "TODOS";

	private ObservableCollection<ExtratoConta> _extrato;

	private bool _saldoFinal;

	private bool _naoHaDados;

	public Geometry MaximizeRestore
	{
		get
		{
			return _maximizeRestore;
		}
		set
		{
			_maximizeRestore = value;
			OnPropertyChanged("MaximizeRestore");
		}
	}

	public string Head
	{
		get
		{
			return _head;
		}
		set
		{
			_head = value;
			OnPropertyChanged("Head");
		}
	}

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

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

	public BancosContas SelectedConta
	{
		get
		{
			return _selectedConta;
		}
		set
		{
			_selectedConta = value;
			OnPropertyChanged("SelectedConta");
		}
	}

	public DateTime? Inicio
	{
		get
		{
			return _inicio;
		}
		set
		{
			_inicio = value;
			OnPropertyChanged("Inicio");
		}
	}

	public DateTime? Fim
	{
		get
		{
			return _fim;
		}
		set
		{
			_fim = value;
			OnPropertyChanged("Fim");
		}
	}

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

	public string SelectedBancosContas
	{
		get
		{
			return _selectedBancosContas;
		}
		set
		{
			_selectedBancosContas = value;
			if (value == null || Contas == null || Contas.Count <= 0)
			{
				return;
			}
			switch (value)
			{
			case "TODOS":
				ContasFilter = Contas;
				break;
			case "ATIVOS":
				ContasFilter = new ObservableCollection<BancosContas>(Contas.Where((BancosContas x) => x.Ativo).ToList());
				break;
			case "INATIVOS":
				ContasFilter = new ObservableCollection<BancosContas>(Contas.Where((BancosContas x) => !x.Ativo).ToList());
				break;
			}
			OnPropertyChanged("SelectedBancosContas");
		}
	}

	public ObservableCollection<ExtratoConta> Extrato
	{
		get
		{
			return _extrato;
		}
		set
		{
			_extrato = value;
			NaoHaDados = value == null || value.Count == 0;
			OnPropertyChanged("Extrato");
		}
	}

	public bool SaldoFinal
	{
		get
		{
			return _saldoFinal;
		}
		set
		{
			_saldoFinal = value;
			OnPropertyChanged("SaldoFinal");
		}
	}

	public bool NaoHaDados
	{
		get
		{
			return _naoHaDados;
		}
		set
		{
			_naoHaDados = value;
			OnPropertyChanged("NaoHaDados");
		}
	}

	public ExtratoContaViewModel(long id)
	{
		_servico = new FinanceiroServico();
		BuscaInicial(id);
	}

	private async void BuscaInicial(long id)
	{
		Loading(isLoading: true);
		List<BancosContas> source = await new BancosContasServico().BuscarBancos();
		Contas = new ObservableCollection<BancosContas>(source.OrderBy((BancosContas x) => x.Descricao));
		ContasFilter = new ObservableCollection<BancosContas>(source.OrderBy((BancosContas x) => x.Descricao));
		SelectedConta = ((id > 0) ? ((IEnumerable<BancosContas>)Contas).FirstOrDefault((Func<BancosContas, bool>)((BancosContas x) => ((DomainBase)x).Id == id)) : Contas.FirstOrDefault());
		await GerarRelatorio();
		Loading(isLoading: false);
	}

	public void LimparRelatorio()
	{
		Extrato = null;
	}

	public async Task GerarRelatorio()
	{
		if (SelectedConta == null || ((DomainBase)SelectedConta).Id == 0L || !Inicio.HasValue || !Fim.HasValue)
		{
			return;
		}
		BancosContasServico servico = new BancosContasServico();
		Saldo val = await servico.BuscarSaldoInicial(((DomainBase)SelectedConta).Id);
		if (((val != null) ? val.DataInicio : null) > Inicio)
		{
			ShowMessage("DATA DE INÍCIO É MENOR QUE A CRIAÇÃO DA CONTA " + val.Conta.Descricao + ",\nDATA DE ABERTURA " + val.DataInicio?.ToString("dd/MM/yyyy"));
			NaoHaDados = true;
			return;
		}
		List<ExtratoConta> lancamentos = await _servico.BuscarLancamentosPorConta(Inicio.Value, Fim.Value, ((DomainBase)SelectedConta).Id);
		Saldo val2 = await servico.BuscarSaldo(Inicio.Value, ((DomainBase)SelectedConta).Id);
		if (lancamentos.Count == 0)
		{
			NaoHaDados = true;
			return;
		}
		if (val2 == null)
		{
			val2 = new Saldo
			{
				Conta = SelectedConta,
				DataInicio = Inicio,
				ValorInicio = 0m
			};
		}
		val2.DataFinal = Inicio.Value;
		val2.ValorFinal = default(decimal);
		val2 = await servico.FecharSaldo(val2);
		List<ExtratoConta> extrato = new List<ExtratoConta>();
		ExtratoConta val3 = new ExtratoConta
		{
			Baixa = Inicio.Value,
			Fornecedor = "SALDO INICIAL",
			Valor = val2.ValorFinal.GetValueOrDefault(),
			Sinal = (Sinal)((val2.ValorFinal.GetValueOrDefault() < 0m) ? 1 : 0),
			Bold = true
		};
		extrato.Add(val3);
		decimal? saldoDia = val3.Valor;
		(from x in lancamentos
			orderby x.Baixa
			group x by x.Baixa).ToList().ForEach(delegate(IGrouping<DateTime?, ExtratoConta> g)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			List<ExtratoConta> list2 = lancamentos.Where(delegate(ExtratoConta x)
			{
				DateTime? baixa = x.Baixa;
				DateTime? key = g.Key;
				if (baixa.HasValue != key.HasValue)
				{
					return false;
				}
				return !baixa.HasValue || baixa.GetValueOrDefault() == key.GetValueOrDefault();
			}).ToList();
			ExtratoConta val5 = new ExtratoConta
			{
				Baixa = g.Key,
				Fornecedor = "SALDO FINAL DO DIA",
				Valor = saldoDia + list2.Sum((ExtratoConta x) => x.Valor)
			};
			decimal? num2 = saldoDia + list2.Sum((ExtratoConta x) => x.Valor);
			val5.Sinal = (Sinal)(((num2.GetValueOrDefault() < default(decimal)) & num2.HasValue) ? 1 : 0);
			val5.Bold = true;
			ExtratoConta val6 = val5;
			if (!SaldoFinal)
			{
				extrato.AddRange(list2);
			}
			extrato.Add(val6);
			saldoDia = val6.Valor;
		});
		List<ExtratoConta> list = extrato;
		ExtratoConta val4 = new ExtratoConta
		{
			Baixa = Fim.Value,
			Fornecedor = "SALDO FINAL",
			Valor = saldoDia
		};
		decimal? num = saldoDia;
		val4.Sinal = (Sinal)(((num.GetValueOrDefault() < default(decimal)) & num.HasValue) ? 1 : 0);
		val4.Bold = true;
		list.Add(val4);
		Extrato = new ObservableCollection<ExtratoConta>(extrato);
	}

	public async Task Print()
	{
		if (Extrato == null || Extrato.Count == 0)
		{
			ShowMessage("NÃO HÁ DADOS PARA A IMPRESSÃO");
			return;
		}
		string dados = await Funcoes.GenerateTable(Extrato.ToList(), new List<string>());
		TipoRelatorio val = new TipoRelatorio
		{
			Nome = "EXTRATO CONTA - " + SelectedConta.Descricao,
			Inicio = (Inicio ?? DateTime.MinValue),
			Fim = (Fim ?? DateTime.MinValue)
		};
		val.Nome = ((val.Nome.Length < 30) ? val.Nome : val.Nome.Substring(0, 30));
		string value = Funcoes.ExportarHtml(val, dados, "60", "portrait");
		string tempPath = Path.GetTempPath();
		string text = string.Format("{0}{1}_{2:ddMMyyyyhhmmss}.html", tempPath, new Regex("[" + Regex.Escape(new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars())) + "]").Replace(val.Nome, ""), Funcoes.GetNetworkTime());
		StreamWriter streamWriter = new StreamWriter(text, append: true, Encoding.UTF8);
		streamWriter.Write(value);
		streamWriter.Close();
		Process.Start(text);
	}

	public async Task GerarExcel()
	{
		if (Extrato == null || Extrato.Count == 0)
		{
			ShowMessage("NÃO HÁ DADOS PARA A IMPRESSÃO EM EXCEL");
			return;
		}
		List<ExtratoConta> analitico = Extrato.ToList();
		string text = "";
		string fileName;
		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();
			}
			fileName = text + "EXTRATO CONTA - " + SelectedConta.Descricao + " " + Functions.GetNetworkTime().Date.ToShortDateString().Replace("/", "") + ".xlsx";
		}
		else
		{
			text = Path.GetTempPath();
			fileName = $"{text}{Guid.NewGuid()}.xlsx";
		}
		XLWorkbook val2 = new XLWorkbook();
		string text2 = "EXTRATO CONTA - " + SelectedConta.Descricao;
		text2 = ((text2.Length < 30) ? text2 : text2.Substring(0, 30));
		(await Funcoes.GerarXls(val2, text2, analitico, new List<string>())).SaveAs(fileName);
		Process.Start(fileName);
	}
}