public interface IOrderStatePublisher : IActor
{
}

public class OrderStatePublisher : IOrderStatePublisher
{
    private readonly IConnectionMultiplexer _redis;
    private readonly string _publishChannel;

    public OrderStatePublisher(
        IConnectionMultiplexer redis,
        RedisConfiguration redisConfig)
    {
        _redis = redis;
        _publishChannel = redisConfig.Channels.Updates;
    }

    public async Task ReceiveAsync(IContext ctx)
    {
        switch (ctx.Message)
        {
            case OrderState state:
                await _redis.GetSubscriber().PublishAsync(
                    _publishChannel,
                    JsonSerializer.Serialize(ToWire(state)));
                break;

            case (OrderState state, string msg):
                await _redis.GetSubscriber().PublishAsync(
                    _publishChannel,
                    JsonSerializer.Serialize(ToWire(state, msg)));
                break;
        }
    }

    private WireOrderState ToWire(OrderState state, string? msg = null)
    {
        return new WireOrderState(
            state.Id.ToString(),
            state.ExchangeId ?? string.Empty,
            state.Status.ToString(),
            state.Exchange.ToString(),
            state.Account,
            state.Side.ToString(),
            state.Symbol,
            state.Quantity,
            state.Fills,
            state.ExpirationTimestamp,
            state.CreatedTimestamp,
            state.LastUpdateTimestamp,
            msg ?? string.Empty);
    }

    private record WireOrderState(
        string Id,
        string? ExchangeId,
        string Status,
        string Exchange,
        string Account,
        string Side,
        string Symbol,
        decimal Quantity,
        List<Fill> Fills,
        DateTimeOffset? ExpirationTimestamp,
        DateTimeOffset CreatedTimestamp,
        DateTimeOffset LastUpdateTimestamp,
        string Message);
}