#nullable enable
using System;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using ShrinkEventBus;

namespace ShrinkNetwork.Integration
{
    public static class ShrinkNetworkEventBusBridgeExtensions
    {
        public static ShrinkNetworkService UseEventBusBridge(this ShrinkNetworkService service,
            ShrinkNetworkEventBusBridgeOptions? options = null)
        {
            if (service == null)
                throw new ArgumentNullException(nameof(service));

            options ??= new ShrinkNetworkEventBusBridgeOptions();
            if (options.AutoRegisterAttributedMessages)
                service.AutoRegisterAttributedMessages();
            if (options.AutoRegisterStaticHandlers)
                service.AutoRegisterStaticHandlers();
            if (options.DispatchScheduler != null)
                service.DispatchScheduler = options.DispatchScheduler;

            ShrinkNetworkEventBusBridge.RegisterService(service, options.SessionFilter);
            return service;
        }

        public static UniTask PublishEventAsync<TEvent>(this ShrinkNetworkSession session, TEvent eventArgs, string? route = null)
            where TEvent : EventBase, IShrinkNetworkMessage
        {
            return ShrinkNetworkEventBusBridge.PublishAsync(session, eventArgs, route);
        }

        public static UniTask BroadcastEventAsync<TEvent>(this ShrinkNetworkService service, TEvent eventArgs,
            Func<ShrinkNetworkSession, bool>? sessionFilter = null, string? route = null)
            where TEvent : EventBase, IShrinkNetworkMessage
        {
            if (service == null)
                throw new ArgumentNullException(nameof(service));

            IEnumerable<ShrinkNetworkSession> sessions = service.Sessions.Values;
            if (sessionFilter != null)
            {
                var filtered = new List<ShrinkNetworkSession>();
                foreach (var session in service.Sessions.Values)
                {
                    if (sessionFilter(session))
                        filtered.Add(session);
                }

                sessions = filtered;
            }

            return ShrinkNetworkEventBusBridge.PublishAsync(sessions, eventArgs, route);
        }

        public static async UniTask<ShrinkNetworkEventRequestOutcome> RequestEventAsync<TEvent>(
            this ShrinkNetworkSession session,
            TEvent eventArgs,
            ShrinkRpcCallOptions? options = null)
            where TEvent : EventBase, IShrinkNetworkRequest
        {
            var response = await ShrinkNetworkEventBusBridge.RequestResultAsync(session, eventArgs, options);
            return ShrinkNetworkEventRequestOutcome.FromResponse(response);
        }
    }
}