﻿/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace DotPulsar.Internal;

#if NETSTANDARD2_0
public sealed class DotPulsarEventSource
{
    public static readonly DotPulsarEventSource Log = new();

    public void ClientCreated() { }

    public void ClientDisposed() { }

    public void ConnectionCreated() { }

    public void ConnectionDisposed() { }

    public void ConsumerCreated() { }

    public void ConsumerDisposed() { }

    public void ProducerCreated() { }

    public void ProducerDisposed() { }

    public void ReaderCreated() { }

    public void ReaderDisposed() { }

    public void TokenRefreshed() { }

    public long TokenRefreshCount => 0;
}

#else
using System.Diagnostics.Tracing;
using System.Threading;

public sealed class DotPulsarEventSource : EventSource
{
#pragma warning disable IDE0052 // Remove unread private members
    private PollingCounter? _totalClientsCounter;
    private long _totalClients;

    private PollingCounter? _currentClientsCounter;
    private long _currentClients;

    private PollingCounter? _totalConnectionsCounter;
    private long _totalConnections;

    private PollingCounter? _currentConnectionsCounter;
    private long _currentConnections;

    private PollingCounter? _totalConsumersCounter;
    private long _totalConsumers;

    private PollingCounter? _currentConsumersCounter;
    private long _currentConsumers;

    private PollingCounter? _totalProducersCounter;
    private long _totalProducers;

    private PollingCounter? _currentProducersCounter;
    private long _currentProducers;

    private PollingCounter? _totalReadersCounter;
    private long _totalReaders;

    private PollingCounter? _currentReadersCounter;
    private long _currentReaders;

    private PollingCounter? _tokenRefreshCounter;
    private long _totalTokenRefreshes;
#pragma warning restore IDE0052 // Remove unread private members

    public static readonly DotPulsarEventSource Log = new();

    public DotPulsarEventSource() : base("DotPulsar") { }
    public long TokenRefreshCount => _totalTokenRefreshes;

    public void ClientCreated()
    {
        Interlocked.Increment(ref _totalClients);
        Interlocked.Increment(ref _currentClients);
    }

    public void ClientDisposed()
    {
        Interlocked.Decrement(ref _currentClients);
    }

    public void ConnectionCreated()
    {
        Interlocked.Increment(ref _totalConnections);
        Interlocked.Increment(ref _currentConnections);
    }

    public void ConnectionDisposed()
    {
        Interlocked.Decrement(ref _currentConnections);
    }

    public void ConsumerCreated()
    {
        Interlocked.Increment(ref _totalConsumers);
        Interlocked.Increment(ref _currentConsumers);
    }

    public void ConsumerDisposed()
    {
        Interlocked.Decrement(ref _currentConsumers);
    }

    public void ProducerCreated()
    {
        Interlocked.Increment(ref _totalProducers);
        Interlocked.Increment(ref _currentProducers);
    }

    public void ProducerDisposed()
    {
        Interlocked.Decrement(ref _currentProducers);
    }

    public void ReaderCreated()
    {
        Interlocked.Increment(ref _totalReaders);
        Interlocked.Increment(ref _currentReaders);
    }

    public void ReaderDisposed()
    {
        Interlocked.Decrement(ref _currentReaders);
    }

    public void TokenRefreshed()
    {
        Interlocked.Increment(ref _totalTokenRefreshes);
    }

    protected override void OnEventCommand(EventCommandEventArgs command)
    {
        if (command.Command != EventCommand.Enable)
            return;

        _totalClientsCounter ??= new PollingCounter("total-clients", this, () => Volatile.Read(ref _totalClients))
        {
            DisplayName = "Total number of clients"
        };

        _currentClientsCounter ??= new PollingCounter("current-clients", this, () => Volatile.Read(ref _currentClients))
        {
            DisplayName = "Current number of clients"
        };

        _totalConnectionsCounter ??= new PollingCounter("total-connections", this, () => Volatile.Read(ref _totalConnections))
        {
            DisplayName = "Total number of connections"
        };

        _currentConnectionsCounter ??= new PollingCounter("current-connections", this, () => Volatile.Read(ref _currentConnections))
        {
            DisplayName = "Current number of connections"
        };

        _totalConsumersCounter ??= new PollingCounter("total-consumers", this, () => Volatile.Read(ref _totalConsumers))
        {
            DisplayName = "Total number of consumers"
        };

        _currentConsumersCounter ??= new PollingCounter("current-consumers", this, () => Volatile.Read(ref _currentConsumers))
        {
            DisplayName = "Current number of consumers"
        };

        _totalProducersCounter ??= new PollingCounter("total-producers", this, () => Volatile.Read(ref _totalProducers))
        {
            DisplayName = "Total number of producers"
        };

        _currentProducersCounter ??= new PollingCounter("current-producers", this, () => Volatile.Read(ref _currentProducers))
        {
            DisplayName = "Current number of producers"
        };

        _totalReadersCounter ??= new PollingCounter("total-readers", this, () => Volatile.Read(ref _totalReaders))
        {
            DisplayName = "Total number of readers"
        };

        _currentReadersCounter ??= new PollingCounter("current-readers", this, () => Volatile.Read(ref _currentReaders))
        {
            DisplayName = "Current number of readers"
        };

        _tokenRefreshCounter ??= new PollingCounter("total-token-refreshes", this, () => Volatile.Read(ref _totalTokenRefreshes))
        {
            DisplayName = "Number of times token was refreshed"
        };
    }
}
#endif