EDalerUriViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using EDaler;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.UI;
using NeuroAccessMaui.UI.Converters;
using NeuroAccessMaui.UI.Pages.Main.Calculator;
using System.ComponentModel;
using System.Globalization;
using System.Text;
using Waher.Content;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.StanzaErrors;
 
namespace NeuroAccessMaui.UI.Pages.Wallet
{
    public partial class EDalerUriViewModel : QrXmppViewModel
    {
        private readonly EDalerUriNavigationArgs? navigationArguments;
        private readonly IShareQrCode? shareQrCode;
        private readonly TaskCompletionSource<string?>? uriToSend = null;
 
        public EDalerUriViewModel(IShareQrCode? ShareQrCode, EDalerUriNavigationArgs? Args)
            : base()
        {
            this.navigationArguments = Args;
            this.shareQrCode = ShareQrCode;
 
            this.uriToSend = Args?.UriToSend;
            this.FriendlyName = Args?.FriendlyName;
 
            if (Args?.Uri is not null)
            {
                this.Uri = Args.Uri.UriString;
                this.Id = Args.Uri.Id;
                this.Amount = Args.Uri.Amount;
                this.AmountExtra = Args.Uri.AmountExtra;
                this.Currency = Args.Uri.Currency;
                this.Created = Args.Uri.Created;
                this.Expires = Args.Uri.Expires;
                this.ExpiresStr = this.Expires.ToShortDateString();
                this.From = Args.Uri.From;
                this.FromType = Args.Uri.FromType;
                this.To = Args.Uri.To;
                this.ToType = Args.Uri.ToType;
                this.ToPreset = !string.IsNullOrEmpty(Args.Uri.To);
                this.Complete = Args.Uri.Complete;
            }
 
            this.NotPaid = true;
 
            this.AmountText = !this.Amount.HasValue || this.Amount.Value <= 0 ? string.Empty : MoneyToString.ToString(this.Amount.Value);
            this.AmountOk = CommonTypes.TryParse(this.AmountText, out decimal d) && d > 0;
            this.AmountPreset = !string.IsNullOrEmpty(this.AmountText) && this.AmountOk;
            this.AmountAndCurrency = this.AmountText + " " + this.Currency;
 
            this.AmountExtraText = this.AmountExtra.HasValue ? MoneyToString.ToString(this.AmountExtra.Value) : string.Empty;
            this.AmountExtraOk = !this.AmountExtra.HasValue || this.AmountExtra.Value >= 0;
            this.AmountExtraPreset = this.AmountExtra.HasValue;
            this.AmountExtraAndCurrency = this.AmountExtraText + " " + this.Currency;
 
            StringBuilder Url = new();
 
            Url.Append("https://");
            Url.Append(this.From);
            Url.Append("/Images/eDalerFront200.png");
 
            this.EDalerFrontGlyph = Url.ToString();
 
            Url.Clear();
            Url.Append("https://");
            Url.Append(ServiceRef.TagProfile.Domain);
            Url.Append("/Images/eDalerBack200.png");
            this.EDalerBackGlyph = Url.ToString();
        }
 
        protected override async Task OnInitialize()
        {
            await base.OnInitialize();
 
            if (this.navigationArguments is not null)
            {
                if (this.navigationArguments.Uri?.EncryptedMessage is not null)
                {
                    if (this.navigationArguments.Uri.EncryptionPublicKey is null)
                        this.Message = Encoding.UTF8.GetString(this.navigationArguments.Uri.EncryptedMessage);
                    else
                    {
                        this.Message = await ServiceRef.XmppService.TryDecryptMessage(this.navigationArguments.Uri.EncryptedMessage,
                        this.navigationArguments.Uri.EncryptionPublicKey, this.navigationArguments.Uri.Id, this.navigationArguments.Uri.From);
                    }
                    this.HasMessage = !string.IsNullOrEmpty(this.Message);
                }
 
                this.MessagePreset = !string.IsNullOrEmpty(this.Message);
                this.CanEncryptMessage = this.navigationArguments.Uri?.ToType == EntityType.LegalId;
                this.EncryptMessage = this.CanEncryptMessage;
            }
        }
 
        protected override async Task OnDispose()
        {
            this.uriToSend?.TrySetResult(null);
 
            await base.OnDispose();
        }
 
        #region Properties
 
        [ObservableProperty]
        private string? uri;
 
        [ObservableProperty]
        private decimal? amount;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(PayOnlineCommand))]
        [NotifyCanExecuteChangedFor(nameof(GenerateQrCodeCommand))]
        [NotifyCanExecuteChangedFor(nameof(SendPaymentCommand))]
        private bool amountOk;
 
        protected override void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            base.OnPropertyChanged(e);
 
            switch (e.PropertyName)
            {
                case nameof(this.IsConnected):
                    this.AcceptCommand.NotifyCanExecuteChanged();
                    this.PayOnlineCommand.NotifyCanExecuteChanged();
                    this.SubmitCommand.NotifyCanExecuteChanged();
                    break;
 
                case nameof(this.HasQrCode):
                    this.PayOnlineCommand.NotifyCanExecuteChanged();
                    this.GenerateQrCodeCommand.NotifyCanExecuteChanged();
                    this.ShareCommand.NotifyCanExecuteChanged();
                    break;
 
                case nameof(this.AmountText):
                    if (CommonTypes.TryParse(this.AmountText, out decimal d) && d > 0)
                    {
                        this.Amount = d;
                        this.AmountOk = true;
                    }
                    else
                        this.AmountOk = false;
 
                    this.AmountAndCurrency = this.AmountText + " " + this.Currency;
                    break;
 
                case nameof(this.AmountExtraText):
                    if (string.IsNullOrEmpty(this.AmountExtraText))
                    {
                        this.AmountExtra = null;
                        this.AmountExtraOk = true;
                    }
                    else if (CommonTypes.TryParse(this.AmountExtraText, out d) && d >= 0)
                    {
                        this.AmountExtra = d;
                        this.AmountExtraOk = true;
                    }
                    else
                        this.AmountExtraOk = false;
 
                    this.AmountExtraAndCurrency = this.AmountExtraText + " " + this.Currency;
                    break;
            }
        }
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(PayOnlineCommand))]
        [NotifyCanExecuteChangedFor(nameof(GenerateQrCodeCommand))]
        [NotifyCanExecuteChangedFor(nameof(SendPaymentCommand))]
        private string? amountText;
 
        [ObservableProperty]
        private string? amountAndCurrency;
 
        [ObservableProperty]
        private bool amountPreset;
 
        [ObservableProperty]
        private decimal? amountExtra;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(PayOnlineCommand))]
        [NotifyCanExecuteChangedFor(nameof(GenerateQrCodeCommand))]
        [NotifyCanExecuteChangedFor(nameof(SendPaymentCommand))]
        private bool amountExtraOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(PayOnlineCommand))]
        [NotifyCanExecuteChangedFor(nameof(GenerateQrCodeCommand))]
        [NotifyCanExecuteChangedFor(nameof(SendPaymentCommand))]
        private string? amountExtraText;
 
        [ObservableProperty]
        private string? amountExtraAndCurrency;
 
        [ObservableProperty]
        private bool amountExtraPreset;
 
        [ObservableProperty]
        private string? currency;
 
        [ObservableProperty]
        private DateTime created;
 
        [ObservableProperty]
        private DateTime expires;
 
        [ObservableProperty]
        private string? expiresStr;
 
        [ObservableProperty]
        private Guid id;
 
        [ObservableProperty]
        private string? from;
 
        [ObservableProperty]
        private EntityType fromType;
 
        [ObservableProperty]
        private string? to;
 
        [ObservableProperty]
        private bool toPreset;
 
        [ObservableProperty]
        private EntityType toType;
 
        [ObservableProperty]
        private string? friendlyName;
 
        [ObservableProperty]
        private bool complete;
 
        [ObservableProperty]
        private string? message;
 
        [ObservableProperty]
        private bool encryptMessage;
 
        [ObservableProperty]
        private bool canEncryptMessage;
 
        [ObservableProperty]
        private bool hasMessage;
 
        [ObservableProperty]
        private bool messagePreset;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(PayOnlineCommand))]
        [NotifyCanExecuteChangedFor(nameof(GenerateQrCodeCommand))]
        [NotifyCanExecuteChangedFor(nameof(SendPaymentCommand))]
        private bool notPaid;
 
        [ObservableProperty]
        private string? eDalerFrontGlyph;
 
        [ObservableProperty]
        private string? eDalerBackGlyph;
 
        #endregion
 
        [RelayCommand]
        private async Task FromClick()
        {
            try
            {
                string? Value = this.From;
                if (Value is null)
                    return;
 
                if ((Value.StartsWith("http://", StringComparison.CurrentCultureIgnoreCase) ||
                    Value.StartsWith("https://", StringComparison.CurrentCultureIgnoreCase)) &&
                    System.Uri.TryCreate(Value, UriKind.Absolute, out Uri? Uri) && await Launcher.TryOpenAsync(Uri))
                {
                    return;
                }
 
                if (System.Uri.TryCreate("https://" + Value, UriKind.Absolute, out Uri) && await Launcher.TryOpenAsync(Uri))
                    return;
 
                await Clipboard.SetTextAsync(Value);
                await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                    ServiceRef.Localizer[nameof(AppResources.TagValueCopiedToClipboard)]);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand(CanExecute = nameof(IsConnected))]
        private async Task Accept()
        {
            try
            {
                if (this.Uri is null)
                    return;
 
                if (!await App.AuthenticateUser(AuthenticationPurpose.AcceptEDalerUri, true))
                    return;
 
                (bool succeeded, Transaction? Transaction) = await ServiceRef.NetworkService.TryRequest(
                    () => ServiceRef.XmppService.SendEDalerUri(this.Uri));
 
                if (succeeded)
                {
                    await this.GoBack();
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                        ServiceRef.Localizer[nameof(AppResources.TransactionAccepted)]);
                }
                else
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                        ServiceRef.Localizer[nameof(AppResources.UnableToProcessEDalerUri)]);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanPayOnline))]
        private async Task PayOnline()
        {
            try
            {
                if (!this.NotPaid)
                {
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                        ServiceRef.Localizer[nameof(AppResources.PaymentAlreadySent)]);
                    return;
                }
 
                if (!await App.AuthenticateUser(AuthenticationPurpose.PayOnline, true))
                    return;
 
                string Uri;
 
                if (this.EncryptMessage && this.ToType == EntityType.LegalId)
                {
                    try
                    {
                        LegalIdentity LegalIdentity = await ServiceRef.XmppService.GetLegalIdentity(this.To);
                        Uri = await ServiceRef.XmppService.CreateFullEDalerPaymentUri(LegalIdentity, this.Amount ?? 0, this.AmountExtra,
                            this.Currency ?? string.Empty, 3, this.Message ?? string.Empty);
                    }
                    catch (ForbiddenException)
                    {
                        // This happens if you try to view someone else's legal identity.
                        // When this happens, try to send a petition to view it instead.
                        // Normal operation. Should not be logged.
 
                        this.NotPaid = true;
 
                        MainThread.BeginInvokeOnMainThread(async () =>
                        {
                            bool Succeeded = await ServiceRef.NetworkService.TryRequest(() => ServiceRef.XmppService.PetitionIdentity(
                                this.To, Guid.NewGuid().ToString(), ServiceRef.Localizer[nameof(AppResources.EncryptedPayment)]));
 
                            if (Succeeded)
                            {
                                await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.PetitionSent)],
                                    ServiceRef.Localizer[nameof(AppResources.APetitionHasBeenSentForEncryption)]);
                            }
                        });
 
                        return;
                    }
                }
                else
                {
                    Uri = await ServiceRef.XmppService.CreateFullEDalerPaymentUri(this.To!, this.Amount ?? 0, this.AmountExtra,
                        this.Currency!, 3, this.Message ?? string.Empty);
                }
 
                // TODO: Validate To is a Bare JID or proper Legal Identity
                // TODO: Offline options: Expiry days
 
                this.NotPaid = false;
 
                (bool succeeded, Transaction? Transaction) = await ServiceRef.NetworkService.TryRequest(
                    () => ServiceRef.XmppService.SendEDalerUri(Uri));
 
                if (succeeded)
                {
                    await this.GoBack();
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                        ServiceRef.Localizer[nameof(AppResources.PaymentSuccess)]);
                }
                else
                {
                    this.NotPaid = true;
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                        ServiceRef.Localizer[nameof(AppResources.UnableToProcessEDalerUri)]);
                }
            }
            catch (Exception ex)
            {
                this.NotPaid = true;
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanGenerateQrCode))]
        private async Task GenerateQrCode()
        {
            if (!this.NotPaid)
            {
                await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                    ServiceRef.Localizer[nameof(AppResources.PaymentAlreadySent)]);
                return;
            }
 
            if (!await App.AuthenticateUser(AuthenticationPurpose.PayOffline, true))
                return;
 
            try
            {
                string Uri;
 
                if (this.EncryptMessage && this.ToType == EntityType.LegalId)
                {
                    LegalIdentity LegalIdentity = await ServiceRef.XmppService.GetLegalIdentity(this.To);
                    Uri = await ServiceRef.XmppService.CreateFullEDalerPaymentUri(LegalIdentity, this.Amount ?? 0, this.AmountExtra,
                        this.Currency ?? string.Empty, 3, this.Message ?? string.Empty);
                }
                else
                {
                    Uri = await ServiceRef.XmppService.CreateFullEDalerPaymentUri(this.To ?? string.Empty, this.Amount ?? 0, this.AmountExtra,
                        this.Currency ?? string.Empty, 3, this.Message ?? string.Empty);
                }
 
                // TODO: Validate To is a Bare JID or proper Legal Identity
                // TODO: Offline options: Expiry days
 
                if (this.IsAppearing)
                {
                    MainThread.BeginInvokeOnMainThread(async () =>
                    {
                        this.GenerateQrCode(Uri);
 
                        if (this.shareQrCode is not null)
                            await this.shareQrCode.ShowQrCode();
                    });
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        private bool CanPayOnline => this.AmountOk && this.AmountExtraOk && !this.HasQrCode && this.IsConnected && this.NotPaid; // TODO: Add To field OK
        private bool CanGenerateQrCode => this.AmountOk && this.AmountExtraOk && !this.HasQrCode && this.NotPaid; // TODO: Add To field OK
        private bool CanShare => this.HasQrCode;
 
        [RelayCommand(CanExecute = nameof(CanShare))]
        private async Task Share()
        {
            if (this.QrCodeBin is null)
                return;
 
            try
            {
                string? Message = this.Message?? this.AmountAndCurrency;
 
                ServiceRef.PlatformSpecific.ShareImage(this.QrCodeBin,
                    string.Format(CultureInfo.CurrentCulture, Message ?? string.Empty, this.Amount, this.Currency),
                    ServiceRef.Localizer[nameof(AppResources.Share)], "RequestPayment.png");
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand(CanExecute = nameof(IsConnected))]
        private async Task Submit()
        {
            if (this.Uri is null)
                return;
 
            try
            {
                if (!await App.AuthenticateUser(AuthenticationPurpose.SubmitEDalerUri))
                    return;
 
                (bool succeeded, Transaction? Transaction) = await ServiceRef.NetworkService.TryRequest(() => ServiceRef.XmppService.SendEDalerUri(this.Uri));
                if (succeeded)
                {
                    await this.GoBack();
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                        ServiceRef.Localizer[nameof(AppResources.PaymentSuccess)]);
                }
                else
                    await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                        ServiceRef.Localizer[nameof(AppResources.UnableToProcessEDalerUri)]);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand]
        private async Task ShowCode()
        {
            if (this.Uri is null)
                return;
 
            if (!await App.AuthenticateUser(AuthenticationPurpose.ShowUriAsQr, true))
                return;
 
            try
            {
                if (this.IsAppearing)
                {
                    MainThread.BeginInvokeOnMainThread(async () =>
                    {
                        this.GenerateQrCode(this.Uri);
 
                        if (this.shareQrCode is not null)
                            await this.shareQrCode.ShowQrCode();
                    });
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        private bool CanSendPayment()
        {
            return this.uriToSend is not null && this.AmountOk && this.AmountExtraOk && this.NotPaid;
        }
 
        [RelayCommand(CanExecute = nameof(CanSendPayment))]
        private async Task SendPayment()
        {
            if (!this.NotPaid)
            {
                await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                    ServiceRef.Localizer[nameof(AppResources.PaymentAlreadySent)]);
                return;
            }
 
            if (!await App.AuthenticateUser(AuthenticationPurpose.SendPayment, true))
                return;
 
            try
            {
                string Uri;
 
                if (this.EncryptMessage && this.ToType == EntityType.LegalId)
                {
                    LegalIdentity LegalIdentity = await ServiceRef.XmppService.GetLegalIdentity(this.To);
                    Uri = await ServiceRef.XmppService.CreateFullEDalerPaymentUri(LegalIdentity, this.Amount ?? 0, this.AmountExtra,
                        this.Currency!, 3, this.Message ?? string.Empty);
                }
                else
                {
                    Uri = await ServiceRef.XmppService.CreateFullEDalerPaymentUri(this.To!, this.Amount ?? 0, this.AmountExtra,
                        this.Currency!, 3, this.Message ?? string.Empty);
                }
 
                // TODO: Validate To is a Bare JID or proper Legal Identity
                // TODO: Offline options: Expiry days
 
                this.uriToSend?.TrySetResult(Uri);
                await this.GoBack();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand]
        public async Task OpenCalculator(object Parameter)
        {
            try
            {
                switch (Parameter?.ToString())
                {
                    case "AmountText":
                        CalculatorNavigationArgs AmountArgs = new(this, nameof(this.AmountText));
 
                        await ServiceRef.UiService.GoToAsync(nameof(CalculatorPage), AmountArgs, BackMethod.Pop);
                        break;
 
                    case "AmountExtraText":
                        CalculatorNavigationArgs ExtraArgs = new(this, nameof(this.AmountExtraText));
 
                        await ServiceRef.UiService.GoToAsync(nameof(CalculatorPage), ExtraArgs, BackMethod.Pop);
                        break;
                }
            }
            catch (Exception ex)
            {
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        #region ILinkableView
 
        public override Task<string> Title => Task.FromResult<string>(ServiceRef.Localizer[nameof(AppResources.Payment)]);
 
        #endregion
 
    }
}