using System.IO;

namespace ytLive.Helpers;

/// <summary>
/// Size-capped log rotation.
/// <para>When a log file grows past a cap, it is rolled to <c>&lt;name&gt;.1.log</c> and a
/// fresh one is started, keeping a bounded number of rolled files. The pattern is the
/// one every sized logger uses — Serilog's file sink pairs <c>fileSizeLimitBytes</c>
/// (the cap) with <c>retainedFileCountLimit</c> (how many rolled files to keep):
/// https://github.com/serilog/serilog-sinks-file</para>
/// <para><b>Why it lives here and not in the logger:</b> <see cref="AppLog"/>'s call surface
/// (156 call sites) must not change, and the rotation rule is worth testing on its own —
/// so the policy is a pure function over a path, and <see cref="AppLog"/> just calls it.</para>
/// </summary>
public static class LogRotation
{
    /// <summary>
    /// Rolls <paramref name="logPath"/> if it has reached <paramref name="maxBytes"/>,
    /// keeping <paramref name="retainedFiles"/> rolled copies
    /// (<c>name.1.log</c>, <c>name.2.log</c>, …). Does nothing when the file is missing
    /// or still under the cap.
    /// <para>Never throws: a failed rotation must not take the app down — the log just
    /// keeps growing, which is the old behaviour.</para>
    /// </summary>
    public static void RollIfNeeded(string logPath, long maxBytes, int retainedFiles)
    {
        try
        {
            var info = new FileInfo(logPath);
            if (!info.Exists || info.Length < maxBytes)
            {
                return;
            }

            // Oldest first: name.1 → name.2 → … → name.N, then the live file → name.1.
            for (var i = retainedFiles; i >= 1; i--)
            {
                var source = i == 1 ? logPath : RolledPath(logPath, i - 1);
                var target = RolledPath(logPath, i);
                if (!File.Exists(source))
                {
                    continue;
                }

                File.Move(source, target, overwrite: true);
            }
        }
        catch
        {
            // Never let logging itself crash the app.
        }
    }

    /// <summary>The rolled path for a given index: <c>startup.log</c> → <c>startup.1.log</c>.</summary>
    public static string RolledPath(string logPath, int index)
    {
        var directory = Path.GetDirectoryName(logPath) ?? string.Empty;
        var name = Path.GetFileNameWithoutExtension(logPath);
        var extension = Path.GetExtension(logPath);
        return Path.Combine(directory, $"{name}.{index}{extension}");
    }
}