ContactInfo.cs

using NeuroAccessMaui.Resources.Languages;
using System.Globalization;
using System.Text;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
 
namespace NeuroAccessMaui.Services.Contacts
{
    [CollectionName("ContactInformation")]
    [TypeName(TypeNameSerialization.None)]
    [Index("BareJid", "SourceId", "Partition", "NodeId")]
    [Index("IsThing", "BareJid", "SourceId", "Partition", "NodeId")]
    [Index("LegalId")]
    public class ContactInfo
    {
        private string? objectId = null;
        private CaseInsensitiveString bareJid = CaseInsensitiveString.Empty;
        private CaseInsensitiveString legalId = CaseInsensitiveString.Empty;
        private LegalIdentity? legalIdentity = null;
        private Property[]? metaData = null;
        private string friendlyName = string.Empty;
        private string sourceId = string.Empty;
        private string partition = string.Empty;
        private string nodeId = string.Empty;
        private CaseInsensitiveString registryJid = string.Empty;
        private bool? subscribeTo = null;
        private bool? allowSubscriptionFrom = null;
        private bool? isThing = null;
        private bool? isSensor = null;
        private bool? isActuator = null;
        private bool? isConcentrator = null;
        private bool? supportsSensorEvents = null;
        private bool? owner = null;
 
        public ContactInfo()
        {
        }
 
        [ObjectId]
        public string? ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        public CaseInsensitiveString BareJid
        {
            get => this.bareJid;
            set => this.bareJid = value;
        }
 
        public CaseInsensitiveString LegalId
        {
            get => this.legalId;
            set => this.legalId = value;
        }
 
        [DefaultValueNull]
        public LegalIdentity? LegalIdentity
        {
            get => this.legalIdentity;
            set => this.legalIdentity = value;
        }
 
        [DefaultValueStringEmpty]
        public string FriendlyName
        {
            get => this.friendlyName;
            set => this.friendlyName = value;
        }
 
        public string SourceId
        {
            get => this.sourceId;
            set => this.sourceId = value;
        }
 
        public string Partition
        {
            get => this.partition;
            set => this.partition = value;
        }
 
        public string NodeId
        {
            get => this.nodeId;
            set => this.nodeId = value;
        }
 
        public CaseInsensitiveString RegistryJid
        {
            get => this.registryJid;
            set => this.registryJid = value;
        }
 
        public bool? SubscribeTo
        {
            get => this.subscribeTo;
            set => this.subscribeTo = value;
        }
 
        public bool? AllowSubscriptionFrom
        {
            get => this.allowSubscriptionFrom;
            set => this.allowSubscriptionFrom = value;
        }
 
        public bool? IsThing
        {
            get => this.isThing;
            set => this.isThing = value;
        }
 
        public bool? IsSensor
        {
            get => this.isSensor;
            set => this.isSensor = value;
        }
 
        public bool? SupportsSensorEvents
        {
            get => this.supportsSensorEvents;
            set => this.supportsSensorEvents = value;
        }
 
        public bool? IsActuator
        {
            get => this.isActuator;
            set => this.isActuator = value;
        }
 
        public bool? IsConcentrator
        {
            get => this.isConcentrator;
            set => this.isConcentrator = value;
        }
 
        [DefaultValueNull]
        public bool? Owner
        {
            get => this.owner;
            set => this.owner = value;
        }
 
        [DefaultValueNull]
        public Property[]? MetaData
        {
            get => this.metaData;
            set => this.metaData = value;
        }
 
        public static Task<ContactInfo> FindByBareJid(string BareJid)
        {
            return Database.FindFirstIgnoreRest<ContactInfo>(new FilterFieldEqualTo("BareJid", BareJid));
        }
 
        public static Task<ContactInfo> FindByBareJid(string BareJid, string SourceId, string Partition, string NodeId)
        {
            return Database.FindFirstIgnoreRest<ContactInfo>(new FilterAnd(
                new FilterFieldEqualTo("BareJid", BareJid),
                new FilterFieldEqualTo("SourceId", SourceId),
                new FilterFieldEqualTo("Partition", Partition),
                new FilterFieldEqualTo("NodeId", NodeId)));
        }
 
        public static Task<ContactInfo> FindByLegalId(string LegalId)
        {
            return Database.FindFirstIgnoreRest<ContactInfo>(new FilterFieldEqualTo("LegalId", LegalId));
        }
 
        public static async Task<string> GetFriendlyName(CaseInsensitiveString RemoteId)
        {
            int i = RemoteId.IndexOf('@');
 
            if (i < 0)
                return RemoteId;
 
            if (RemoteId == ServiceRef.TagProfile.LegalIdentity?.Id)
                return ServiceRef.Localizer[nameof(AppResources.Me)];
 
            string Account = RemoteId.Substring(0, i);
            ContactInfo Info;
            bool AccountIsGuid;
 
            if (AccountIsGuid = Guid.TryParse(Account, out Guid _))
            {
                Info = await FindByLegalId(RemoteId);
 
                if (!string.IsNullOrEmpty(Info?.FriendlyName))
                    return Info.FriendlyName;
 
                if (Info?.LegalIdentity is not null)
                    return GetFriendlyName(Info.LegalIdentity);
            }
 
            Info = await FindByBareJid(RemoteId);
            if (Info is not null)
            {
                if (!string.IsNullOrEmpty(Info.FriendlyName))
                    return Info.FriendlyName;
 
                if (Info.LegalIdentity is not null)
                    return GetFriendlyName(Info.LegalIdentity);
 
                if (Info.MetaData is not null)
                {
                    string? s = GetFriendlyName(Info.MetaData);
 
                    if (!string.IsNullOrEmpty(s))
                        return s;
                }
            }
 
            RosterItem? Item = ServiceRef.XmppService.GetRosterItem(RemoteId);
            if (Item is not null)
                return Item.NameOrBareJid;
 
            lock (identityCache)
                if (identityCache.TryGetValue(RemoteId, out LegalIdentity? Id))
                    if (Id is not null)
                        return GetFriendlyName(Id);
                    else
                        AccountIsGuid = false;
 
            if (AccountIsGuid)
            {
                lock (identityCache)
                    identityCache[RemoteId] = null;
 
                Task _ = Task.Run(async () =>
                {
                    try
                    {
                        LegalIdentity Id = await ServiceRef.XmppService.GetLegalIdentity(RemoteId);
 
                        lock (identityCache)
                            identityCache[RemoteId] = Id;
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                });
            }
 
            return RemoteId;
        }
 
        private static readonly Dictionary<CaseInsensitiveString, LegalIdentity?> identityCache = [];
 
        public static async Task<string[]?> GetFriendlyName(string[] RemoteId)
        {
            if (RemoteId is null)
                return null;
 
            int i, c = RemoteId.Length;
            string[] Result = new string[c];
 
            for (i = 0; i < c; i++)
                Result[i] = await GetFriendlyName(RemoteId[i]);
 
            return Result;
        }
 
        public static string? GetFriendlyName(IEnumerable<Property> MetaData)
        {
            string? Apartment = null;
            string? Area = null;
            string? Building = null;
            string? City = null;
            string? Class = null;
            string? Country = null;
            string? Manufacturer = null;
            string? MeterLocation = null;
            string? MeterNumber = null;
            string? Model = null;
            string? Name = null;
            string? Region = null;
            string? Room = null;
            string? SerialNumber = null;
            string? Street = null;
            string? StreetNumber = null;
            string? Version = null;
            string? Phone = null;
 
            foreach (Property P in MetaData)
                switch (P.Name.ToUpper(CultureInfo.InvariantCulture))
                {
                    case Constants.XmppProperties.Apartment:
                        Apartment = P.Value;
                        break;
 
                    case Constants.XmppProperties.Area:
                        Area = P.Value;
                        break;
 
                    case Constants.XmppProperties.Building:
                        Building = P.Value;
                        break;
 
                    case Constants.XmppProperties.City:
                        City = P.Value;
                        break;
 
                    case Constants.XmppProperties.Country:
                        Country = P.Value;
                        break;
 
                    case Constants.XmppProperties.Region:
                        Region = P.Value;
                        break;
 
                    case Constants.XmppProperties.Room:
                        Room = P.Value;
                        break;
 
                    case Constants.XmppProperties.StreetName:
                        Street = P.Value;
                        break;
 
                    case Constants.XmppProperties.StreetNumber:
                        StreetNumber = P.Value;
                        break;
 
                    case Constants.XmppProperties.Class:
                        Class = P.Value;
                        break;
 
                    case Constants.XmppProperties.Manufacturer:
                        Manufacturer = P.Value;
                        break;
 
                    case Constants.XmppProperties.MeterLocation:
                        MeterLocation = P.Value;
                        break;
 
                    case Constants.XmppProperties.MeterNumber:
                        MeterNumber = P.Value;
                        break;
 
                    case Constants.XmppProperties.Model:
                        Model = P.Value;
                        break;
 
                    case Constants.XmppProperties.Name:
                        Name = P.Value;
                        break;
 
                    case Constants.XmppProperties.SerialNumber:
                        SerialNumber = P.Value;
                        break;
 
                    case Constants.XmppProperties.Version:
                        Version = P.Value;
                        break;
 
                    case Constants.XmppProperties.Phone:
                        Phone = P.Value;
                        break;
                }
 
            StringBuilder? sb = null;
 
            AppendName(ref sb, Class);
            AppendName(ref sb, Model);
            AppendName(ref sb, Version);
            AppendName(ref sb, Room);
            AppendName(ref sb, Name);
            AppendName(ref sb, Apartment);
            AppendName(ref sb, Building);
            AppendName(ref sb, Street);
            AppendName(ref sb, StreetNumber);
            AppendName(ref sb, Area);
            AppendName(ref sb, City);
            AppendName(ref sb, Region);
            AppendName(ref sb, Country);
            AppendName(ref sb, MeterNumber);
            AppendName(ref sb, MeterLocation);
            AppendName(ref sb, Manufacturer);
            AppendName(ref sb, SerialNumber);
            AppendName(ref sb, Phone);
 
            return sb?.ToString();
        }
 
        public static string GetFriendlyName(LegalIdentity? Identity)
        {
            if (Identity is null)
                return string.Empty;
 
            string? FirstName = null;
            string? MiddleName = null;
            string? LastName = null;
            string? PersonalNumber = null;
            string? Domain = null;
            string? OrgDepartment = null;
            string? OrgRole = null;
            string? OrgName = null;
            bool HasName = false;
            bool HasOrg = false;
            bool HasDomain = false;
 
            foreach (Property P in Identity.Properties)
            {
                switch (P.Name.ToUpper(CultureInfo.InvariantCulture))
                {
                    case Constants.XmppProperties.FirstName:
                        FirstName = P.Value;
                        HasName = true;
                        break;
 
                    case Constants.XmppProperties.MiddleNames:
                        MiddleName = P.Value;
                        HasName = true;
                        break;
 
                    case Constants.XmppProperties.LastNames:
                        LastName = P.Value;
                        HasName = true;
                        break;
 
                    case Constants.XmppProperties.PersonalNumber:
                        PersonalNumber = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgName:
                        OrgName = P.Value;
                        HasOrg = true;
                        break;
 
                    case Constants.XmppProperties.OrgDepartment:
                        OrgDepartment = P.Value;
                        HasOrg = true;
                        break;
 
                    case Constants.XmppProperties.OrgRole:
                        OrgRole = P.Value;
                        HasOrg = true;
                        break;
 
                    case Constants.XmppProperties.Domain:
                        Domain = P.Value;
                        HasDomain = true;
                        break;
                }
            }
 
            StringBuilder? sb = null;
 
            if (HasName)
            {
                AppendName(ref sb, FirstName);
                AppendName(ref sb, MiddleName);
                AppendName(ref sb, LastName);
            }
 
            if (HasOrg)
            {
                AppendName(ref sb, OrgRole);
                AppendName(ref sb, OrgDepartment);
                AppendName(ref sb, OrgName);
            }
 
            string Result = sb is not null ? sb.ToString() : !string.IsNullOrEmpty(PersonalNumber) ? PersonalNumber : Identity.Id;
 
            if (HasDomain)
                Result = Domain + " (" + Result + ")";
 
            return Result;
        }
 
        public static string GetFullName(LegalIdentity? Identity)
        {
            string? FirstName = null;
            string? MiddleNames = null;
            string? LastNames = null;
 
            if (Identity?.Properties is not null)
                foreach (Property P in Identity.Properties)
                    switch (P.Name)
                    {
                        case Constants.XmppProperties.FirstName:
                            FirstName = P.Value;
                            break;
 
                        case Constants.XmppProperties.LastNames:
                            LastNames = P.Value;
                            break;
 
                        case Constants.XmppProperties.MiddleNames:
                            MiddleNames = P.Value;
                            break;
                    }
 
            return GetFullName(FirstName, MiddleNames, LastNames);
        }
 
        public static string GetFullName(string? FirstName, string? MiddleNames, string? LastNames)
        {
            StringBuilder? sb = null;
 
            AppendName(ref sb, FirstName);
            AppendName(ref sb, MiddleNames);
            AppendName(ref sb, LastNames);
 
            return sb?.ToString() ?? string.Empty;
        }
 
        internal static void AppendName(ref StringBuilder? sb, string? Value)
        {
            if (!string.IsNullOrEmpty(Value))
            {
                if (sb is null)
                    sb = new StringBuilder();
                else
                    sb.Append(' ');
 
                sb.Append(Value);
            }
        }
 
        public static async Task<string> GetFriendlyName(CaseInsensitiveString BareJid, string SourceId, string PartitionId, string NodeId)
        {
            if (string.IsNullOrEmpty(NodeId) && string.IsNullOrEmpty(PartitionId) && string.IsNullOrEmpty(SourceId))
                return await GetFriendlyName(BareJid);
 
            ContactInfo Thing = await FindByBareJid(BareJid, SourceId, PartitionId, NodeId);
 
            if (Thing is not null)
                return Thing.FriendlyName;
 
            string s = NodeId;
 
            if (!string.IsNullOrEmpty(PartitionId))
                if (string.IsNullOrEmpty(s))
                    s = PartitionId;
                else
                    s = ServiceRef.Localizer[nameof(AppResources.XInY), s, PartitionId];
 
            if (!string.IsNullOrEmpty(SourceId))
                if (string.IsNullOrEmpty(s))
                    s = SourceId;
                else
                    s = ServiceRef.Localizer[nameof(AppResources.XInY), s, SourceId];
 
            return ServiceRef.Localizer[nameof(AppResources.XOnY), s, BareJid];
        }
 
        public string this[string PropertyName]
        {
            get
            {
                if (this.metaData is not null)
                    foreach (Property P in this.metaData)
                        if (string.Equals(P.Name, PropertyName, StringComparison.OrdinalIgnoreCase))
                            return P.Value;
 
                return string.Empty;
            }
        }
 
        public string ThingNotificationCategoryKey
        {
            get
            {
                return GetThingNotificationCategoryKey(this.bareJid, this.nodeId, this.sourceId, this.partition);
            }
        }
 
        public static string GetThingNotificationCategoryKey(string BareJid, string? NodeId, string? SourceId, string? Partition)
        {
            StringBuilder sb = new();
 
            sb.Append(BareJid);
            sb.Append('|');
 
            if (SourceId is not null)
                sb.Append(SourceId);
 
            sb.Append('|');
 
            if (Partition is not null)
                sb.Append(Partition);
 
            sb.Append('|');
 
            if (NodeId is not null)
                sb.Append(NodeId);
 
            return sb.ToString();
        }
    }
}