ContractOrchestratorService.cs

using System.Data;
using System.Globalization;
using System.Reflection;
using System.Text;
using EDaler;
using NeuroAccessMaui.Extensions;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services.Authentication;
using NeuroAccessMaui.Services.Notification;
using NeuroAccessMaui.Services.Notification.Identities;
using NeuroAccessMaui.Services.UI;
using NeuroAccessMaui.UI.Pages.Contracts.NewContract;
using NeuroAccessMaui.UI.Pages.Contracts.ViewContract;
using NeuroAccessMaui.UI.Pages.Identity.ViewIdentity;
using NeuroAccessMaui.UI.Pages.Onboarding;
using NeuroAccessMaui.UI.Pages.Main;
using NeuroAccessMaui.UI.Pages.Petitions.PetitionIdentity;
using NeuroAccessMaui.UI.Pages.Petitions.PetitionPeerReview;
using NeuroAccessMaui.UI.Pages.Petitions.PetitionSignature;
using NeuroFeatures;
using NeuroFeatures.EventArguments;
using Waher.Content.Xml;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Networking.XMPP.StanzaErrors;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Inventory;
using NeuroAccessMaui.Services.UI.Popups;
 
namespace NeuroAccessMaui.Services.Contracts
{
    [Singleton]
    internal class ContractOrchestratorService : LoadableService, IContractOrchestratorService
    {
 
        private readonly IAuthenticationService authenticationService = ServiceRef.Provider.GetRequiredService<IAuthenticationService>();
 
        public ContractOrchestratorService()
        {
        }
 
        public override Task Load(bool IsResuming, CancellationToken CancellationToken)
        {
            if (this.BeginLoad(IsResuming, CancellationToken))
            {
                ServiceRef.XmppService.ConnectionStateChanged += this.Contracts_ConnectionStateChanged;
                ServiceRef.XmppService.PetitionForPeerReviewIdReceived += this.Contracts_PetitionForPeerReviewIdReceived;
                ServiceRef.XmppService.PetitionForIdentityReceived += this.Contracts_PetitionForIdentityReceived;
                ServiceRef.XmppService.PetitionForSignatureReceived += this.Contracts_PetitionForSignatureReceived;
                ServiceRef.XmppService.PetitionedIdentityResponseReceived += this.Contracts_PetitionedIdentityResponseReceived;
                ServiceRef.XmppService.PetitionedPeerReviewIdResponseReceived += this.Contracts_PetitionedPeerReviewResponseReceived;
                ServiceRef.XmppService.SignaturePetitionResponseReceived += this.Contracts_SignaturePetitionResponseReceived;
                ServiceRef.XmppService.ContractProposalReceived += this.Contracts_ContractProposalRecieved;
 
                this.EndLoad(true);
            }
 
            return Task.CompletedTask;
        }
 
        public override Task Unload()
        {
            if (this.BeginUnload())
            {
                ServiceRef.XmppService.ConnectionStateChanged -= this.Contracts_ConnectionStateChanged;
                ServiceRef.XmppService.PetitionForPeerReviewIdReceived -= this.Contracts_PetitionForPeerReviewIdReceived;
                ServiceRef.XmppService.PetitionForIdentityReceived -= this.Contracts_PetitionForIdentityReceived;
                ServiceRef.XmppService.PetitionForSignatureReceived -= this.Contracts_PetitionForSignatureReceived;
                //ServiceRef.XmppService.PetitionForContractReceived -= this.Contract_Pe
                ServiceRef.XmppService.PetitionedIdentityResponseReceived -= this.Contracts_PetitionedIdentityResponseReceived;
                ServiceRef.XmppService.PetitionedPeerReviewIdResponseReceived -= this.Contracts_PetitionedPeerReviewResponseReceived;
                ServiceRef.XmppService.SignaturePetitionResponseReceived -= this.Contracts_SignaturePetitionResponseReceived;
                ServiceRef.XmppService.ContractProposalReceived -= this.Contracts_ContractProposalRecieved;
 
                this.EndUnload();
            }
 
            return Task.CompletedTask;
        }
 
        #region Event Handlers
 
        private async Task Contracts_PetitionForPeerReviewIdReceived(object? Sender, SignaturePetitionEventArgs e)
        {
            try
            {
                LegalIdentity Identity = e.RequestorIdentity;
 
                if (Identity?.Properties is not null)
                {
                    foreach (Property Property in Identity.Properties)
                    {
                        switch (Property.Name)
                        {
                            case Constants.XmppProperties.FirstName:
                            case Constants.XmppProperties.MiddleNames:
                            case Constants.XmppProperties.LastNames:
                            case Constants.XmppProperties.FullName:
                            case Constants.XmppProperties.PersonalNumber:
                            case Constants.XmppProperties.Address:
                            case Constants.XmppProperties.Address2:
                            case Constants.XmppProperties.Area:
                            case Constants.XmppProperties.City:
                            case Constants.XmppProperties.ZipCode:
                            case Constants.XmppProperties.Region:
                            case Constants.XmppProperties.Country:
                            case Constants.XmppProperties.Nationality:
                            case Constants.XmppProperties.Gender:
                            case Constants.XmppProperties.BirthDay:
                            case Constants.XmppProperties.BirthMonth:
                            case Constants.XmppProperties.BirthYear:
                            case Constants.XmppProperties.OrgName:
                            case Constants.XmppProperties.OrgNumber:
                            case Constants.XmppProperties.OrgAddress:
                            case Constants.XmppProperties.OrgAddress2:
                            case Constants.XmppProperties.OrgArea:
                            case Constants.XmppProperties.OrgCity:
                            case Constants.XmppProperties.OrgZipCode:
                            case Constants.XmppProperties.OrgRegion:
                            case Constants.XmppProperties.OrgCountry:
                            case Constants.XmppProperties.OrgDepartment:
                            case Constants.XmppProperties.OrgRole:
                            case Constants.XmppProperties.DeviceId:
                            case Constants.XmppProperties.Jid:
                            case Constants.XmppProperties.Phone:
                            case Constants.XmppProperties.EMail:
                                break;
 
                            default:
                                byte[] Signature = await ServiceRef.XmppService.Sign(e.ContentToSign, SignWith.LatestApprovedId);
 
                                await ServiceRef.XmppService.SendPetitionSignatureResponse(e.SignatoryIdentityId, e.ContentToSign, Signature,
                                    e.PetitionId, e.RequestorFullJid, false);
 
                                return;
                        }
                    }
 
                    PetitionPeerReviewNavigationArgs Args = new(Identity, e.RequestorFullJid, e.SignatoryIdentityId, e.PetitionId,
                        e.Purpose, e.ContentToSign);
 
                    await ServiceRef.NavigationService.GoToAsync(nameof(PetitionPeerReviewPage), Args);
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private async Task Contracts_PetitionForIdentityReceived(object? Sender, LegalIdentityPetitionEventArgs e)
        {
            try
            {
                LegalIdentity Identity;
 
                if (e.RequestedIdentityId == ServiceRef.TagProfile.LegalIdentity?.Id)
                    Identity = ServiceRef.TagProfile.LegalIdentity;
                else
                {
                    (bool Succeeded, LegalIdentity? LegalId) = await ServiceRef.NetworkService.TryRequest(() => ServiceRef.XmppService.GetLegalIdentity(e.RequestedIdentityId));
 
                    if (!Succeeded || LegalId is null)
                        return;
 
                    Identity = LegalId;
                }
 
                if (Identity is null)
                {
                    ServiceRef.LogService.LogWarning("Identity is missing or cannot be retrieved, ignore.",
                        new KeyValuePair<string, object?>("Type", this.GetType().Name),
                        new KeyValuePair<string, object?>("Method", nameof(Contracts_PetitionForIdentityReceived)));
 
                    return;
                }
 
                if (Identity.State == IdentityState.Compromised ||
                    Identity.State == IdentityState.Rejected)
                {
                    await ServiceRef.NetworkService.TryRequest(() =>
                    {
                        return ServiceRef.XmppService.SendPetitionIdentityResponse(
                            e.RequestedIdentityId, e.PetitionId, e.RequestorFullJid, false);
                    });
                }
                else
                {
                    Identity = e.RequestorIdentity;
 
                    if (Identity is not null)
                    {
                        RequestIdentityNotificationEvent Event = new(e);
                        await ServiceRef.Provider.GetRequiredService<IPopupService>().PopAsync();
                        //await ServiceRef.NotificationService.NewEvent(Event);
                        await ServiceRef.NavigationService.GoToAsync(nameof(PetitionIdentityPage), new PetitionIdentityNavigationArgs(
                            Identity, e.RequestorFullJid, e.RequestedIdentityId, e.PetitionId, e.Purpose));
                        NotificationIntent Intent = CreateIdentityPetitionNotificationIntent(e);
                        await this.MarkPetitionNotificationConsumedAsync(Intent);
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private async Task Contracts_PetitionForSignatureReceived(object? Sender, SignaturePetitionEventArgs e)
        {
            try
            {
                LegalIdentity Identity;
 
                if (e.SignatoryIdentityId == ServiceRef.TagProfile.LegalIdentity?.Id)
                    Identity = ServiceRef.TagProfile.LegalIdentity;
                else
                {
                    (bool Succeeded, LegalIdentity? LegalId) = await ServiceRef.NetworkService.TryRequest(() => ServiceRef.XmppService.GetLegalIdentity(e.SignatoryIdentityId));
                    if (!Succeeded || LegalId is null)
                        return;
 
                    Identity = LegalId;
                }
 
                if (Identity is null)
                {
                    ServiceRef.LogService.LogWarning("Identity is missing or cannot be retrieved, ignore.",
                        new KeyValuePair<string, object?>("Type", this.GetType().Name),
                        new KeyValuePair<string, object?>("Method", nameof(Contracts_PetitionForSignatureReceived)));
 
                    return;
                }
 
                if (Identity.State == IdentityState.Compromised || Identity.State == IdentityState.Rejected)
                {
                    await ServiceRef.NetworkService.TryRequest(() =>
                    {
                        return ServiceRef.XmppService.SendPetitionSignatureResponse(
                            e.SignatoryIdentityId, e.ContentToSign, [], e.PetitionId, e.RequestorFullJid, false);
                    });
                }
                else
                {
                    Identity = e.RequestorIdentity;
 
                    if (Identity is not null)
                    {
                        await ServiceRef.NavigationService.GoToAsync(nameof(PetitionSignaturePage), new PetitionSignatureNavigationArgs(
                            Identity, e.RequestorFullJid, e.SignatoryIdentityId, e.ContentToSign, e.PetitionId, e.Purpose));
                        NotificationIntent Intent = CreateSignaturePetitionNotificationIntent(e);
                        await this.MarkPetitionNotificationConsumedAsync(Intent);
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private async Task Contracts_PetitionedIdentityResponseReceived(object? Sender, LegalIdentityPetitionResponseEventArgs e)
        {
            try
            {
                LegalIdentity Identity = e.RequestedIdentity;
 
                if (!e.Response || Identity is null)
                {
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.Message)],
                        ServiceRef.Localizer[nameof(AppResources.SignaturePetitionDenied)],
                        ServiceRef.Localizer[nameof(AppResources.Ok)]);
                }
                else if (ServiceRef.NavigationService.CurrentPage is not (NewContractPage or ViewContractPage))
                    await ServiceRef.NavigationService.GoToAsync(nameof(ViewIdentityPage), new ViewIdentityNavigationArgs(Identity));
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private async Task Contracts_PetitionedPeerReviewResponseReceived(object? Sender, SignaturePetitionResponseEventArgs e)
        {
            try
            {
                LegalIdentity? ReviewedIdentity = ServiceRef.TagProfile.IdentityApplication;
                if (ReviewedIdentity is null)
                    return;
 
                if (!e.Response)
                {
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.PeerReviewRejected)],
                        ServiceRef.Localizer[nameof(AppResources.APeerYouRequestedToReviewHasRejected)],
                        ServiceRef.Localizer[nameof(AppResources.Ok)]);
 
                    return;
                }
 
                LegalIdentity ReviewerIdentity = e.RequestedIdentity;
                if (ReviewerIdentity is null)
                    return;
 
                try
                {
                    StringBuilder Xml = new();
                    ReviewedIdentity.Serialize(Xml, true, true, true, true, true, true, true);
                    string s = Xml.ToString();
                    byte[] Data = Encoding.UTF8.GetBytes(s);
                    bool? Result;
 
                    try
                    {
                        Result = ServiceRef.XmppService.ValidateSignature(ReviewerIdentity, Data, e.Signature);
                    }
                    catch (Exception ex)
                    {
                        await ServiceRef.UiService.DisplayException(ex);
                        return;
                    }
 
                    if (!Result.HasValue || !Result.Value)
                    {
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.PeerReviewRejected)],
                            ServiceRef.Localizer[nameof(AppResources.APeerYouRequestedToReviewHasBeenRejectedDueToSignatureError)],
                            ServiceRef.Localizer[nameof(AppResources.Ok)]);
                    }
                    else
                    {
                        (bool Succeeded, LegalIdentity? LegalIdentity) = await ServiceRef.NetworkService.TryRequest(async () =>
                        {
                            LegalIdentity Result = await ServiceRef.XmppService.AddPeerReviewIdAttachment(ReviewedIdentity, ReviewerIdentity, e.Signature);
                            await ServiceRef.TagProfile.IncrementNrPeerReviews();
                            return Result;
                        });
 
                        if (Succeeded)
                        {
                            await ServiceRef.UiService.DisplayAlert(
                                ServiceRef.Localizer[nameof(AppResources.PeerReviewAccepted)],
                                ServiceRef.Localizer[nameof(AppResources.APeerReviewYouhaveRequestedHasBeenAccepted)],
                                ServiceRef.Localizer[nameof(AppResources.Ok)]);
                        }
                    }
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.ErrorTitle)], ex.Message,
                        ServiceRef.Localizer[nameof(AppResources.Ok)]);
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private static NotificationIntent CreateIdentityPetitionNotificationIntent(LegalIdentityPetitionEventArgs e)
        {
            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionIdentityTitle), ToBareJid(e.RequestorFullJid)];
            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionIdentityBody)];
 
            NotificationIntent Intent = new()
            {
                Channel = Constants.PushChannels.Petitions,
                Title = Title,
                Body = Body,
                Action = NotificationAction.OpenPetition,
                EntityId = e.RequestorFullJid,
                CorrelationId = e.PetitionId,
                Presentation = NotificationPresentation.StoreOnly
            };
 
            Intent.Extras["petitionId"] = e.PetitionId ?? string.Empty;
            Intent.Extras["requestedIdentityId"] = e.RequestedIdentityId ?? string.Empty;
            Intent.Extras["requestorIdentityId"] = e.RequestorIdentity?.Id ?? string.Empty;
 
            return Intent;
        }
 
        private static NotificationIntent CreateSignaturePetitionNotificationIntent(SignaturePetitionEventArgs e)
        {
            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionSignatureTitle), ToBareJid(e.RequestorFullJid)];
            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionSignatureBody)];
 
            NotificationIntent Intent = new()
            {
                Channel = Constants.PushChannels.Petitions,
                Title = Title,
                Body = Body,
                Action = NotificationAction.OpenPetition,
                EntityId = e.RequestorFullJid,
                CorrelationId = e.PetitionId,
                Presentation = NotificationPresentation.StoreOnly
            };
 
            byte[] ContentToSign = e.ContentToSign ?? Array.Empty<byte>();
            string ContentToSignBase64 = Convert.ToBase64String(ContentToSign);
            string Purpose = e.Purpose ?? string.Empty;
            string RequestorIdentityId = e.RequestorIdentity?.Id ?? string.Empty;
 
            Intent.Extras["signatoryId"] = e.SignatoryIdentityId ?? string.Empty;
            Intent.Extras["petitionId"] = e.PetitionId ?? string.Empty;
            Intent.Extras["requestorIdentityId"] = RequestorIdentityId;
            Intent.Extras["purpose"] = Purpose;
            Intent.Extras["contentToSign"] = ContentToSignBase64;
 
            return Intent;
        }
 
        private async Task MarkPetitionNotificationConsumedAsync(NotificationIntent Intent)
        {
            try
            {
                INotificationServiceV2 NotificationService = ServiceRef.Provider.GetRequiredService<INotificationServiceV2>();
                string NotificationId = NotificationService.ComputeId(Intent, NotificationSource.Xmpp);
                await NotificationService.MarkConsumedAsync(NotificationId, CancellationToken.None);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private static string ToBareJid(string Jid)
        {
            if (string.IsNullOrWhiteSpace(Jid))
                return Jid;
 
            int SlashIndex = Jid.IndexOf('/');
            return SlashIndex > -1 ? Jid.Substring(0, SlashIndex) : Jid;
        }
 
        private async Task Contracts_ContractProposalRecieved(object? sender, ContractProposalEventArgs e)
        {
            try
            {
                Contract Contract = await ServiceRef.XmppService.GetContract(e.ContractId);
 
                while (ServiceRef.NavigationService.CurrentPage is not MainPage)
                {
                    await Task.Delay(500);
                }
                await Task.Delay(500);
 
                await ServiceRef.NavigationService.GoToAsync(nameof(ViewContractPage), new ViewContractNavigationArgs(
                            Contract, false, e.Role, e.MessageText, e.FromBareJID));
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private async Task Contracts_ConnectionStateChanged(object _, XmppState NewState)
        {
            /*
            try
            {
                if (ServiceRef.XmppService.IsOnline &&
                    ServiceRef.TagProfile.IsCompleteOrWaitingForValidation())
                {
                    if (ServiceRef.TagProfile.LegalIdentity is not null)
                    {
                        Task FireAndForget = Task.Run( async () =>
                        { 
                            try
                            {
                                await Task.Delay(Constants.Timeouts.XmppInit);
                                await ReDownloadLegalIdentity();
                            }
                            catch (Exception ex)
                            {
                                ServiceRef.LogService.LogException(ex);
                            }
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
            */
 
        }
 
        #endregion
 
        protected static async Task ReDownloadLegalIdentity()
        {
            if (ServiceRef.XmppService is null ||
                !await ServiceRef.XmppService.WaitForConnectedState(Constants.Timeouts.XmppConnect) ||
                !ServiceRef.XmppService.IsOnline ||
                ServiceRef.TagProfile.LegalIdentity is null)
            {
                return;
            }
 
            LegalIdentity? Identity;
 
            try
            {
                Identity = await ServiceRef.XmppService!.GetLegalIdentity(ServiceRef.TagProfile.LegalIdentity.Id);
            }
            catch (ForbiddenException)    // Old ID belonging to a previous account, for example. Simply discard.
            {
                await ServiceRef.TagProfile.ClearLegalIdentity();
                await ServiceRef.NavigationService.GoToAsync(nameof(OnboardingPage), new OnboardingNavigationArgs() { Scenario = OnboardingScenario.FullSetup });
                return;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                return;
            }
 
            if (Identity is not null)
            {
                MainThread.BeginInvokeOnMainThread(async () =>
                {
                    try
                    {
 
                        string? UserMessage = null;
                        bool GotoRegistrationPage = false;
 
                        if (Identity.State == IdentityState.Compromised)
                        {
                            UserMessage = ServiceRef.Localizer[nameof(AppResources.YourLegalIdentityHasBeenCompromised)];
                            await ServiceRef.TagProfile.CompromiseLegalIdentity(Identity);
                            GotoRegistrationPage = true;
                        }
                        else if (Identity.State == IdentityState.Obsoleted)
                        {
                            UserMessage = ServiceRef.Localizer[nameof(AppResources.YourLegalIdentityHasBeenObsoleted)];
                            await ServiceRef.TagProfile.RevokeLegalIdentity(Identity);
                            GotoRegistrationPage = true;
                        }
                        else if (Identity.State == IdentityState.Approved)
                        {
                            bool HasPrivateKeys = false;
                            try
                            {
                                HasPrivateKeys = await ServiceRef.XmppService.HasPrivateKey(Identity.Id);
 
                            }
                            catch (Exception Ex)
                            {
                                ServiceRef.LogService.LogException(Ex);
                            }
 
                            if (HasPrivateKeys)
                            {
                                await ServiceRef.TagProfile.SetLegalIdentity(Identity, true);
                                return;
                            }
 
                            bool Response = await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.WarningTitle)],
                            ServiceRef.Localizer[nameof(AppResources.UnableToGetAccessToYourPrivateKeys)],
                            ServiceRef.Localizer[nameof(AppResources.Continue)],
                            ServiceRef.Localizer[nameof(AppResources.Repair)]);
 
                            if (Response)
                                await ServiceRef.TagProfile.SetLegalIdentity(Identity, true);
                            else
                            {
                                try
                                {
                                    File.WriteAllText(Path.Combine(ServiceRef.StorageService.DataFolder, "Start.txt"),
                                        DateTime.Now.AddHours(1).Ticks.ToString(CultureInfo.InvariantCulture));
                                }
                                catch (Exception ex)
                                {
                                    ServiceRef.LogService.LogException(ex);
                                }
 
                                await App.StopAsync();
                                return;
                            }
                        }
                        else
                            await ServiceRef.TagProfile.SetLegalIdentity(Identity, true);
 
                        if (GotoRegistrationPage)
                        {
                            //await App.SetRegistrationPageAsync();
 
                            // After navigating to the registration page, show the user why this happened.
                            if (!string.IsNullOrWhiteSpace(UserMessage))
                            {
                                // Do a begin invoke here so the page animation has time to finish,
                                // and the view model loads state et.c. before showing the alert.
                                // This gives a better UX experience.
                                MainThread.BeginInvokeOnMainThread(async () =>
                                {
                                    await ServiceRef.UiService.DisplayAlert(
                                        ServiceRef.Localizer[nameof(AppResources.YourLegalIdentity)], UserMessage);
                                });
                            }
                        }
                    }
                    catch (Exception E)
                    {
                        ServiceRef.LogService.LogException(E);
                    }
                });
            }
        }
 
        public async Task OpenLegalIdentity(string LegalId, string Purpose)
        {
            try
            {
                bool Connected = await ServiceRef.XmppService.WaitForConnectedState(Constants.Timeouts.XmppConnect);
 
                if (!Connected)
                    throw new TimeoutException();
 
                LegalIdentity Identity = await ServiceRef.XmppService.GetLegalIdentity(LegalId);
                MainThread.BeginInvokeOnMainThread(async () =>
                {
                    await ServiceRef.NavigationService.GoToAsync(nameof(ViewIdentityPage), new ViewIdentityNavigationArgs(Identity));
                });
            }
            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.
 
                MainThread.BeginInvokeOnMainThread(async () =>
                {
                    bool Succeeded = await ServiceRef.NetworkService.TryRequest(() => ServiceRef.XmppService.PetitionIdentity(LegalId, Guid.NewGuid().ToString(), Purpose));
                    if (Succeeded)
                    {
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.PetitionSent)],
                            ServiceRef.Localizer[nameof(AppResources.APetitionHasBeenSentToTheOwner)]);
                    }
                });
            }
            catch (TimeoutException)
            {
                await ServiceRef.UiService.DisplayAlert(
                    ServiceRef.Localizer[nameof(AppResources.AppNotConnected)],
                    ServiceRef.Localizer[nameof(AppResources.PleaseTryAgain)],
                    ServiceRef.Localizer[nameof(AppResources.Ok)]);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));
                await ServiceRef.UiService.DisplayAlert(
                    ServiceRef.Localizer[nameof(AppResources.SomethingWentWrong)],
                    ServiceRef.Localizer[nameof(AppResources.PleaseTryAgain)],
                    ServiceRef.Localizer[nameof(AppResources.Ok)]);
            }
        }
 
        public async Task<LegalIdentity?> TryGetLegalIdentity(string LegalId, string Purpose)
        {
            try
            {
                LegalIdentity Identity = await ServiceRef.XmppService.GetLegalIdentity(LegalId);
                return Identity;
            }
            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.
                if (!string.IsNullOrEmpty(Purpose))
                    await ServiceRef.XmppService.PetitionIdentity(LegalId, Guid.NewGuid().ToString(), Purpose);
                return null;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));
                return null;
            }
        }
 
        public async Task OpenContract(string ContractId, string Purpose, Dictionary<CaseInsensitiveString, object>? ParameterValues)
        {
            try
            {
                Contract Contract = await ServiceRef.XmppService.GetContract(ContractId);
 
                ContractReference Ref = await Database.FindFirstDeleteRest<ContractReference>(
                    new FilterFieldEqualTo("ContractId", Contract.ContractId));
 
                if (Ref is not null)
                {
                    if (Ref.Updated != Contract.Updated || !Ref.ContractLoaded)
                    {
                        await Ref.SetContract(Contract);
                        await Database.Update(Ref);
                    }
 
                    ServiceRef.TagProfile.CheckContractReference(Ref);
                }
 
                MainThread.BeginInvokeOnMainThread(async () =>
                {
                    if (Contract.PartsMode == ContractParts.TemplateOnly && Contract.State == ContractState.Approved)
                    {
                        if (Ref is null)
                        {
                            Ref = new()
                            {
                                ContractId = Contract.ContractId
                            };
 
                            await Ref.SetContract(Contract);
                            await Database.Insert(Ref);
 
                            ServiceRef.TagProfile.CheckContractReference(Ref);
                        }
                        if (Contract.ForMachinesNamespace == NeuroFeaturesClient.NamespaceNeuroFeatures
                        || Contract.ForMachinesNamespace == Constants.ContractMachineNames.PaymentInstructionsNamespace)
                        {
                            CreationAttributesEventArgs CreationAttr = await ServiceRef.XmppService.GetNeuroFeatureCreationAttributes();
                            ServiceRef.TagProfile.TrustProviderId = CreationAttr.TrustProviderId;
                            ParameterValues ??= [];
                            ParameterValues.TryAdd(new CaseInsensitiveString("TrustProvider"), CreationAttr.TrustProviderId);
                            ParameterValues.TryAdd(new CaseInsensitiveString("Currency"), CreationAttr.Currency);
                            ParameterValues.TryAdd(new CaseInsensitiveString("CommissionPercent"), CreationAttr.Commission);
                        }
 
                        NewContractNavigationArgs e = new(Contract, ParameterValues);
 
                        await ServiceRef.NavigationService.GoToAsync(nameof(NewContractPage), e, BackMethod.CurrentPage);
                    }
                    else
                    {
                        ViewContractNavigationArgs e = new(Contract, false);
 
                        await ServiceRef.NavigationService.GoToAsync(nameof(ViewContractPage), e, BackMethod.Pop);
                    }
                });
            }
            catch (ForbiddenException)
            {
                // This happens if you try to view someone else's contract.
                // When this happens, try to send a petition to view it instead.
                // Normal operation. Should not be logged.
 
                MainThread.BeginInvokeOnMainThread(async () =>
                {
                    bool Succeeded = await ServiceRef.NetworkService.TryRequest(() =>
                        ServiceRef.XmppService.PetitionContract(ContractId, Guid.NewGuid().ToString(), Purpose));
 
                    if (Succeeded)
                    {
                        await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.PetitionSent)],
                            ServiceRef.Localizer[nameof(AppResources.APetitionHasBeenSentToTheContract)]);
                    }
                });
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public async Task TagSignature(string Request)
        {
            int i = Request.IndexOf(',');
 
            if (i < 0)
                throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.InvalidTagSignatureId)]);
 
            string JID = System.Web.HttpUtility.UrlDecode(Request[..i]);
            string Key = Request[(i + 1)..];
 
            LegalIdentity? ID = ServiceRef.TagProfile.LegalIdentity;
 
            if (ID is null)
            {
                await ServiceRef.Provider.GetRequiredService<UiService>().DisplayAlert(
                    ServiceRef.Localizer[nameof(AppResources.SomethingWentWrong)], ServiceRef.Localizer[nameof(AppResources.NotCompletedOnboardingError)],
                    ServiceRef.Localizer[nameof(AppResources.Ok)]);
                return;
            }
 
            if (ID.State != IdentityState.Approved)
            {
                await ServiceRef.Provider.GetRequiredService<UiService>().DisplayAlert(
                    ServiceRef.Localizer[nameof(AppResources.SomethingWentWrong)], ServiceRef.Localizer[nameof(AppResources.LegalIdNotApproved)],
                    ServiceRef.Localizer[nameof(AppResources.Ok)]);
                return;
            }
 
            string IdRef = ServiceRef.TagProfile.LegalIdentity?.Id ?? string.Empty;
 
            StringBuilder Xml = new();
 
            Xml.Append("<ql xmlns='https://tagroot.io/schema/Signature' key='");
            Xml.Append(XML.Encode(Key));
            Xml.Append("' legalId='");
            Xml.Append(XML.Encode(IdRef));
            Xml.Append("'/>");
 
            if (!ServiceRef.XmppService.IsOnline &&
                !await ServiceRef.XmppService.WaitForConnectedState(TimeSpan.FromSeconds(10)))
            {
                throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.AppNotConnected)]);
            }
 
            await ServiceRef.XmppService.IqSetAsync(JID, Xml.ToString());
        }
 
        private async Task Contracts_SignaturePetitionResponseReceived(object? Sender, SignaturePetitionResponseEventArgs e)
        {
            try
            {
                LegalIdentity Identity = e.RequestedIdentity;
 
                if (!e.Response || Identity is null)
                {
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.Message)],
                        ServiceRef.Localizer[nameof(AppResources.PetitionToViewLegalIdentityWasDenied)],
                        ServiceRef.Localizer[nameof(AppResources.Ok)]);
                }
                else
                    await ServiceRef.NavigationService.GoToAsync(nameof(ViewIdentityPage), new ViewIdentityNavigationArgs(Identity));
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
    }
}