NotificationBuilder.cs

using System;
using System.Collections.Generic;
using Waher.Events;
using Waher.Script.Abstraction.Elements;
using Waher.Networking.XMPP.Server.PushNotification;
 
namespace Waher.Networking.HTTP.Firebase 
{
    public class NotificationBuilder
    {
        private readonly NotificationMessage message;
        private readonly NotificationOptions options;
        private Dictionary<string, object> data;
        private readonly ClientType clientType;
 
        public NotificationBuilder(ClientType ClientType)
        {
            this.clientType = ClientType;
            this.options = new NotificationOptions();
            this.message = ClientType switch
            {
                ClientType.Android => new NotificationMessageAndroid(),
                ClientType.iOS => new NotificationMessageApple(),
                ClientType.Web => new NotificationMessageWeb(),
                _ => new NotificationMessage()
            };
        }
 
        public NotificationBuilder ApplyPayload(PushNotificationPayload Payload)
        {
            if (Payload is null)
                return this;
 
            bool SilentDelivery = Payload.Delivery?.Silent ?? false;
 
            if (!(Payload.Visual is null))
            {
                if (!SilentDelivery && !string.IsNullOrEmpty(Payload.Visual.Title))
                    this.message.Title = Payload.Visual.Title;
 
                if (!SilentDelivery && !string.IsNullOrEmpty(Payload.Visual.Body))
                    this.message.Body = Payload.Visual.Body;
 
                if (!string.IsNullOrEmpty(Payload.Visual.Subtitle))
                {
                    if (this.message is NotificationMessageApple Apple)
                        Apple.SubTitle = Payload.Visual.Subtitle;
                }
 
                if (!string.IsNullOrEmpty(Payload.Visual.Icon))
                {
                    if (this.message is NotificationMessageAndroid Android)
                        Android.Icon = Payload.Visual.Icon;
                    else if (this.message is NotificationMessageWeb Web)
                        Web.Icon = Payload.Visual.Icon;
                }
 
                if (!string.IsNullOrEmpty(Payload.Visual.Badge) && this.message is NotificationMessageApple AppleBadge)
                    AppleBadge.Badge = Payload.Visual.Badge;
            }
 
            if (!(Payload.Action is null))
            {
                if (!SilentDelivery && !string.IsNullOrEmpty(Payload.Action.NavigationTarget))
                {
                    this.message.ClickAction = Payload.Action.NavigationTarget;
 
                    if (this.message is NotificationMessageWeb Web)
                        Web.Link = Payload.Action.NavigationTarget;
                }
 
                this.AddData("actionType", Payload.Action.Type);
                this.AddData("entityId", Payload.Action.EntityId);
                this.AddData("correlationId", Payload.Action.CorrelationId);
                this.AddData("navigationTarget", Payload.Action.NavigationTarget);
            }
 
            if (!(Payload.Channel is null))
            {
                if (!string.IsNullOrEmpty(Payload.Channel.ChannelId) && this.message is NotificationMessageAndroid Android)
                    Android.ChannelId = Payload.Channel.ChannelId;
 
                this.AddData("channelId", Payload.Channel.ChannelId);
                this.AddData("category", Payload.Channel.Category);
                this.AddData("importance", Payload.Channel.Importance);
                if (!(Payload.Channel.Tags is null))
                    this.AddData("tags", Payload.Channel.Tags);
            }
 
            if (!(Payload.Context is null))
            {
                foreach (KeyValuePair<string, object> P in Payload.Context)
                    this.AddData(P.Key, P.Value);
            }
 
            if (!(Payload.CustomData is null))
            {
                foreach (KeyValuePair<string, object> P in Payload.CustomData)
                    this.AddData(P.Key, P.Value);
            }
 
            if (!(Payload.Delivery is null))
            {
                if (!string.IsNullOrEmpty(Payload.Delivery.Priority) &&
                    Enum.TryParse(Payload.Delivery.Priority, true, out NotificationPriority Priority))
                {
                    this.message.Priority = Priority;
                }
 
                if (Payload.Delivery.Ttl.HasValue)
                    this.message.TimeToLive = Payload.Delivery.Ttl.Value;
 
                if (!string.IsNullOrEmpty(Payload.Delivery.CollapseKey))
                    this.options.CollapseKey = Payload.Delivery.CollapseKey;
 
                if (Payload.Delivery.Silent)
                {
                    this.message.SuppressNotification = true;
                    this.message.Priority = NotificationPriority.Normal;
 
                    switch (this.message)
                    {
                        case NotificationMessageApple Apple:
                            Apple.ContentAvailable = true;
                            break;
                    }
                }
            }
 
            if (!(Payload.PlatformOverrides is null) &&
                Payload.PlatformOverrides.TryGetValue(this.clientType, out Dictionary<string, object> Overrides))
            {
                foreach (KeyValuePair<string, object> P in Overrides)
                    this.ApplyOverrideProperty(P.Key, P.Value);
            }
 
            return this;
        }
 
        public (NotificationMessage message, NotificationOptions options, Dictionary<string, object> data) Build()
        {
            this.ValidateNotification();
            return (this.message, this.options, this.data);
        }
 
        private void ValidateNotification()
        {
            switch (this.clientType)
            {
                case ClientType.Android:
                    this.ValidateAndroid();
                    break;
 
                case ClientType.iOS:
                    this.ValidateApple(); 
                    break;
 
                case ClientType.Web:
                case ClientType.Other:
                default:
                    break;
            }
        }
 
        private void ValidateAndroid()
        {
            if (!(this.message is NotificationMessageAndroid Android))
                return;
 
            // Validate Android-specific requirements
            if (string.IsNullOrEmpty(Android.ChannelId))
                Android.ChannelId = "default";  // Ensure default channel
        }
 
        private void ValidateApple()
        {
            if (!(this.message is NotificationMessageApple Apple))
                return;
 
            // For iOS, either alert (title/body) or content-available must be set
            if (string.IsNullOrEmpty(Apple.Title) && 
            string.IsNullOrEmpty(Apple.Body) && 
            !Apple.ContentAvailable)
            {
                Apple.ContentAvailable = true;
            }
        }
 
        private void AddData(string Key, object Value)
        {
            if (string.IsNullOrEmpty(Key) || Value is null)
                return;
 
            this.data ??= new Dictionary<string, object>();
            this.data[Key] = Value;
        }
 
        private void ApplyOverrideProperty(string Key, object Value)
        {
            // Try options first (transport-level settings)
            bool Handled = this.options.TrySetProperty(Key, Value);
 
            // Try message second (platform-specific settings)
            Handled = this.message.TrySetProperty(Key, Value) || Handled;
 
            // Add to data if not handled (custom data)
            if (Key == "data" && Value is Dictionary<string, object> DataItems)
            {
                foreach (KeyValuePair<string, object> Item in DataItems)
                    this.AddData(Item.Key, Item.Value);
            }
            else if (!Handled)
                this.AddData(Key, Value);
        }
    }
}