1. Caso de Estudio: Voice Volume Tracker para Windows

VoiceVolumeTracker/
├── VoiceTracker.Domain/              # CORE (Lógica de Negocio)
│   ├── Entities/
│   │   ├── VoiceProfile.cs           # Perfil de voz del usuario
│   │   ├── VolumeReading.cs          # Lectura de volumen
│   │   ├── AlertEvent.cs             # Evento de alerta
│   │   └── AppConfig.cs              # Configuración
│   ├── ValueObjects/
│   │   ├── Decibel.cs                # Value object para dB
│   │   ├── VoiceEmbedding.cs         # Embedding de voz
│   │   └── TimeRange.cs              # Rango horario (Día/Noche)
│   ├── Repositories/
│   │   ├── IVoiceProfileRepository.cs
│   │   ├── IVolumeHistoryRepository.cs
│   │   └── IConfigRepository.cs
│   ├── Services/
│   │   ├── IAudioProcessor.cs        # Interface para procesamiento
│   │   ├── ISpeakerVerifier.cs       # Interface para ML
│   │   └── IAlertService.cs          # Interface para alertas
│   └── UseCases/
│       ├── EnrollVoiceUseCase.cs     # Registrar voz del usuario
│       ├── MonitorVolumeUseCase.cs   # Monitorear volumen
│       └── ConfigureThresholdsUseCase.cs
│
├── VoiceTracker.Infrastructure/      # ADAPTERS (Implementaciones)
│   ├── Audio/
│   │   ├── NAudioProcessor.cs        # Procesamiento con NAudio
│   │   ├── AudioCapture.cs           # Captura de micrófono
│   │   └── DecibelCalculator.cs      # Cálculo de dBFS
│   ├── ML/
│   │   ├── ONNXSpeakerVerifier.cs    # Verificación con ONNX
│   │   ├── EmbeddingExtractor.cs     # Extracción de embeddings
│   │   └── Models/
│   │       └── speechbrain_ecapa.onnx
│   ├── Persistence/
│   │   ├── SQLiteVoiceProfileRepository.cs
│   │   ├── SQLiteVolumeHistoryRepository.cs
│   │   └── JsonConfigRepository.cs
│   ├── Alerts/
│   │   ├── ToastNotificationService.cs
│   │   └── ScreenOverlayService.cs   # DirectX overlay
│   └── IPC/
│       └── NamedPipeServer.cs        # Comunicación con UI
│
├── VoiceTracker.Service/             # Windows Service
│   ├── VoiceMonitorService.cs        # Servicio principal
│   ├── FiniteStateMachine.cs         # FSM Día/Noche
│   └── BackgroundWorker.cs           # Worker en segundo plano
│
├── VoiceTracker.UI/                  # WPF Application
│   ├── Views/
│   │   ├── MainWindow.xaml           # Ventana principal
│   │   ├── EnrollmentWindow.xaml     # Wizard de enrollment
│   │   ├── ConfigWindow.xaml         # Configuración
│   │   └── StatsWindow.xaml          # Estadísticas
│   ├── ViewModels/
│   │   ├── MainViewModel.cs
│   │   ├── EnrollmentViewModel.cs
│   │   └── ConfigViewModel.cs
│   └── Services/
│       └── NamedPipeClient.cs        # Cliente IPC
│
└── VoiceTracker.Tests/
    ├── Unit/
    ├── Integration/
    └── Performance/

Idle → Listening: Audio detectado
Listening → Speaking: Voz del usuario identificada
Speaking → AlertActive: Volumen > Umbral
AlertActive → Speaking: Volumen < Umbral
Speaking → Idle: Silencio detectado

DayMode ↔ NightMode: Cambio de horario configurado

// VoiceTracker.Service/FiniteStateMachine.cs
public enum SystemState
{
    Idle,
    Listening,
    Speaking,
    AlertActive
}

public enum TimeMode
{
    Day,
    Night
}

public class VoiceTrackerFSM
{
    private SystemState _currentState = SystemState.Idle;
    private TimeMode _currentMode = TimeMode.Day;

    private readonly AppConfig _config;
    private readonly IAlertService _alertService;

    public SystemState CurrentState => _currentState;
    public TimeMode CurrentMode => _currentMode;

    public void ProcessAudioFrame(AudioFrame frame, bool isUserVoice, Decibel volume)
    {
        // Actualizar modo según hora
        UpdateTimeMode();

        // Transiciones de estado
        switch (_currentState)
        {
            case SystemState.Idle:
                if (frame.HasAudio)
                    TransitionTo(SystemState.Listening);
                break;

            case SystemState.Listening:
                if (isUserVoice)
                    TransitionTo(SystemState.Speaking);
                else if (!frame.HasAudio)
                    TransitionTo(SystemState.Idle);
                break;

            case SystemState.Speaking:
                var threshold = GetCurrentThreshold();
                if (volume > threshold)
                    TransitionTo(SystemState.AlertActive);
                else if (!isUserVoice)
                    TransitionTo(SystemState.Listening);
                break;

            case SystemState.AlertActive:
                var currentThreshold = GetCurrentThreshold();
                if (volume <= currentThreshold)
                    TransitionTo(SystemState.Speaking);
                break;
        }
    }

    private void TransitionTo(SystemState newState)
    {
        var oldState = _currentState;
        _currentState = newState;

        OnStateChanged(oldState, newState);
    }

    private void OnStateChanged(SystemState from, SystemState to)
    {
        if (to == SystemState.AlertActive)
        {
            _alertService.ShowAlert(GetCurrentThreshold());
        }
        else if (from == SystemState.AlertActive && to != SystemState.AlertActive)
        {
            _alertService.HideAlert();
        }
    }

    private void UpdateTimeMode()
    {
        var currentHour = DateTime.Now.Hour;
        var newMode = currentHour >= _config.NightModeStartHour || 
                      currentHour < _config.DayModeStartHour
            ? TimeMode.Night
            : TimeMode.Day;

        if (newMode != _currentMode)
        {
            _currentMode = newMode;
            OnTimeModeChanged(newMode);
        }
    }

    private Decibel GetCurrentThreshold()
    {
        return _currentMode == TimeMode.Day
            ? _config.DayThreshold
            : _config.NightThreshold;
    }
}

// VoiceTracker.Infrastructure/Audio/AudioCapture.cs
using NAudio.Wave;

public class AudioCapture : IAudioCapture
{
    private WaveInEvent _waveIn;
    private readonly int _sampleRate = 16000; // 16 kHz
    private readonly int _channels = 1; // Mono
    private readonly int _bitsPerSample = 16;

    public event EventHandler<AudioFrameEventArgs> AudioFrameReady;

    public void Start()
    {
        _waveIn = new WaveInEvent
        {
            WaveFormat = new WaveFormat(_sampleRate, _bitsPerSample, _channels),
            BufferMilliseconds = 100 // 100ms buffer
        };

        _waveIn.DataAvailable += OnDataAvailable;
        _waveIn.StartRecording();
    }

    private void OnDataAvailable(object sender, WaveInEventArgs e)
    {
        // Convertir bytes a floats
        var samples = new float[e.BytesRecorded / 2]; // bit = 2 bytes
        for (int i = 0; i < samples.Length; i++)
        {
            short sample = BitConverter.ToInt16(e.Buffer, i * 2);
            samples[i] = sample / 32768f; // Normalizar a [-1, 1]
        }

        var frame = new AudioFrame
        {
            Samples = samples,
            SampleRate = _sampleRate,
            Timestamp = DateTime.UtcNow
        };

        AudioFrameReady?.Invoke(this, new AudioFrameEventArgs(frame));
    }

    public void Stop()
    {
        _waveIn?.StopRecording();
        _waveIn?.Dispose();
    }
}

RMS = sqrt(mean(samples^2))
dBFS = 20 * log10(RMS)

// VoiceTracker.Infrastructure/Audio/DecibelCalculator.cs
using System;
using System.Linq;

public class DecibelCalculator
{
    public Decibel Calculate(float[] samples)
    {
        if (samples == null || samples.Length == 0)
            return Decibel.Silence;

        // Calcular RMS (Root Mean Square)
        var sumOfSquares = samples.Select(s => s * s).Sum();
        var rms = Math.Sqrt(sumOfSquares / samples.Length);

        // Evitar log(0)
        if (rms < 1e-10)
            return Decibel.Silence;

        // Calcular dBFS
        var dbfs = 20 * Math.Log10(rms);

        return new Decibel(dbfs);
    }

    public bool HasVoiceActivity(float[] samples, double threshold = -40.0)
    {
        var db = Calculate(samples);
        return db.Value > threshold;
    }
}

// VoiceTracker.Domain/ValueObjects/Decibel.cs
public record Decibel
{
    public double Value { get; init; }

    public static Decibel Silence => new Decibel(-96.0); // Silencio digital

    public Decibel(double value)
    {
        if (value > 0)
            throw new ArgumentException("dBFS must be <= 0");
        Value = value;
    }

    public static bool operator >(Decibel a, Decibel b) => a.Value > b.Value;
    public static bool operator <(Decibel a, Decibel b) => a.Value < b.Value;
}

// VoiceTracker.Infrastructure/Audio/VoiceActivityDetector.cs
public class VoiceActivityDetector
{
    private readonly double _energyThreshold = -40.0; // dBFS
    private readonly double _zeroCrossingThreshold = 0.3;

    public bool DetectVoice(float[] samples)
    {
        // Criterio 1: Energía suficiente
        var energy = CalculateEnergy(samples);
        if (energy < _energyThreshold)
            return false;

        // Criterio 2: Zero-Crossing Rate (detecta habla vs ruido)
        var zcr = CalculateZeroCrossingRate(samples);
        if (zcr < _zeroCrossingThreshold)
            return false;

        return true;
    }

    private double CalculateEnergy(float[] samples)
    {
        var calculator = new DecibelCalculator();
        return calculator.Calculate(samples).Value;
    }

    private double CalculateZeroCrossingRate(float[] samples)
    {
        int crossings = 0;
        for (int i = 1; i < samples.Length; i++)
        {
            if ((samples[i] >= 0 && samples[i - 1] < 0) ||
                (samples[i] < 0 && samples[i - 1] >= 0))
            {
                crossings++;
            }
        }
        return (double)crossings / samples.Length;
    }
}