1. Voice Volume Tracker - Parte 3: Seguridad, Anti-patrones y Conclusiones

// VoiceTracker.Infrastructure/Security/EmbeddingEncryption.cs
using System.Security.Cryptography;

public class EmbeddingEncryption
{
    private readonly byte[] _key;
    private readonly byte[] _iv;

    public EmbeddingEncryption(string masterPassword)
    {
        // Derivar key e IV del password usando PBKDF2
        using var pbkdf2 = new Rfc2898DeriveBytes(
            masterPassword,
            salt: Encoding.UTF8.GetBytes("VoiceTracker_Salt_v1"),
            iterations: 100000,
            HashAlgorithmName.SHA256
        );

        _key = pbkdf2.GetBytes(32); // 256 bits
        _iv = pbkdf2.GetBytes(16);  // 128 bits
    }

    public byte[] Encrypt(float[] embedding)
    {
        using var aes = Aes.Create();
        aes.Key = _key;
        aes.IV = _iv;

        using var encryptor = aes.CreateEncryptor();
        using var ms = new MemoryStream();
        using var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
        using var bw = new BinaryWriter(cs);

        foreach (var value in embedding)
        {
            bw.Write(value);
        }

        cs.FlushFinalBlock();
        return ms.ToArray();
    }

    public float[] Decrypt(byte[] encryptedData)
    {
        using var aes = Aes.Create();
        aes.Key = _key;
        aes.IV = _iv;

        using var decryptor = aes.CreateDecryptor();
        using var ms = new MemoryStream(encryptedData);
        using var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
        using var br = new BinaryReader(cs);

        var embedding = new List<float>();
        while (ms.Position < ms.Length)
        {
            try
            {
                embedding.Add(br.ReadSingle());
            }
            catch (EndOfStreamException)
            {
                break;
            }
        }

        return embedding.ToArray();
    }
}

// VoiceTracker.Infrastructure/Logging/SecureLogger.cs
using Serilog;

public class SecureLogger
{
    private readonly ILogger _logger;

    public SecureLogger()
    {
        _logger = new LoggerConfiguration()
            .WriteTo.File("logs/voice-tracker-.log", rollingInterval: RollingInterval.Day)
            .CreateLogger();
    }

    public void LogVolumeReading(Decibel volume, bool isUserVoice, AlertLevel level)
    {
        // ✅ BIEN: Solo metadatos
        _logger.Information(
            "Volume reading: {Volume} dB, IsUser: {IsUser}, Alert: {Level}",
            volume.Value,
            isUserVoice,
            level
        );
    }

    public void LogAudioSamples(float[] samples)
    {
        // ❌ MAL: NUNCA hacer esto
        // _logger.Debug("Audio samples: {Samples}", samples);

        // ✅ BIEN: Solo metadatos
        _logger.Debug("Processed audio frame with {SampleCount} samples", samples.Length);
    }

    public void LogEmbedding(float[] embedding)
    {
        // ❌ MAL: NUNCA hacer esto
        // _logger.Debug("Embedding: {Embedding}", embedding);

        // ✅ BIEN: Solo hash o ID
        var hash = ComputeHash(embedding);
        _logger.Debug("Processed embedding with hash: {Hash}", hash);
    }

    private string ComputeHash(float[] data)
    {
        using var sha256 = SHA256.Create();
        var bytes = new byte[data.Length * sizeof(float)];
        Buffer.BlockCopy(data, 0, bytes, 0, bytes.Length);
        var hash = sha256.ComputeHash(bytes);
        return Convert.ToBase64String(hash);
    }
}

// VoiceTracker.Infrastructure/Audio/MicrophonePermissions.cs
using Windows.Media.Capture;

public class MicrophonePermissions
{
    public async Task<bool> RequestPermissionAsync()
    {
        try
        {
            var settings = new MediaCaptureInitializationSettings
            {
                StreamingCaptureMode = StreamingCaptureMode.Audio
            };

            using var capture = new MediaCapture();
            await capture.InitializeAsync(settings);

            return true;
        }
        catch (UnauthorizedAccessException)
        {
            return false;
        }
    }

    public async Task<bool> CheckPermissionAsync()
    {
        var status = await Windows.Media.Capture.MediaCapture
            .RequestAccessAsync(Windows.Media.Capture.MediaCaptureKind.Audio);

        return status == Windows.Media.Capture.MediaCaptureAccessStatus.Allowed;
    }
}

// VoiceTracker.Service/VoiceMonitorService.cs
public class VoiceMonitorService : ServiceBase
{
    protected override async void OnStart(string[] args)
    {
        var permissions = new MicrophonePermissions();

        if (!await permissions.CheckPermissionAsync())
        {
            _logger.Error("Microphone permission denied. Service cannot start.");
            Stop();
            return;
        }

        // Continuar con inicio del servicio...
    }
}

// VoiceTracker.Infrastructure/Audio/FalsePositiveFilter.cs
public class FalsePositiveFilter
{
    private readonly Queue<bool> _recentDetections = new();
    private readonly int _windowSize = 5;
    private readonly double _confidenceThreshold = 0.6;

    public bool IsConfidentDetection(bool currentDetection)
    {
        _recentDetections.Enqueue(currentDetection);

        if (_recentDetections.Count > _windowSize)
            _recentDetections.Dequeue();

        // Requiere que al menos 60% de las últimas detecciones sean positivas
        var positiveRatio = _recentDetections.Count(d => d) / (double)_recentDetections.Count;

        return positiveRatio >= _confidenceThreshold;
    }
}

// VoiceTracker.Service/OptimizedBackgroundWorker.cs
public class OptimizedBackgroundWorker
{
    private readonly BlockingCollection<AudioFrame> _audioQueue = new();
    private readonly CancellationTokenSource _cts = new();

    public void Start()
    {
        // Producer: Captura de audio (thread separado)
        Task.Run(() => CaptureAudioLoop(_cts.Token));

        // Consumer: Procesamiento (thread separado)
        Task.Run(() => ProcessAudioLoop(_cts.Token));
    }

    private async Task CaptureAudioLoop(CancellationToken ct)
    {
        var capture = new AudioCapture();
        capture.AudioFrameReady += (s, e) =>
        {
            // No bloquear: agregar a cola
            if (!_audioQueue.TryAdd(e.Frame, 100))
            {
                // Si la cola está llena, descartar frame antiguo
                _audioQueue.TryTake(out _);
                _audioQueue.TryAdd(e.Frame);
            }
        };

        capture.Start();
        await Task.Delay(Timeout.Infinite, ct);
    }

    private async Task ProcessAudioLoop(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            if (_audioQueue.TryTake(out var frame, 100))
            {
                // Procesamiento asíncrono
                await ProcessFrameAsync(frame);
            }
        }
    }

    private async Task ProcessFrameAsync(AudioFrame frame)
    {
        // Ejecutar en thread pool para no bloquear
        await Task.Run(() =>
        {
            var volume = _calculator.Calculate(frame.Samples);
            var isUser = _verifier.IsUserSpeaking(frame.Samples);
            _fsm.ProcessAudioFrame(frame, isUser, volume);
        });
    }
}

// VoiceTracker.Infrastructure/Audio/ResourceManager.cs
public class ResourceManager : IDisposable
{
    private readonly List<IDisposable> _resources = new();
    private readonly Timer _gcTimer;

    public ResourceManager()
    {
        // Forzar GC cada 5 minutos
        _gcTimer = new Timer(_ =>
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
    }

    public T Register<T>(T resource) where T : IDisposable
    {
        _resources.Add(resource);
        return resource;
    }

    public void Dispose()
    {
        foreach (var resource in _resources)
        {
            resource?.Dispose();
        }
        _resources.Clear();
        _gcTimer?.Dispose();
    }
}

// Uso
using var resourceManager = new ResourceManager();
var capture = resourceManager.Register(new AudioCapture());
var extractor = resourceManager.Register(new EmbeddingExtractor("model.onnx"));

// VoiceTracker.Domain/Services/AdaptiveVoiceProfile.cs
public class AdaptiveVoiceProfile
{
    private VoiceProfile _profile;
    private readonly Queue<float[]> _recentEmbeddings = new();
    private readonly int _adaptationWindowSize = 50;

    public void AdaptToNewEnvironment(float[] newEmbedding, double similarity)
    {
        // Si la similitud es moderada (0.6-0.75), adaptar gradualmente
        if (similarity >= 0.6 && similarity < 0.75)
        {
            _recentEmbeddings.Enqueue(newEmbedding);

            if (_recentEmbeddings.Count > _adaptationWindowSize)
                _recentEmbeddings.Dequeue();

            // Cada 50 muestras, actualizar embedding de referencia
            if (_recentEmbeddings.Count == _adaptationWindowSize)
            {
                var adaptedEmbedding = AverageEmbeddings(_recentEmbeddings.ToList());

                // Mezclar con embedding original (80% original, 20% adaptado)
                _profile.ReferenceEmbedding = BlendEmbeddings(
                    _profile.ReferenceEmbedding.Values,
                    adaptedEmbedding,
                    alpha: 0.8
                );
            }
        }
    }

    private float[] BlendEmbeddings(float[] original, float[] adapted, double alpha)
    {
        var blended = new float[original.Length];
        for (int i = 0; i < original.Length; i++)
        {
            blended[i] = (float)(alpha * original[i] + (1 - alpha) * adapted[i]);
        }
        return blended;
    }
}

# Abrir PowerShell como Admin
sc.exe create "VoiceTrackerService" binPath= "C:\Ruta\Al\VoiceTracker.Service.exe" start= auto
sc.exe start "VoiceTrackerService"