ObsWebSocketClient.cs

using System;
using System.Collections.Generic;
using System.Net.WebSockets;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

namespace ObsHelper
{
    public enum ObsConnectionState { Disconnected, Connecting, Connected }

    /// <summary>
    /// Cliente ligero para OBS WebSocket v5 (OBS 28+).
    /// Soporta iniciar/detener grabación y notificaciones de estado en tiempo real.
    /// </summary>
    public class ObsWebSocketClient : IDisposable
    {
        private ClientWebSocket _ws;
        private CancellationTokenSource _cts;
        private Task _receiveTask;
        private readonly Dictionary<string, TaskCompletionSource<JObject>> _pending
            = new Dictionary<string, TaskCompletionSource<JObject>>();
        private readonly SynchronizationContext _syncCtx;
        private bool _disposed;

        public ObsConnectionState State       { get; private set; } = ObsConnectionState.Disconnected;
        public bool               IsRecording { get; private set; }

        /// <summary>Disparado en el hilo UI cuando cambia el estado de conexión.</summary>
        public event EventHandler<ObsConnectionState> ConnectionStateChanged;
        /// <summary>Disparado en el hilo UI cuando OBS inicia o detiene la grabación.</summary>
        public event EventHandler<bool>               RecordingStateChanged;
        /// <summary>Disparado en el hilo UI cuando ocurre un error inesperado.</summary>
        public event EventHandler<string>             ErrorOccurred;

        public ObsWebSocketClient()
        {
            // Capturar el SynchronizationContext de WinForms para despachar eventos en el hilo UI
            _syncCtx = SynchronizationContext.Current;
        }

        // ─────────────────────────────────────────────────────────────────────
        // API pública
        // ─────────────────────────────────────────────────────────────────────

        public async Task ConnectAsync(string host, int port, string password)
        {
            if (_disposed) throw new ObjectDisposedException(nameof(ObsWebSocketClient));
            if (State != ObsConnectionState.Disconnected)
                throw new InvalidOperationException("Ya está conectado o conectando.");

            Logger.Info($"Conectando a OBS WebSocket en ws://{host}:{port}");
            SetState(ObsConnectionState.Connecting);

            _cts = new CancellationTokenSource();
            _ws  = new ClientWebSocket();

            await _ws.ConnectAsync(new Uri("ws://" + host + ":" + port), _cts.Token);
            Logger.Info("TCP conectado. Esperando Hello...");

            // Paso 1: Recibir Hello (op=0)
            var hello     = await ReceiveMessageAsync(_cts.Token);
            var helloData = hello?["d"] as JObject;
            Logger.Debug($"Hello recibido: {hello}");

            // Paso 2: Calcular autenticación si es necesaria
            string authString = null;
            if (helloData?["authentication"] != null)
            {
                Logger.Info("OBS requiere autenticación. Calculando hash...");
                if (string.IsNullOrEmpty(password))
                    throw new Exception("OBS requiere contraseña pero no se proporcionó ninguna.");

                string salt      = helloData["authentication"]["salt"].Value<string>();
                string challenge = helloData["authentication"]["challenge"].Value<string>();
                authString = ComputeAuth(password, salt, challenge);
                Logger.Info("Hash de autenticación calculado correctamente.");
            }
            else
            {
                Logger.Info("OBS no requiere autenticación.");
            }

            // Paso 3: Enviar Identify (op=1)
            var identifyPayload = new JObject
            {
                ["rpcVersion"]         = 1,
                ["eventSubscriptions"] = 65  // General(1) | Outputs(64) — para RecordStateChanged
            };
            if (authString != null) identifyPayload["authentication"] = authString;

            Logger.Debug("Enviando Identify (op=1)...");
            await SendRawAsync(
                new JObject { ["op"] = 1, ["d"] = identifyPayload }.ToString(),
                _cts.Token);

            // Paso 4: Esperar Identified (op=2)
            var identified = await ReceiveMessageAsync(_cts.Token);
            Logger.Debug($"Identified recibido: {identified}");

            if (identified?["op"]?.Value<int>() != 2)
                throw new Exception("Handshake fallido. Verifica la contraseña de OBS WebSocket.");

            Logger.Info("Handshake completado. Conexión establecida.");
            SetState(ObsConnectionState.Connected);

            // Iniciar bucle de recepción en background
            _receiveTask = Task.Run(() => ReceiveLoopAsync(_cts.Token));

            // Consultar estado actual de grabación
            await RefreshRecordingStateAsync();
        }

        public async Task DisconnectAsync()
        {
            if (State == ObsConnectionState.Disconnected) return;

            Logger.Info("Desconectando de OBS WebSocket...");
            _cts?.Cancel();

            if (_ws?.State == WebSocketState.Open)
            {
                try
                {
                    using (var t = new CancellationTokenSource(2000))
                        await _ws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, t.Token);
                }
                catch (Exception ex)
                {
                    Logger.Warn("Excepción al cerrar WebSocket limpiamente: " + ex.Message);
                }
            }

            if (_receiveTask != null)
            {
                try { await _receiveTask; } catch { }
                _receiveTask = null;
            }

            _ws?.Dispose();
            _ws = null;

            Logger.Info("Desconectado.");
            if (State != ObsConnectionState.Disconnected)
                SetState(ObsConnectionState.Disconnected);
        }

        public Task StartRecordingAsync() => SendRequestAsync("StartRecord");
        public Task StopRecordingAsync()  => SendRequestAsync("StopRecord");

        public async Task RefreshRecordingStateAsync()
        {
            var resp = await SendRequestAsync("GetRecordStatus");
            bool active = resp?["outputActive"]?.Value<bool>() ?? false;
            IsRecording = active;
            RaiseEvent(RecordingStateChanged, IsRecording);
        }

        public async Task<string> GetRecordDirectoryAsync()
        {
            var resp = await SendRequestAsync("GetRecordDirectory");
            return resp?["recordDirectory"]?.Value<string>();
        }

        public Task SetRecordDirectoryAsync(string path)
        {
            return SendRequestAsync("SetRecordDirectory",
                new JObject { ["recordDirectory"] = path });
        }

        // ─────────────────────────────────────────────────────────────────────
        // Internos
        // ─────────────────────────────────────────────────────────────────────

        private async Task<JObject> SendRequestAsync(string requestType, JObject requestData = null)
        {
            if (_ws?.State != WebSocketState.Open)
                throw new InvalidOperationException("No hay conexión activa con OBS.");

            string id  = Guid.NewGuid().ToString("N");
            var    tcs = new TaskCompletionSource<JObject>();
            lock (_pending) _pending[id] = tcs;

            Logger.Debug($"Enviando request: {requestType} (id={id})");
            var d = new JObject { ["requestType"] = requestType, ["requestId"] = id };
            if (requestData != null) d["requestData"] = requestData;
            await SendRawAsync(new JObject { ["op"] = 6, ["d"] = d }.ToString(), _cts.Token);

            // Esperar respuesta con timeout de 5 segundos
            var timeout = Task.Delay(5000);
            if (await Task.WhenAny(tcs.Task, timeout) == timeout)
            {
                lock (_pending) _pending.Remove(id);
                Logger.Error($"Timeout esperando respuesta de OBS para: {requestType}");
                throw new TimeoutException("OBS no respondió a tiempo.");
            }

            var result = await tcs.Task;
            Logger.Debug($"Respuesta recibida para {requestType}: {result}");
            return result;
        }

        private async Task ReceiveLoopAsync(CancellationToken ct)
        {
            Logger.Info("Bucle de recepción iniciado.");
            try
            {
                while (!ct.IsCancellationRequested && _ws?.State == WebSocketState.Open)
                {
                    var msg = await ReceiveMessageAsync(ct);
                    if (msg == null)
                    {
                        Logger.Warn("WebSocket cerrado por el servidor (mensaje nulo).");
                        break;
                    }
                    HandleMessage(msg);
                }
            }
            catch (OperationCanceledException)
            {
                Logger.Info("Bucle de recepción cancelado (desconexión solicitada).");
            }
            catch (Exception ex)
            {
                Logger.Error("Error inesperado en el bucle de recepción.", ex);
                RaiseEvent(ErrorOccurred, "Conexión perdida: " + ex.Message);
            }
            finally
            {
                Logger.Info("Bucle de recepción terminado.");
                lock (_pending)
                {
                    foreach (var kv in _pending) kv.Value.TrySetCanceled();
                    _pending.Clear();
                }
                if (State == ObsConnectionState.Connected)
                    SetState(ObsConnectionState.Disconnected);
            }
        }

        private void HandleMessage(JObject msg)
        {
            int op = msg["op"]?.Value<int>() ?? -1;
            switch (op)
            {
                case 7: // RequestResponse
                {
                    string reqId = msg["d"]?["requestId"]?.Value<string>();
                    if (reqId == null) break;

                    TaskCompletionSource<JObject> tcs;
                    lock (_pending)
                    {
                        if (!_pending.TryGetValue(reqId, out tcs)) break;
                        _pending.Remove(reqId);
                    }

                    bool success = msg["d"]?["requestStatus"]?["result"]?.Value<bool>() ?? false;
                    string code  = msg["d"]?["requestStatus"]?["code"]?.ToString() ?? "?";
                    if (!success)
                        Logger.Warn($"OBS respondió con error al request {reqId}: code={code}, msg={msg["d"]?["requestStatus"]?["comment"]}");

                    tcs.TrySetResult(msg["d"]?["responseData"] as JObject ?? new JObject());
                    break;
                }
                case 5: // Event
                {
                    string eventType = msg["d"]?["eventType"]?.Value<string>();
                    Logger.Debug($"Evento recibido: {eventType}");

                    if (eventType == "RecordStateChanged")
                    {
                        bool active    = msg["d"]?["eventData"]?["outputActive"]?.Value<bool>() ?? false;
                        string outState = msg["d"]?["eventData"]?["outputState"]?.Value<string>() ?? "?";
                        Logger.Info($"RecordStateChanged → outputActive={active}, outputState={outState}");
                        IsRecording = active;
                        RaiseEvent(RecordingStateChanged, IsRecording);
                    }
                    break;
                }
                default:
                    Logger.Debug($"Mensaje recibido con op={op} (ignorado)");
                    break;
            }
        }

        private async Task<JObject> ReceiveMessageAsync(CancellationToken ct)
        {
            var buffer = new byte[65536];
            var sb     = new StringBuilder();
            WebSocketReceiveResult result;
            do
            {
                result = await _ws.ReceiveAsync(new ArraySegment<byte>(buffer), ct);
                if (result.MessageType == WebSocketMessageType.Close) return null;
                sb.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
            } while (!result.EndOfMessage);

            return JObject.Parse(sb.ToString());
        }

        private Task SendRawAsync(string text, CancellationToken ct)
        {
            var bytes = Encoding.UTF8.GetBytes(text);
            return _ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, ct);
        }

        private void SetState(ObsConnectionState state)
        {
            State = state;
            RaiseEvent(ConnectionStateChanged, state);
        }

        private void RaiseEvent<T>(EventHandler<T> handler, T arg)
        {
            if (handler == null) return;
            if (_syncCtx != null)
                _syncCtx.Post(_ => handler(this, arg), null);
            else
                handler(this, arg);
        }

        private static string ComputeAuth(string password, string salt, string challenge)
        {
            using (var sha = SHA256.Create())
            {
                // secret = base64( SHA256(password + salt) )
                byte[] s1     = sha.ComputeHash(Encoding.UTF8.GetBytes(password + salt));
                string secret = Convert.ToBase64String(s1);
                // auth   = base64( SHA256(secret + challenge) )
                byte[] s2     = sha.ComputeHash(Encoding.UTF8.GetBytes(secret + challenge));
                return Convert.ToBase64String(s2);
            }
        }

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            _cts?.Cancel();
            _ws?.Dispose();
        }
    }
}