LaboratoryProtection/Assets/PMaker/MessagePipe/MessageKit.cs

using Cysharp.Threading.Tasks;

using MessagePipe;

using PMaker.UI;

using System;
using System.Threading;

using UniRx;

namespace PMaker.MessagePipe
{
    public static partial class MessageKit
    {
        static BuiltinContainerBuilder _builtinContainerBuilder;

        public static IPublisher<TMessage> GetPublisher<TMessage>()
        {
            return GlobalMessagePipe.GetPublisher<TMessage>();
        }

        public static ISubscriber<TMessage> GetSubscriber<TMessage>()
        {
            return GlobalMessagePipe.GetSubscriber<TMessage>();
        }

        public static IAsyncPublisher<TMessage> GetAsyncPublisher<TMessage>()
        {
            return GlobalMessagePipe.GetAsyncPublisher<TMessage>();
        }

        public static IAsyncSubscriber<TMessage> GetAsyncSubscriber<TMessage>()
        {
            return GlobalMessagePipe.GetAsyncSubscriber<TMessage>();
        }

        public static IAsyncPublisher<TKey, TMessage> GetAsyncPublisher<TKey, TMessage>()
        {
            return GlobalMessagePipe.GetAsyncPublisher<TKey, TMessage>();
        }

        public static IAsyncSubscriber<TKey, TMessage> GetAsyncSubscriber<TKey, TMessage>()
        {
            return GlobalMessagePipe.GetAsyncSubscriber<TKey, TMessage>();
        }

        public static IPublisher<TKey, TMessage> GetPublisher<TKey, TMessage>()
        {
            return GlobalMessagePipe.GetPublisher<TKey, TMessage>();
        }

        public static ISubscriber<TKey, TMessage> GetSubscriber<TKey, TMessage>()
        {
            return GlobalMessagePipe.GetSubscriber<TKey, TMessage>();
        }
    }

    public static partial class MessageKit
    {
        public static UniTask PublishAsync<TKey, TMessage>(TKey key, TMessage message, CancellationToken cancellationToken = default)
        {
            return GetAsyncPublisher<TKey, TMessage>().PublishAsync(key, message, cancellationToken);
        }

        public static void Publish<TKey, TMessage>(TKey key, TMessage message)
        {
            GlobalMessagePipe.GetPublisher<TKey, TMessage>().Publish(key, message);
        }

        public static void Publish<TMessage>(TMessage message)
        {
            GlobalMessagePipe.GetPublisher<TMessage>().Publish(message);
        }

        public static async UniTask<TMessage> PublishFuncAsync<TKey, TMessage>(TKey key, TMessage message, CancellationToken cancellationToken = default)
        {
            var refHelper = new Ref<TMessage>() { value = message };
            await GetAsyncPublisher<TKey, Ref<TMessage>>().PublishAsync(key, refHelper, cancellationToken);
            return refHelper.value;
        }

        public static TMessage PublishFunc<TKey, TMessage>(TKey key, TMessage message)
        {
            var refHelper = new Ref<TMessage>();
            GlobalMessagePipe.GetPublisher<TKey, Ref<TMessage>>().Publish(key, refHelper);
            return refHelper.value;
        }

        public static ISubscriber<TKey, Ref<TMessage>> GetFuncSubscriber<TKey, TMessage>()
        {
            return GlobalMessagePipe.GetSubscriber<TKey, Ref<TMessage>>();
        }

        public static IAsyncSubscriber<TKey, Ref<TMessage>> GetFuncAsyncSubscriber<TKey, TMessage>()
        {
            return GlobalMessagePipe.GetAsyncSubscriber<TKey, Ref<TMessage>>();
        }
    }

    // Init
    public static partial class MessageKit
    {
        static MessageKit()
        {
            _builtinContainerBuilder = new BuiltinContainerBuilder();
            _builtinContainerBuilder.AddMessagePipe()
                                    .AddMessageBroker<string, string>()
                                    .AddMessageBroker<string, bool>()
                                    .AddMessageBroker<string, int>()
                                    .AddMessageBroker<string>()
                                    // message
                                    .AddMessageBroker<string, (string, bool)>()
                                    .AddMessageBroker<string, Ref<int>>()
                                    .AddMessageBroker<string, Ref<Page>>()
                                    .AddMessageBroker<string, Func<UniTask>[]>();

            GlobalMessagePipe.SetProvider(_builtinContainerBuilder.BuildServiceProvider());
        }
    }

    public class Ref<T>
    {
        public T value;
    }

    public abstract class MessageBehaviourBase<TKey, TMessage> : BaseBehaviour
    {
        protected abstract TKey Key { get; }
        protected Func<TMessage, CancellationToken, UniTask> asyncHandler;
        protected Action<TMessage> handler;

        protected virtual void Awake()
        {
            MessageKit.GetAsyncSubscriber<TKey, TMessage>()
                      .Subscribe(Key, async (message, token) => {
                          await this.asyncHandler(message, token);
                      })
                      .AddTo(this);

            MessageKit.GetSubscriber<TKey, TMessage>()
                      .Subscribe(Key, message => {
                          this.handler(message);
                      })
                      .AddTo(this);
        }
    }

    public class NameMessageBehaviour<TMessage> : MessageBehaviourBase<string, TMessage>
    {
        protected override string Key => this.name;
    }
}