MainForm.cs

using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using Newtonsoft.Json.Linq;
using QRCoder;

namespace ObsHelper
{
    public partial class MainForm : Form
    {
        private SettingsManager    _settings;
        private ObsWebSocketClient _obsClient;
        private Timer              _diskTimer;
        private double             _diskUsedPercent;
        private WebServer          _webServer;

        // Estado accesible desde el hilo del servidor HTTP
        private volatile bool _isObsConnected;
        private volatile bool _isRecording;
        private string _lastFileForApi;
        private string _lastFilePathForApi;
        private readonly object _apiLock = new object();

        public MainForm()
        {
            Logger.SessionStart();
            Logger.Info("Iniciando OBS Recording Helper...");

            string iniPath = Path.Combine(Application.StartupPath, "settings.ini");
            _settings = new SettingsManager(iniPath);
            _settings.Load();
            Logger.Info($"Configuración cargada — ObsFolder={_settings.ObsFolder} | WsHost={_settings.ObsWsHost}:{_settings.ObsWsPort}");

            InitializeComponent();

            // Aplicar configuración guardada a los controles
            _txtObsFolder.Text     = _settings.ObsFolder;
            _txtVlcPath.Text       = _settings.VlcPath;
            _txtObsWsHost.Text     = _settings.ObsWsHost;
            _txtObsWsPort.Text     = _settings.ObsWsPort.ToString();
            _txtObsWsPassword.Text = _settings.ObsWsPassword;

            RefreshLastFile();
            UpdateDiskSpace();

            _diskTimer          = new Timer { Interval = 30_000 };
            _diskTimer.Tick    += (s, e) => UpdateDiskSpace();
            _diskTimer.Start();

            // Crear cliente OBS (debe hacerse tras InitializeComponent para capturar el SynchronizationContext)
            _obsClient = new ObsWebSocketClient();
            _obsClient.ConnectionStateChanged += OnObsConnectionStateChanged;
            _obsClient.RecordingStateChanged  += OnObsRecordingStateChanged;
            _obsClient.ErrorOccurred          += OnObsError;

            if (!Directory.Exists(_settings.ObsFolder))
            {
                _tabControl.SelectedIndex = 2;  // ir a Configuración
                SetStatus("Configura la carpeta de grabaciones de OBS para comenzar.", Color.DarkOrange);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Servidor web móvil
        // ─────────────────────────────────────────────────────────────────────

        private void BtnToggleServer_Click(object sender, EventArgs e)
        {
            if (_webServer != null && _webServer.IsRunning)
                StopWebServer();
            else
                StartWebServer();
        }

        private void StartWebServer()
        {
            try
            {
                _webServer = new WebServer(
                    _settings.WebServerPort,
                    GetStatusJson,
                    () => _obsClient.StartRecordingAsync(),
                    () => _obsClient.StopRecordingAsync(),
                    () => Task.Run(() => Invoke(new Action(async () =>
                    {
                        try { await _obsClient.ConnectAsync(_settings.ObsWsHost, _settings.ObsWsPort, _settings.ObsWsPassword); }
                        catch (Exception ex) { SetStatus("Error al conectar desde móvil: " + ex.Message, Color.OrangeRed); }
                    }))),
                    () => Task.Run(() => Invoke(new Action(async () =>
                    {
                        try { await _obsClient.DisconnectAsync(); }
                        catch (Exception ex) { SetStatus("Error al desconectar desde móvil: " + ex.Message, Color.OrangeRed); }
                    })))
                );

                _webServer.Start();

                string ip  = WebServer.GetLocalIp();
                string url = $"http://{ip}:{_settings.WebServerPort}";

                lblQrUrl.Text = url;
                picQr.Image   = GenerateQr(url);
                picQr.Visible           = true;
                lblQrPlaceholder.Visible = false;

                btnToggleServer.Text       = "Detener servidor";
                btnToggleServer.ColorStart = Color.FromArgb(183, 28, 28);
                btnToggleServer.ColorEnd   = Color.FromArgb(139, 10, 10);
                btnToggleServer.Invalidate();

                SetStatus($"Servidor móvil iniciado en {url}", Color.FromArgb(61, 185, 110));
                Logger.Info($"WebServer iniciado en {url}");
            }
            catch (Exception ex)
            {
                Logger.Error("Error al iniciar el servidor web.", ex);
                SetStatus("Error al iniciar el servidor: " + ex.Message, Color.OrangeRed);
            }
        }

        private void StopWebServer()
        {
            _webServer?.Stop();
            _webServer?.Dispose();
            _webServer = null;

            picQr.Image?.Dispose();
            picQr.Image            = null;
            picQr.Visible          = false;
            lblQrPlaceholder.Visible = true;
            lblQrUrl.Text          = "Servidor detenido";

            btnToggleServer.Text       = "Iniciar servidor";
            btnToggleServer.ColorStart = Color.FromArgb(0, 120, 212);
            btnToggleServer.ColorEnd   = Color.FromArgb(0, 90, 158);
            btnToggleServer.Invalidate();

            SetStatus("Servidor móvil detenido.");
            Logger.Info("WebServer detenido.");
        }

        private string GetStatusJson()
        {
            string file, path;
            lock (_apiLock) { file = _lastFileForApi; path = _lastFilePathForApi; }

            var obj = new JObject
            {
                ["obsConnected"] = _isObsConnected,
                ["recording"]    = _isRecording,
                ["lastFile"]     = file,
                ["lastFilePath"] = path
            };
            return obj.ToString(Newtonsoft.Json.Formatting.None);
        }

        private static Bitmap GenerateQr(string url)
        {
            using (var gen  = new QRCodeGenerator())
            using (var data = gen.CreateQrCode(url, QRCodeGenerator.ECCLevel.Q))
            {
                var qr = new QRCode(data);
                return qr.GetGraphic(8, Color.White, Color.FromArgb(44, 44, 44), drawQuietZones: true);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Helpers de UI
        // ─────────────────────────────────────────────────────────────────────

        // ─────────────────────────────────────────────────────────────────────
        // Espacio en disco
        // ─────────────────────────────────────────────────────────────────────

        private void UpdateDiskSpace()
        {
            try
            {
                string folder = !string.IsNullOrEmpty(_settings.ObsFolder)
                    ? _settings.ObsFolder
                    : Application.StartupPath;

                var drive = new DriveInfo(Path.GetPathRoot(folder));
                long free  = drive.AvailableFreeSpace;
                long total = drive.TotalSize;
                _diskUsedPercent = 1.0 - (double)free / total;

                double freeGb = free / 1_073_741_824.0;

                lblDriveName.Text = $"DISCO ({drive.Name.TrimEnd('\\')})";
                lblDiskFree.Text  = $"{freeGb:F1} GB libres";
                pnlDiskBarBg.Invalidate();
            }
            catch
            {
                lblDriveName.Text = "DISCO";
                lblDiskFree.Text  = "N/D";
            }

            UpdateFolderButton();
        }

        private void UpdateFolderButton()
        {
            if (!string.IsNullOrEmpty(_settings.ObsFolder) && Directory.Exists(_settings.ObsFolder))
            {
                btnOpenFolder.Text      = "→  " + _settings.ObsFolder;
                btnOpenFolder.ForeColor = Color.FromArgb(0, 120, 212);
            }
            else if (!string.IsNullOrEmpty(_settings.ObsFolder))
            {
                btnOpenFolder.Text      = "→  " + _settings.ObsFolder + "  (carpeta no encontrada)";
                btnOpenFolder.ForeColor = Color.FromArgb(200, 100, 50);
            }
            else
            {
                btnOpenFolder.Text      = "→  Sin configurar — ve a Ajustes";
                btnOpenFolder.ForeColor = Color.FromArgb(138, 138, 138);
            }
        }

        private void PnlDiskBarBg_Paint(object sender, PaintEventArgs e)
        {
            var panel = (Panel)sender;
            int fillWidth = (int)(panel.Width * _diskUsedPercent);
            if (fillWidth <= 0) return;

            using (var brush = new SolidBrush(GetDiskBarColor(_diskUsedPercent)))
                e.Graphics.FillRectangle(brush, 0, 0, fillWidth, panel.Height);
        }

        private Color GetDiskBarColor(double used)
        {
            // Verde → Amarillo (0 – 65%)
            if (used <= 0.65)
                return Lerp(Color.FromArgb(22, 163, 74), Color.FromArgb(234, 179, 8), used / 0.65);

            // Amarillo → Naranja (65 – 85%)
            if (used <= 0.85)
                return Lerp(Color.FromArgb(234, 179, 8), Color.FromArgb(249, 115, 22), (used - 0.65) / 0.20);

            // Naranja → Rojo (85 – 100%)
            return Lerp(Color.FromArgb(249, 115, 22), Color.FromArgb(220, 38, 38), (used - 0.85) / 0.15);
        }

        private static Color Lerp(Color a, Color b, double t)
        {
            t = Math.Max(0, Math.Min(1, t));
            return Color.FromArgb(
                (int)(a.R + (b.R - a.R) * t),
                (int)(a.G + (b.G - a.G) * t),
                (int)(a.B + (b.B - a.B) * t));
        }

        private void SetStatus(string msg, Color? color = null)
        {
            _statusLabel.Text      = msg;
            _statusLabel.ForeColor = color ?? Color.FromArgb(61, 185, 110);
        }

        // ─────────────────────────────────────────────────────────────────────
        // Tab bar personalizada
        // ─────────────────────────────────────────────────────────────────────

        private static readonly string[] _tabLabels = { "GRABACIÓN", "OBS CONTROL", "AJUSTES" };

        private void TabControl_DrawItem(object sender, DrawItemEventArgs e)
        {
            var g      = e.Graphics;
            bool sel   = (e.Index == _tabControl.SelectedIndex);
            var bounds = e.Bounds;

            // Fondo de la barra de pestañas
            using (var bg = new SolidBrush(Color.FromArgb(26, 26, 26)))
                g.FillRectangle(bg, bounds);

            // Texto de la pestaña
            Color fg = sel ? Color.White : Color.FromArgb(138, 138, 138);
            TextRenderer.DrawText(g, _tabLabels[e.Index], _tabLabelFont, bounds, fg,
                TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);

            // Indicador azul (Windows Fluent) en el borde superior de la pestaña
            // (TabAlignment=Bottom → el borde superior del tab strip es el lado pegado al contenido)
            if (sel)
            {
                int iw = bounds.Width / 3;
                var ind = new Rectangle(bounds.X + (bounds.Width - iw) / 2, bounds.Y + 2, iw, 3);
                using (var b = new SolidBrush(Color.FromArgb(0, 120, 212)))
                    g.FillRectangle(b, ind);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Lógica de archivos
        // ─────────────────────────────────────────────────────────────────────

        private string GetNewestFile()
        {
            if (string.IsNullOrEmpty(_settings.ObsFolder) || !Directory.Exists(_settings.ObsFolder))
                return null;

            return new DirectoryInfo(_settings.ObsFolder)
                .GetFiles()
                .Where(f => (f.Attributes & FileAttributes.Hidden) == 0)
                .OrderByDescending(f => f.LastWriteTime)
                .Select(f => f.FullName)
                .FirstOrDefault();
        }

        private void RefreshLastFile()
        {
            string file = GetNewestFile();
            if (file != null)
            {
                _lblLastFile.Text       = Path.GetFileName(file);
                _lblLastFile.ForeColor  = Color.White;
                lblFileSubtext.Text     = Path.GetDirectoryName(file);
                lblFileSubtext.ForeColor = Color.FromArgb(90, 90, 90);

                lock (_apiLock)
                {
                    _lastFileForApi     = Path.GetFileName(file);
                    _lastFilePathForApi = Path.GetDirectoryName(file);
                }
            }
            else
            {
                _lblLastFile.Text        = "Sin archivos detectados";
                _lblLastFile.ForeColor   = Color.FromArgb(173, 170, 170);
                lblFileSubtext.Text      = "Inicia una grabacion para ver los resultados aqui";
                lblFileSubtext.ForeColor = Color.FromArgb(90, 90, 90);

                lock (_apiLock)
                {
                    _lastFileForApi     = null;
                    _lastFilePathForApi = null;
                }
            }
        }

        private void MoveFile(string subfolder, string successMsg)
        {
            string file = GetNewestFile();
            if (file == null) { SetStatus("No se encontró ningún archivo.", Color.OrangeRed); return; }

            try
            {
                string destDir  = Path.Combine(_settings.ObsFolder, subfolder);
                Directory.CreateDirectory(destDir);
                string destFile = Path.Combine(destDir, Path.GetFileName(file));

                if (File.Exists(destFile))
                    destFile = Path.Combine(destDir,
                        Path.GetFileNameWithoutExtension(file)
                        + "_" + DateTime.Now.ToString("yyyyMMddHHmmss")
                        + Path.GetExtension(file));

                File.Move(file, destFile);
                SetStatus(successMsg + ": " + Path.GetFileName(file), Color.FromArgb(16, 124, 16));
                RefreshLastFile();
            }
            catch (Exception ex)
            {
                SetStatus("Error: " + ex.Message, Color.OrangeRed);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Eventos de OBS WebSocket
        // ─────────────────────────────────────────────────────────────────────

        private void OnObsConnectionStateChanged(object sender, ObsConnectionState state)
        {
            switch (state)
            {
                case ObsConnectionState.Connecting:
                    _lblObsStatus.Text      = "Conectando...";
                    _lblObsStatus.ForeColor = Color.DarkOrange;
                    _btnConnect.Enabled     = false;
                    _btnDisconnect.Enabled  = false;
                    SetStatus("Conectando a OBS…", Color.DarkOrange);
                    break;

                case ObsConnectionState.Connected:
                    _isObsConnected         = true;
                    _lblObsStatus.Text      = "Conectado";
                    _lblObsStatus.ForeColor = Color.FromArgb(61, 185, 110);
                    _btnConnect.Enabled     = false;
                    _btnDisconnect.Enabled  = true;
                    _btnStartRecord.Enabled = true;
                    _btnStopRecord.Enabled  = true;
                    SetStatus("Conectado a OBS WebSocket.", Color.FromArgb(16, 124, 16));
                    _ = SyncFolderFromObsAsync();
                    break;

                case ObsConnectionState.Disconnected:
                    _isObsConnected         = false;
                    _isRecording            = false;
                    _lblObsStatus.Text      = "Desconectado";
                    _lblObsStatus.ForeColor = Color.FromArgb(173, 170, 170);
                    _btnConnect.Enabled     = true;
                    _btnDisconnect.Enabled  = false;
                    _btnStartRecord.Enabled = false;
                    _btnStopRecord.Enabled  = false;
                    _lblRecordStatus.Text      = "●  Inactiva";
                    _lblRecordStatus.ForeColor = Color.FromArgb(173, 170, 170);
                    SetStatus("Desconectado de OBS.");
                    break;
            }
        }

        private void OnObsRecordingStateChanged(object sender, bool isRecording)
        {
            _isRecording = isRecording;
            if (isRecording)
            {
                _lblRecordStatus.Text      = "⏺  Grabando";
                _lblRecordStatus.ForeColor = Color.FromArgb(255, 113, 99);
                SetStatus("OBS grabando.", Color.FromArgb(196, 43, 28));
            }
            else
            {
                _lblRecordStatus.Text      = "●  Inactiva";
                _lblRecordStatus.ForeColor = Color.FromArgb(173, 170, 170);
                SetStatus("Grabación detenida.");
                RefreshLastFile();
            }
        }

        private void OnObsError(object sender, string message)
        {
            SetStatus(message, Color.OrangeRed);
        }

        // ─────────────────────────────────────────────────────────────────────
        // Handlers – pestaña OBS
        // ─────────────────────────────────────────────────────────────────────

        private async void BtnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                await _obsClient.ConnectAsync(_settings.ObsWsHost, _settings.ObsWsPort, _settings.ObsWsPassword);
            }
            catch (Exception ex)
            {
                Logger.Error("Fallo al conectar con OBS.", ex);
                SetStatus("Error al conectar: " + ex.Message, Color.OrangeRed);
                _btnConnect.Enabled     = true;
                _btnDisconnect.Enabled  = false;
                _lblObsStatus.Text      = "●  Desconectado";
                _lblObsStatus.ForeColor = Color.Gray;
            }
        }

        private async void BtnDisconnect_Click(object sender, EventArgs e)
        {
            try
            {
                await _obsClient.DisconnectAsync();
            }
            catch (Exception ex)
            {
                Logger.Error("Fallo al desconectar de OBS.", ex);
                SetStatus("Error al desconectar: " + ex.Message, Color.OrangeRed);
            }
        }

        private async void BtnStartRecord_Click(object sender, EventArgs e)
        {
            Logger.Info("Usuario pulsó Iniciar Grabación.");
            try
            {
                await _obsClient.StartRecordingAsync();
            }
            catch (Exception ex)
            {
                Logger.Error("Fallo al iniciar grabación.", ex);
                SetStatus("Error al iniciar grabación: " + ex.Message, Color.OrangeRed);
            }
        }

        private async void BtnStopRecord_Click(object sender, EventArgs e)
        {
            Logger.Info("Usuario pulsó Detener Grabación.");
            try
            {
                await _obsClient.StopRecordingAsync();
            }
            catch (Exception ex)
            {
                Logger.Error("Fallo al detener grabación.", ex);
                SetStatus("Error al detener grabación: " + ex.Message, Color.OrangeRed);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Handlers – pestaña Grabación
        // ─────────────────────────────────────────────────────────────────────

        private void BtnPlay_Click(object sender, EventArgs e)
        {
            string file = GetNewestFile();
            if (file == null) { SetStatus("No se encontró ningún archivo.", Color.OrangeRed); return; }

            if (!File.Exists(_settings.VlcPath))
            {
                SetStatus("VLC no encontrado. Comprueba la configuración.", Color.OrangeRed);
                return;
            }

            try
            {
                Process.Start(_settings.VlcPath, "--play-and-exit --fullscreen \"" + file + "\"");
                SetStatus("Reproduciendo: " + Path.GetFileName(file));
            }
            catch (Exception ex)
            {
                SetStatus("Error al abrir VLC: " + ex.Message, Color.OrangeRed);
            }
        }

        private void BtnClose_Click(object sender, EventArgs e)
        {
            var procs = Process.GetProcessesByName("vlc");
            foreach (var p in procs)
            {
                try { p.Kill(); } catch { }
                p.Dispose();
            }
            SetStatus(procs.Length > 0 ? "Reproductor cerrado." : "No había ningún reproductor abierto.");
        }

        private void BtnRefresh_Click(object sender, EventArgs e) => RefreshLastFile();
        private void BtnKeep_Click  (object sender, EventArgs e) => MoveFile(".keep",  "Archivo conservado");
        private void BtnDelete_Click(object sender, EventArgs e) => MoveFile(".trash", "Archivo eliminado");

        private void BtnOpenFolder_Click(object sender, EventArgs e)
        {
            string folder = _settings.ObsFolder;
            if (string.IsNullOrEmpty(folder))
            {
                SetStatus("No hay carpeta configurada. Ve a Ajustes.", Color.OrangeRed);
                _tabControl.SelectedIndex = 2;
                return;
            }
            if (!Directory.Exists(folder))
            {
                SetStatus("La carpeta no existe: " + folder, Color.OrangeRed);
                return;
            }
            try   { Process.Start("explorer.exe", folder); }
            catch (Exception ex) { SetStatus("Error al abrir el explorador: " + ex.Message, Color.OrangeRed); }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Handlers – pestaña Configuración
        // ─────────────────────────────────────────────────────────────────────

        private void BtnBrowseObs_Click(object sender, EventArgs e)
        {
            using (var d = new FolderBrowserDialog { Description = "Selecciona la carpeta donde OBS guarda las grabaciones" })
            {
                if (Directory.Exists(_txtObsFolder.Text)) d.SelectedPath = _txtObsFolder.Text;
                if (d.ShowDialog() == DialogResult.OK) _txtObsFolder.Text = d.SelectedPath;
            }
        }

        private void BtnBrowseVlc_Click(object sender, EventArgs e)
        {
            using (var d = new OpenFileDialog
            {
                Title    = "Selecciona el ejecutable de VLC",
                Filter   = "Ejecutables (*.exe)|*.exe|Todos los archivos (*.*)|*.*",
                FileName = "vlc.exe"
            })
            {
                if (File.Exists(_txtVlcPath.Text)) d.InitialDirectory = Path.GetDirectoryName(_txtVlcPath.Text);
                if (d.ShowDialog() == DialogResult.OK) _txtVlcPath.Text = d.FileName;
            }
        }

        private void BtnDetectVlc_Click(object sender, EventArgs e)
        {
            string path = SettingsManager.DetectVlc();
            if (path != null)
            {
                _txtVlcPath.Text = path;
                SetStatus("VLC detectado en: " + path, Color.FromArgb(16, 124, 16));
            }
            else
            {
                SetStatus("VLC no encontrado automáticamente. Selecciónalo manualmente.", Color.OrangeRed);
            }
        }

        private async void BtnSave_Click(object sender, EventArgs e)
        {
            _settings.ObsFolder     = _txtObsFolder.Text.Trim();
            _settings.VlcPath       = _txtVlcPath.Text.Trim();
            _settings.ObsWsHost     = _txtObsWsHost.Text.Trim();
            _settings.ObsWsPassword = _txtObsWsPassword.Text;

            if (int.TryParse(_txtObsWsPort.Text.Trim(), out int port) && port > 0 && port < 65536)
                _settings.ObsWsPort = port;
            else
            {
                Logger.Warn("Puerto WebSocket inválido introducido: " + _txtObsWsPort.Text);
                SetStatus("Puerto WebSocket inválido. Usa un número entre 1 y 65535.", Color.OrangeRed);
                return;
            }

            _settings.Save();
            Logger.Info($"Configuración guardada — ObsFolder={_settings.ObsFolder} | WsHost={_settings.ObsWsHost}:{_settings.ObsWsPort}");

            if (_obsClient?.State == ObsConnectionState.Connected)
            {
                try
                {
                    await _obsClient.SetRecordDirectoryAsync(_settings.ObsFolder);
                    Logger.Info($"Carpeta de grabación actualizada en OBS: {_settings.ObsFolder}");
                    SetStatus("Configuración guardada y sincronizada con OBS.", Color.FromArgb(16, 124, 16));
                }
                catch (Exception ex)
                {
                    Logger.Warn("No se pudo sincronizar la carpeta con OBS: " + ex.Message);
                    SetStatus("Carpeta guardada, pero no se pudo sincronizar con OBS: " + ex.Message, Color.DarkOrange);
                }
            }
            else
            {
                SetStatus("Configuración guardada.", Color.FromArgb(16, 124, 16));
            }

            RefreshLastFile();
            UpdateDiskSpace();
        }

        private async Task SyncFolderFromObsAsync()
        {
            try
            {
                string obsDir = await _obsClient.GetRecordDirectoryAsync();
                if (string.IsNullOrEmpty(obsDir) || obsDir == _settings.ObsFolder) return;

                _settings.ObsFolder = obsDir;
                _settings.Save();
                _txtObsFolder.Text = obsDir;
                RefreshLastFile();
                UpdateDiskSpace();
                Logger.Info($"Carpeta sincronizada desde OBS: {obsDir}");
                SetStatus($"Carpeta sincronizada desde OBS: {obsDir}", Color.FromArgb(61, 185, 110));
            }
            catch (Exception ex)
            {
                Logger.Warn("No se pudo leer la carpeta de grabación de OBS: " + ex.Message);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // Ciclo de vida del formulario
        // ─────────────────────────────────────────────────────────────────────

        protected override async void OnFormClosing(FormClosingEventArgs e)
        {
            base.OnFormClosing(e);
            Logger.Info("Cerrando aplicación...");
            _diskTimer?.Stop();
            _diskTimer?.Dispose();
            StopWebServer();
            if (_obsClient != null)
            {
                try { await _obsClient.DisconnectAsync(); } catch { }
                _obsClient.Dispose();
            }
            Logger.Info("Aplicación cerrada.");
        }
    }
}