AudioResource.cs

using Gondwana.Assets;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
 
namespace Gondwana.Audio;

[JsonObject(IsReference = true)]
public class AudioResource : IDisposable
{
    public const float MinimumPlaybackSpeed = 0.25f;

    public const float MaximumPlaybackSpeed = 4.0f;
 
    private IAudioPlaybackHandle? _playback;
    private bool _disposed;
 
    [JsonProperty]
    private float _volume = 1.0f;
 
    [JsonProperty]
    private float _pan;
 
    [JsonProperty]
    private float _playbackSpeed = 1.0f;
 
    [JsonProperty]
    private bool _isLooping;

    public event EventHandler? PlaybackCompleted;

    public Func<Task>? PlaybackCompletedAsync;

    public event EventHandler? Disposed;
 
    [JsonConstructor]
    private AudioResource()
    {
        Key = string.Empty;
    }
 
    internal AudioResource(
        string key,
        IAudioPlaybackHandle playback,
        float volume = 1.0f,
        float pan = 0.0f,
        float playbackSpeed = 1.0f,
        string? filePathOrExt = null,
        byte[]? rawBytes = null,
        AssetsFileIdentifier? assetIdentifier = null)
    {
        Key = key;
        _playback = playback ?? throw new ArgumentNullException(nameof(playback));
 
        AssetIdentifier = assetIdentifier;
        SourceFilePath = assetIdentifier is null && !string.IsNullOrWhiteSpace(filePathOrExt) && File.Exists(filePathOrExt)
            ? filePathOrExt
            : null;
 
        var ext = Path.GetExtension(filePathOrExt ?? string.Empty);
        SourceExtension = string.IsNullOrEmpty(ext) ? null : NormalizeExtension(ext);
        OriginalBytes = rawBytes;
 
        Volume = volume;
        Pan = pan;
        PlaybackSpeed = playbackSpeed;
        IsLooping = false;
 
        _playback.PlaybackCompleted += OnPlaybackCompleted;
    }

    [JsonProperty]
    public string Key { get; private set; }

    [JsonIgnore]
    public byte[]? OriginalBytes { get; private set; }

    [JsonProperty]
    public string? SourceFilePath { get; private set; }

    [JsonProperty]
    public AssetsFileIdentifier? AssetIdentifier { get; private set; }

    [JsonProperty]
    public string? SourceExtension { get; private set; }

    [JsonProperty]
    public string? SourceUri { get; private set; }

    [JsonIgnore]
    public string? TempFilePath => _playback?.TemporaryFilePath;

    [JsonIgnore]
    public bool IsPaused => State == AudioPlaybackState.Paused;

    [JsonIgnore]
    public bool IsPlaying => State == AudioPlaybackState.Playing;

    [JsonIgnore]
    public AudioPlaybackState State => _playback?.State ?? AudioPlaybackState.Stopped;

    [JsonIgnore]
    public TimeSpan CurrentTime
    {
        get => _playback?.CurrentTime ?? TimeSpan.Zero;
        set => Seek(value);
    }

    [JsonIgnore]
    public TimeSpan Duration => _playback?.Duration ?? TimeSpan.Zero;

    public bool IsLooping
    {
        get => _isLooping;
        set
        {
            _isLooping = value;
            if (_playback is not null)
                _playback.IsLooping = value;
        }
    }

    public float Volume
    {
        get => _volume;
        set
        {
            if (float.IsNaN(value)) throw new ArgumentOutOfRangeException(nameof(value));
            _volume = Math.Clamp(value, 0f, 1f);
            if (_playback is not null)
                _playback.Volume = _volume;
        }
    }

    public float Pan
    {
        get => _pan;
        set
        {
            if (float.IsNaN(value)) throw new ArgumentOutOfRangeException(nameof(value));
            _pan = Math.Clamp(value, -1f, 1f);
            if (_playback is not null)
                _playback.Pan = _pan;
        }
    }

    public float PlaybackSpeed
    {
        get => _playbackSpeed;
        set
        {
            if (float.IsNaN(value)) throw new ArgumentOutOfRangeException(nameof(value));
            _playbackSpeed = Math.Clamp(value, MinimumPlaybackSpeed, MaximumPlaybackSpeed);
            if (_playback is not null)
                _playback.PlaybackSpeed = _playbackSpeed;
        }
    }

    public void Play(bool fromStart = true) => Playback.Play(fromStart);

    public void Pause() => Playback.Pause();

    public void Resume() => Playback.Resume();

    public void Seek(TimeSpan position) => Playback.Seek(position);

    public void Stop() => Playback.Stop();
 
    internal void SetSourceUri(string uri)
    {
        SourceUri = uri;
        SourceFilePath = null;
        SourceExtension = NormalizeExtension(Path.GetExtension(new Uri(uri, UriKind.RelativeOrAbsolute).IsAbsoluteUri
            ? new Uri(uri).AbsolutePath
            : uri));
    }
 
    internal void SetAssetIdentifier(AssetsFileIdentifier identifier) => AssetIdentifier = identifier;
 
    internal void CopySourceFrom(AudioResource original)
    {
        SourceFilePath = original.SourceFilePath;
        AssetIdentifier = original.AssetIdentifier;
    }

    internal void ReloadIntoManager(bool forceReload = false)
    {
        if (string.IsNullOrWhiteSpace(Key))
            throw new InvalidOperationException("AudioResource has no Key and cannot be reloaded.");
 
        var manager = AudioResourceManager.Instance;
 
        if (!forceReload && manager.TryGet(Key, out var existing) && existing is not null)
        {
            existing.Volume = Volume;
            existing.Pan = Pan;
            existing.PlaybackSpeed = PlaybackSpeed;
            existing.IsLooping = IsLooping;
            return;
        }
 
        if (forceReload && manager.Contains(Key))
            manager.Unload(Key);
 
        AudioResource loaded;
        if (AssetIdentifier is not null)
        {
            using var stream = AssetIdentifier.Data;
            if (stream is null)
                throw new InvalidOperationException($"Missing asset data for {Key}.");
 
            loaded = manager.LoadFromStream(Key, stream, SourceExtension ?? ".wav", Volume, Pan, PlaybackSpeed);
            loaded.SetAssetIdentifier(AssetIdentifier);
        }
        else if (!string.IsNullOrWhiteSpace(SourceFilePath))
        {
            loaded = manager.LoadFromFile(Key, SourceFilePath, Volume, Pan, PlaybackSpeed);
        }
        else if (!string.IsNullOrWhiteSpace(SourceUri))
        {
            loaded = manager.LoadFromUri(Key, SourceUri, Volume, Pan, PlaybackSpeed);
        }
        else
        {
            throw new InvalidOperationException($"AudioResource '{Key}' has no persisted source.");
        }
 
        loaded.IsLooping = IsLooping;
    }
 
    private IAudioPlaybackHandle Playback
    {
        get
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            return _playback ?? throw new InvalidOperationException(
                $"AudioResource '{Key}' is not attached to an audio backend. Configure an audio backend before loading or restoring audio.");
        }
    }
 
    private async void OnPlaybackCompleted(object? sender, EventArgs e)
    {
        try
        {
            if (PlaybackCompletedAsync is not null)
                await PlaybackCompletedAsync().ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            Engine.Logger.LogError(ex, "PlaybackCompletedAsync threw an exception for audio resource: {Key}", Key);
        }
        finally
        {
            PlaybackCompleted?.Invoke(this, EventArgs.Empty);
        }
    }
 
    private static string? NormalizeExtension(string? extension)
    {
        if (string.IsNullOrWhiteSpace(extension))
            return null;
 
        return extension.StartsWith('.')
            ? extension.ToLowerInvariant()
            : "." + extension.ToLowerInvariant();
    }

    public void Dispose()
    {
        if (_disposed)
            return;
 
        if (_playback is not null)
        {
            _playback.PlaybackCompleted -= OnPlaybackCompleted;
            _playback.Dispose();
            _playback = null;
        }
 
        _disposed = true;
        Disposed?.Invoke(this, EventArgs.Empty);
        GC.SuppressFinalize(this);
    }
}