using System.Diagnostics;

namespace AcDream.Core.Net.Transport;

/// <summary>
/// The transport's monotonic time authority: an injectable timestamp source
/// (production default <see cref="Stopwatch.GetTimestamp"/>) driving retail's
/// 0.5-second interval counter. <see cref="IntervalId"/> is the value retail
/// writes into <c>ProtoHeader::interval_</c> — our
/// <see cref="Packets.PacketHeader.Time"/> — on rebuilt resend headers.
///
/// <para>
/// Retail oracle: <c>ClientFlowQueue::IncrementLocalInterval @ 0x00547F10</c>
/// (named-retail pseudo-C :338389) — the tail is
/// <c>CurLocalInterval_.intervalID_ += elapsedIntervals</c>, advanced by the
/// caller once per elapsed 0.5-s slice. Only the interval counter is in
/// N1 scope: the same function's every-6-intervals TimeSync/EchoRequest
/// (~3 s) and every-0xDC-intervals CICMD keepalive are campaign §5
/// deferrals (TS-58) — standalone-unsafe against ACE's watermark hole.
/// </para>
///
/// <para>
/// One clock owns every transport gate (campaign §5 AP-126 — retail's
/// cur/local clock split is immaterial to the gates we port). Single-threaded
/// like the rest of the transport: <see cref="Update"/> runs only from the
/// session sweep.
/// </para>
/// </summary>
internal sealed class TransportClock
{
    private readonly Func<long> _timestampSource;
    private readonly long _ticksPerInterval;
    private long _intervalBaseTimestamp;

    /// <summary>Timestamp ticks per second of the injected source.</summary>
    public long Frequency { get; }

    /// <summary>
    /// Retail's 0.5-s interval counter (<c>CurLocalInterval_.intervalID_</c>).
    /// Starts at 1; wraps with natural ushort arithmetic.
    /// </summary>
    public ushort IntervalId { get; private set; }

    public TransportClock(
        Func<long>? timestampSource = null,
        long? frequency = null)
    {
        _timestampSource = timestampSource ?? Stopwatch.GetTimestamp;
        Frequency = frequency ?? Stopwatch.Frequency;
        if (Frequency < 2)
        {
            throw new ArgumentOutOfRangeException(
                nameof(frequency),
                "the interval clock needs at least 2 ticks per second");
        }

        _ticksPerInterval = Frequency / 2;
        _intervalBaseTimestamp = _timestampSource();
        IntervalId = 1;
    }

    /// <summary>Current raw timestamp from the injected source.</summary>
    public long GetTimestamp() => _timestampSource();

    /// <summary>
    /// Advance <see cref="IntervalId"/> by however many whole 0.5-s
    /// intervals have elapsed since the last update. Called once per sweep.
    /// </summary>
    public void Update()
    {
        long elapsed = _timestampSource() - _intervalBaseTimestamp;
        if (elapsed < _ticksPerInterval)
            return;

        long steps = elapsed / _ticksPerInterval;
        IntervalId = unchecked((ushort)(IntervalId + steps));
        _intervalBaseTimestamp += steps * _ticksPerInterval;
    }
}