using System;
using System.Collections.Generic;

namespace AcDream.Core.Net.Messages;

/// <summary>
/// Central router for inbound <c>0xF7B0</c> GameEvent envelopes.
///
/// <para>
/// Each handled <see cref="GameEventType"/> gets a registered delegate.
/// Unhandled types are counted for diagnostics so it's easy to see which
/// events the server is actually emitting vs which ones we theoretically
/// support — a useful number when iterating on chat / inventory / combat.
/// </para>
///
/// <para>
/// Handlers are invoked synchronously on the thread that called
/// <see cref="Dispatch"/> — normally the render thread since
/// <see cref="WorldSession"/>'s decode path runs there in the current
/// architecture. Handlers must not block.
/// </para>
/// </summary>
public sealed class GameEventDispatcher
{
    public delegate void EventHandler(GameEventEnvelope envelope);

    private readonly Dictionary<GameEventType, EventHandler> _handlers = new();
    private readonly Dictionary<GameEventType, int> _unhandledCounts = new();

    /// <summary>
    /// Register a handler for a GameEvent sub-opcode. Replaces any
    /// existing handler for that opcode.
    /// </summary>
    public void Register(GameEventType type, EventHandler handler)
    {
        ArgumentNullException.ThrowIfNull(handler);
        _handlers[type] = handler;
    }

    /// <summary>
    /// Remove the registered handler for a sub-opcode.
    /// </summary>
    public void Unregister(GameEventType type) => _handlers.Remove(type);

    /// <summary>
    /// Route an envelope to its handler, or log as unhandled. Exceptions
    /// inside handlers are swallowed to keep the decode loop alive — a
    /// malformed event from the server should not crash the client.
    /// </summary>
    public void Dispatch(GameEventEnvelope envelope)
    {
        if (_handlers.TryGetValue(envelope.EventType, out var handler))
        {
            try
            {
                handler(envelope);
            }
            catch (Exception ex)
            {
                // The decode thread must survive handler failures. Log via
                // Console so it surfaces in live-play logs without needing
                // a Serilog sink here.
                Console.Error.WriteLine(
                    $"[GameEvent] handler for 0x{(uint)envelope.EventType:X4} threw: {ex.Message}");
            }
        }
        else
        {
            _unhandledCounts.TryGetValue(envelope.EventType, out int n);
            _unhandledCounts[envelope.EventType] = n + 1;
        }
    }

    /// <summary>Number of events of the given type we've seen with no handler.</summary>
    public int GetUnhandledCount(GameEventType type) =>
        _unhandledCounts.TryGetValue(type, out var n) ? n : 0;

    /// <summary>
    /// Snapshot of every event type we've seen without a handler, keyed
    /// by type → count. Useful for "which server events are firing that
    /// we don't parse?" diagnostic overlays.
    /// </summary>
    public IReadOnlyDictionary<GameEventType, int> UnhandledCounts => _unhandledCounts;

    /// <summary>Reset the unhandled-counts bag (e.g. after a log-off).</summary>
    public void ResetUnhandledCounts() => _unhandledCounts.Clear();

    /// <summary>How many distinct sub-opcodes have a handler registered.</summary>
    public int RegisteredHandlerCount => _handlers.Count;
}