WebSocket API

using System;
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

public class OilPriceWebSocket : IDisposable
{
    private const string WebSocketUrl = "wss://api.oilpriceapi.com/cable";
    private readonly string _apiKey;
    private ClientWebSocket _webSocket;
    private CancellationTokenSource _cancellationTokenSource;
    private int _reconnectAttempts;
    private const int MaxReconnects = 5;

    public OilPriceWebSocket(string apiKey)
    {
        _apiKey = apiKey;
        _webSocket = new ClientWebSocket();
        _cancellationTokenSource = new CancellationTokenSource();
    }

    public async Task ConnectAsync()
    {
        _webSocket = new ClientWebSocket();
        await _webSocket.ConnectAsync(new Uri(WebSocketUrl), _cancellationTokenSource.Token);

        Console.WriteLine("WebSocket connected");
        _reconnectAttempts = 0;

        await SubscribeAsync();
    }

    private async Task SubscribeAsync()
    {
        var identifier = JsonSerializer.Serialize(new
        {
            channel = "EnergyPricesChannel",
            api_key = _apiKey
        });

        var subscribeMessage = JsonSerializer.Serialize(new
        {
            command = "subscribe",
            identifier = identifier
        });

        var bytes = Encoding.UTF8.GetBytes(subscribeMessage);
        await _webSocket.SendAsync(
            new ArraySegment<byte>(bytes),
            WebSocketMessageType.Text,
            true,
            _cancellationTokenSource.Token
        );

        Console.WriteLine("Subscribed to EnergyPricesChannel");
    }

    public async Task ListenAsync()
    {
        var buffer = new byte[4096];

        while (_webSocket.State == WebSocketState.Open)
        {
            try
            {
                var result = await _webSocket.ReceiveAsync(
                    new ArraySegment<byte>(buffer),
                    _cancellationTokenSource.Token
                );

                if (result.MessageType == WebSocketMessageType.Close)
                {
                    await ReconnectAsync();
                    return;
                }

                var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                HandleMessage(message);
            }
            catch (WebSocketException ex)
            {
                Console.WriteLine($"WebSocket error: {ex.Message}");
                await ReconnectAsync();
                return;
            }
        }
    }

    private void HandleMessage(string rawMessage)
    {
        try
        {
            using var doc = JsonDocument.Parse(rawMessage);
            var root = doc.RootElement;

            // Skip ping messages
            if (root.TryGetProperty("type", out var type) && type.GetString() == "ping")
            {
                return;
            }

            // Handle price updates
            if (root.TryGetProperty("message", out var message))
            {
                if (message.TryGetProperty("type", out var msgType) &&
                    msgType.GetString() == "price_update")
                {
                    var data = message.GetProperty("data");
                    var code = data.GetProperty("code").GetString();
                    var price = data.GetProperty("price").GetDouble();
                    var change = data.GetProperty("change_percent").GetDouble();

                    Console.WriteLine($"{code}: ${price:F2} ({change:F2}%)");
                }
            }
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"JSON parse error: {ex.Message}");
        }
    }

    private async Task ReconnectAsync()
    {
        if (_reconnectAttempts >= MaxReconnects)
        {
            Console.WriteLine("Max reconnection attempts reached");
            return;
        }

        _reconnectAttempts++;
        var delay = _reconnectAttempts * 5000;
        Console.WriteLine($"Reconnecting in {delay}ms (attempt {_reconnectAttempts}/{MaxReconnects})");

        await Task.Delay(delay);

        try
        {
            _webSocket.Dispose();
            await ConnectAsync();
            _ = ListenAsync();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Reconnection failed: {ex.Message}");
            await ReconnectAsync();
        }
    }

    public async Task DisconnectAsync()
    {
        if (_webSocket.State == WebSocketState.Open)
        {
            await _webSocket.CloseAsync(
                WebSocketCloseStatus.NormalClosure,
                "Client disconnect",
                CancellationToken.None
            );
        }
    }

    public void Dispose()
    {
        _cancellationTokenSource.Cancel();
        _webSocket?.Dispose();
        _cancellationTokenSource?.Dispose();
    }
}

// Usage
class Program
{
    static async Task Main(string[] args)
    {
        using var client = new OilPriceWebSocket("YOUR_API_KEY");

        Console.CancelKeyPress += async (sender, e) =>
        {
            e.Cancel = true;
            Console.WriteLine("\nShutting down...");
            await client.DisconnectAsync();
        };

        await client.ConnectAsync();
        await client.ListenAsync();
    }
}