LlamaCasty/ViewModels/MainViewModel.Trax.cs

using System.IO;
using System.Windows.Media;
using Microsoft.Win32;
using ytLive.Helpers;
using ytLive.Models;
using ytLive.Services.Audio;

namespace ytLive.ViewModels;

public partial class MainViewModel
{
    // TRAX (TASK 9): free background music at a fixed quiet volume, playing to
    // the default device so it rides the loopback into the stream. The dot is
    // red (no track) / yellow (loaded, stopped) / green (playing).
    private readonly MusicPlayer _musicPlayer = new();
    private Music? _music;
    private bool _musicPlaying;
    private bool _traxLoadInFlight;

    /// <summary>Hard ceiling on the TRAX reachability probe. A track on an offline
    /// network share blocks ~40s inside <c>MediaFoundationReader</c> before it throws
    /// 0x80070035, and that call sat on the startup path inside LoadLayout, so the
    /// window froze for the whole SMB timeout. The probe runs off the UI thread and is
    /// abandoned at this budget; the orphan thread stays parked until SMB gives up,
    /// which is the point — it is not the thread the creator is waiting on.</summary>
    internal static readonly TimeSpan TraxProbeBudget = TimeSpan.FromSeconds(2);

    private static readonly SolidColorBrush TraxIdleBrush = CreateBrush("#555");
    /// <summary>True while the TRAX background track is playing.</summary>
    public bool IsMusicPlaying
    {
        get => _musicPlaying;
        private set
        {
            if (SetProperty(ref _musicPlaying, value))
            {
                OnPropertyChanged(nameof(TraxDotBrush));
                OnPropertyChanged(nameof(TraxToolTip));
            }
        }
    }

    private string? _traxError;

    /// <summary>Error message from the last TRAX load/playback failure; null = no error.</summary>
    public string? TraxError
    {
        get => _traxError;
        private set => SetProperty(ref _traxError, value);
    }

    /// <summary>TRAX status dot: green = playing, gray = idle or no track.</summary>
    public SolidColorBrush TraxDotBrush => _musicPlayer.IsPlaying
        ? BarOnBrush
        : TraxIdleBrush;

    public string TraxToolTip => _musicPlayer.TrackName != null
        ? $"TRAX: {_musicPlayer.TrackName} — left-click {(IsMusicPlaying ? "pauses" : "plays")}, right-click chooses a track"
        : "No track — left-click or right-click to choose background music";

    /// <summary>Left-click on TRAX: no track → pick one; otherwise toggle play/pause.</summary>
    public void TraxLeftClick()
    {
        if (_music == null || string.IsNullOrWhiteSpace(_music.TrackPath))
            PickTraxTrack();
        else if (IsMusicPlaying)
            PauseTrax();
        else
            PlayTrax();
    }

    /// <summary>Right-click on TRAX: always open the track picker (never the OS viewer).</summary>
    public void TraxRightClick() => PickTraxTrack();

    private void PickTraxTrack()
    {
        var dialog = new OpenFileDialog
        {
            Title = "Choose background music",
            Filter = "Music (*.mp3;*.wav;*.m4a;*.aac;*.flac;*.ogg)|*.mp3;*.wav;*.m4a;*.aac;*.flac;*.ogg|All files (*.*)|*.*",
        };
        if (dialog.ShowDialog() != true)
            return;

        _music = new Music { TrackPath = dialog.FileName, IsEnabled = true };
        LoadTrax(play: true);
    }

    /// <summary>Probes a path off the UI thread and gives up at <paramref name="budget"/>.
    /// A probe may time out — that is the whole point. False means offline, missing, or
    /// slower than the budget, and every one of those is a normal state, not an error.</summary>
    internal static async Task<bool> IsTrackReachableAsync(string path, TimeSpan budget, Func<string, bool> probe)
    {
        var probeTask = Task.Run(() =>
        {
            try
            {
                return probe(path);
            }
            catch
            {
                return false;
            }
        });

        var finished = await Task.WhenAny(probeTask, Task.Delay(budget)).ConfigureAwait(false);
        return finished == probeTask && await probeTask.ConfigureAwait(false);
    }

    private void LoadTrax(bool play) => _ = LoadTraxAsync(play);

    private async Task LoadTraxAsync(bool play)
    {
        var music = _music;
        if (music == null || string.IsNullOrWhiteSpace(music.TrackPath) || _traxLoadInFlight)
            return;

        _traxLoadInFlight = true;
        var loaded = false;
        try
        {
            var path = music.TrackPath;
            if (await IsTrackReachableAsync(path, TraxProbeBudget, File.Exists))
            {
                // Reached the share, so this bind is cheap and stays on the UI thread
                // with every other MusicPlayer mutation — no new race to reason about.
                _musicPlayer.Load(path);
                UpdateTraxLocalGain();
                music.IsEnabled = true;
                TraxError = null;
                if (play)
                    _musicPlayer.Play();
                loaded = true;
            }
            else
            {
                AppLog.Write($"TRAX: '{path}' unreachable within {TraxProbeBudget.TotalSeconds:0}s — not loading");
                TraxError = $"Can't reach {Path.GetFileName(path)} — is the drive on?";
            }
        }
        catch (Exception ex)
        {
            AppLog.Write($"TRAX: failed to load '{music.TrackPath}': {ex.Message}");
            TraxError = $"Failed to load: {Path.GetFileName(music.TrackPath)} — {ex.Message}";
        }
        finally
        {
            _traxLoadInFlight = false;
            RefreshTraxUi();
            if (loaded)
                ScheduleSave();
        }
    }

    private void PlayTrax() => _musicPlayer.Play();

    private void PauseTrax() => _musicPlayer.Pause();

    private void OnTraxPlaybackEnded(Exception? ex)
    {
        if (ex != null)
        {
            AppLog.Write($"TRAX: playback error: {ex.Message}");
            TraxError = $"Playback error: {ex.Message}";
        }
        RefreshTraxUi();
    }

    private void RefreshTraxUi()
    {
        IsMusicPlaying = _musicPlayer.IsPlaying;
        OnPropertyChanged(nameof(TraxDotBrush));
        OnPropertyChanged(nameof(TraxToolTip));
    }

    /// <summary>Mirrors the desktop/game audio bar's volume and mute onto the
    /// music so the creator hears the controls work in the headphones (the
    /// track rides the loopback channel, so it must duck the same way locally).
    /// Called whenever the game volume/mute change and on TRAX load.</summary>
    private void UpdateTraxLocalGain()
    {
        _musicPlayer.LocalGain = GameMuted ? 0f : 1f;
    }
}