using System;
using ADOFAIRenderer.Util.Audio.Mixer;
using UnityEngine;

namespace ADOFAIRenderer.Util.Audio;

/// <summary>
/// Playback state of a game AudioSource mapped to an effect <see cref="Voice"/>, as the AudioSource reports it to the game
/// (isPlaying, time, timeSamples, pitch). Main thread only. Times are seconds relative to the render start (the render clock that
/// also drives AudioSettings.dspTime during rendering); clip positions are seconds into the clip.
///
/// Reported values:
/// - Playing: from the scheduled start until Stop(), the scheduled end time, or the natural end of the clip (not looping).
///   Before the start, isPlaying is true and time is the position playback will start from.
/// - time while playing: start position + elapsed time * pitch since the last change, wrapped at the clip length when looping.
///   time is 0 while not playing.
/// - timeSamples while playing: floor(time * clip frequency). While not playing: the last value set through time or timeSamples,
///   reset to 0 by Stop().
/// - pitch: the last finite value set (NaN and infinity are ignored). Playback uses max(0, pitch).
/// Changes made while not playing are stored and do not reach the voice.
/// </summary>
internal sealed class SourceState
{
    /// <summary>Start of playback, seconds relative to the render start.</summary>
    private readonly double _start;

    /// <summary>Render time of the last position or pitch change (at least <see cref="_start"/>), seconds.</summary>
    private double _anchorTime;

    /// <summary>Unwrapped clip position at <see cref="_anchorTime"/>, seconds into the clip.</summary>
    private double _anchorPosition;

    /// <summary>Last finite pitch set (reported as is; negative values play as 0).</summary>
    private double _pitch;

    private readonly bool _loop;

    /// <summary>Scheduled end time, seconds relative to the render start; infinity when not set.</summary>
    private double _endTime = double.PositiveInfinity;

    /// <summary>True after <see cref="Stop"/>; playback does not resume.</summary>
    private bool _stopped;

    /// <summary>timeSamples reported while not playing: the last value set through time/timeSamples, 0 after Stop.</summary>
    private int _offsetSamples;

    /// <summary>Clip length in seconds.</summary>
    private double _length;

    /// <summary>Clip sample rate in Hz (at least 1), used to convert between time and timeSamples.</summary>
    private int _frequency;

    /// <param name="voice">Voice that plays the sound.</param>
    /// <param name="start">Start of playback (seconds relative to the render start, not before the time it was scheduled).</param>
    /// <param name="pitch">Pitch at the start.</param>
    /// <param name="loop">Repeats the clip.</param>
    /// <param name="endTime">Scheduled end time (seconds relative to the render start), or infinity.</param>
    /// <param name="length">Clip length in seconds (replaced by the game clip in <see cref="BindClip"/>).</param>
    /// <param name="frequency">Clip sample rate for timeSamples (replaced by the game clip in <see cref="BindClip"/>).</param>
    public SourceState(Voice voice, double start, double pitch, bool loop, double endTime, double length, int frequency)
    {
        Voice = voice;
        _start = start;
        _anchorTime = start;
        _pitch = pitch;
        _loop = loop;
        _endTime = endTime;
        _length = length;
        _frequency = Math.Max(1, frequency);
    }

    /// <summary>Voice of the <see cref="VoiceMixer"/> that plays the sound; changes made while playing are queued on it.</summary>
    public Voice Voice { get; }

    /// <summary>Takes the clip length and sample rate from the clip of the game AudioSource.</summary>
    public void BindClip(AudioClip? clip)
    {
        if (!clip) return;
        _length = clip!.length;
        _frequency = Math.Max(1, clip.frequency);
    }

    /// <summary>Scheduled end time (see AudioSource.SetScheduledEndTime), seconds relative to the render start.</summary>
    public void SetEndTime(double endTime, double now)
    {
        if (!IsPlaying(now)) return;
        _endTime = endTime;
        Voice.SetEndTime(endTime, now);
    }

    /// <summary>AudioSource.isPlaying at <paramref name="now"/>: not stopped and before both the scheduled end and the natural end.</summary>
    public bool IsPlaying(double now) => !_stopped && now < Math.Min(_endTime, NaturalEnd());

    /// <summary>AudioSource.time at <paramref name="now"/>: clip position in seconds while playing, otherwise 0.</summary>
    public float GetTime(double now) => IsPlaying(now) ? (float)PositionAt(now) : 0f;

    /// <summary>AudioSource.timeSamples at <paramref name="now"/>: floor(position * frequency) while playing, otherwise the stored offset.</summary>
    public int GetTimeSamples(double now) => IsPlaying(now) ? (int)Math.Floor(PositionAt(now) * _frequency) : _offsetSamples;

    /// <summary>AudioSource.pitch: the last finite value set.</summary>
    public float GetPitch() => (float)_pitch;

    /// <summary>
    /// AudioSource.time setter: stores floor(seconds * frequency) as the offset and, while playing, moves the position to
    /// <paramref name="seconds"/> (negative values become 0) from <paramref name="now"/> (or from the start when not started yet).
    /// </summary>
    public void SetTime(float seconds, double now)
    {
        _offsetSamples = (int)Math.Floor((double)seconds * _frequency);
        Seek(seconds, now);
    }

    /// <summary>AudioSource.timeSamples setter: as <see cref="SetTime"/> with samples / frequency seconds.</summary>
    public void SetTimeSamples(int samples, double now)
    {
        _offsetSamples = samples;
        Seek((double)samples / _frequency, now);
    }

    /// <summary>
    /// AudioSource.pitch setter: ignores NaN and infinity. While playing, the position up to <paramref name="now"/> is kept
    /// (new anchor) and the voice changes rate at <paramref name="now"/>; otherwise only the reported value changes.
    /// </summary>
    public void SetPitch(float pitch, double now)
    {
        if (float.IsNaN(pitch) || float.IsInfinity(pitch)) return;
        var playing = IsPlaying(now);
        if (playing) Reanchor(now);
        _pitch = pitch;
        if (playing) Voice.SetPitch(pitch, now);
    }

    /// <summary>AudioSource.Stop(): stops the voice at <paramref name="now"/> when playing, marks the state stopped and clears the offset.</summary>
    public void Stop(double now)
    {
        if (IsPlaying(now)) Voice.Stop(now);
        _stopped = true;
        _offsetSamples = 0;
    }

    /// <summary>Rate used for playback: <see cref="_pitch"/> with negative values treated as 0 (as in <see cref="Voice.SetPitch"/>).</summary>
    private double PlaybackPitch => Math.Max(0.0, _pitch);

    /// <summary>
    /// While playing, sets the clip position to <paramref name="seconds"/> (at least 0) from max(now, start) and queues the same
    /// position change on the voice.
    /// </summary>
    private void Seek(double seconds, double now)
    {
        if (!IsPlaying(now)) return;
        var position = Math.Max(0.0, seconds);
        _anchorTime = Math.Max(now, _start);
        _anchorPosition = position;
        Voice.SetPosition(position, now);
    }

    /// <summary>Moves the anchor to max(now, start), keeping the current position, before a pitch change.</summary>
    private void Reanchor(double now)
    {
        var time = Math.Max(now, _start);
        _anchorPosition = PositionAt(time);
        _anchorTime = time;
    }

    /// <summary>Clip position at <paramref name="now"/> (the start position before the start), wrapped when looping.</summary>
    private double PositionAt(double now)
    {
        var position = _anchorPosition + (Math.Max(now, _anchorTime) - _anchorTime) * PlaybackPitch;
        if (_loop && _length > 0 && position >= _length) position %= _length;
        return position;
    }

    /// <summary>Time at which the clip position reaches the clip length (infinity when looping or at pitch 0).</summary>
    private double NaturalEnd()
    {
        if (_loop || PlaybackPitch <= 0) return double.PositiveInfinity;
        return _anchorTime + Math.Max(0.0, _length - _anchorPosition) / PlaybackPitch;
    }
}