namespace ZB.MOM.WW.OtOpcUa.AdminUI.ScriptAnalysis;

/// <summary>
///     Presentation rules for the script editor's Problems list — the markers Monaco reports through
///     <c>MonacoEditor.MarkersChanged</c> (the same <see cref="DiagnosticMarker"/> shape the diagnostics endpoint
///     returns), rendered by <c>ScriptProblemsList</c>.
/// </summary>
public static class ScriptProblems
{
    /// <summary>Monaco's error severity.</summary>
    public const int Error = 8;

    /// <summary>Monaco's warning severity.</summary>
    public const int Warning = 4;

    /// <summary>Errors first, then warnings, then the rest; within a severity, by position.</summary>
    /// <param name="markers">The reported markers (null treated as none).</param>
    /// <returns>The markers in display order.</returns>
    public static IReadOnlyList<DiagnosticMarker> Order(IEnumerable<DiagnosticMarker>? markers)
        => (markers ?? Array.Empty<DiagnosticMarker>())
            .OrderByDescending(m => m.Severity)
            .ThenBy(m => m.StartLineNumber)
            .ThenBy(m => m.StartColumn)
            .ToList();

    /// <summary>The label for a Monaco severity value.</summary>
    /// <param name="severity">8 = error, 4 = warning, 2 = info, otherwise hint.</param>
    /// <returns>The display label.</returns>
    public static string SeverityLabel(int severity) => severity switch
    {
        Error => "Error",
        Warning => "Warning",
        2 => "Info",
        _ => "Hint",
    };

    /// <summary>A one-line count, e.g. <c>"2 errors, 1 warning"</c>.</summary>
    /// <param name="markers">The reported markers.</param>
    /// <returns>The summary, or <c>"No problems"</c>.</returns>
    public static string Summary(IReadOnlyCollection<DiagnosticMarker> markers)
    {
        if (markers.Count == 0) return "No problems";
        var errors = markers.Count(m => m.Severity == Error);
        var warnings = markers.Count(m => m.Severity == Warning);
        var other = markers.Count - errors - warnings;
        var parts = new List<string>(3);
        if (errors > 0) parts.Add(Plural(errors, "error"));
        if (warnings > 0) parts.Add(Plural(warnings, "warning"));
        if (other > 0) parts.Add($"{other} other");
        return string.Join(", ", parts);
    }

    /// <summary>A one-line count for a (possibly capped) report, e.g. <c>"200 errors (showing 200 of 4321)"</c>.</summary>
    /// <param name="report">The report the editor sent.</param>
    /// <returns>The summary of the shown markers, with the shown/total suffix when some were left out.</returns>
    public static string Summary(ScriptProblemReport report)
    {
        var summary = Summary(report.Markers.ToList());
        return report.Omitted > 0 ? $"{summary} (showing {report.Markers.Count} of {report.Total})" : summary;
    }

    /// <summary>Cuts <paramref name="text"/> to at most <paramref name="maxChars"/> characters, ending in an ellipsis.</summary>
    /// <param name="text">The text.</param>
    /// <param name="maxChars">The maximum length, ellipsis included (at least 1).</param>
    /// <returns>The text, unchanged when it already fits.</returns>
    public static string Truncate(string text, int maxChars)
        => text.Length <= maxChars ? text : string.Concat(text.AsSpan(0, Math.Max(0, maxChars - 1)), "…");

    private static string Plural(int n, string noun) => n == 1 ? $"1 {noun}" : $"{n} {noun}s";
}

/// <summary>
///     What the editor reported for the Problems list: at most <see cref="ScriptEditorLimits.MaxReportedMarkers"/>
///     markers in display order (errors first) plus the <see cref="Total"/> the diagnostics pass produced. The JS caps
///     the report before it crosses the circuit — one hub message, bounded by the 1 MB receive limit — and
///     <see cref="FromEditor"/> clamps it again on arrival.
/// </summary>
/// <param name="Markers">The markers shown.</param>
/// <param name="Total">How many markers the diagnostics pass produced (≥ <c>Markers.Count</c>).</param>
public sealed record ScriptProblemReport(IReadOnlyList<DiagnosticMarker> Markers, int Total)
{
    /// <summary>No problems.</summary>
    public static readonly ScriptProblemReport Empty = new(Array.Empty<DiagnosticMarker>(), 0);

    /// <summary>How many markers were left out of <see cref="Markers"/>.</summary>
    public int Omitted => Math.Max(0, Total - Markers.Count);

    /// <summary>Builds a report from what the editor JS sent, re-applying the circuit caps defensively.</summary>
    /// <param name="markers">The markers sent (already capped by the JS).</param>
    /// <param name="total">The total the JS counted.</param>
    /// <returns>The clamped report.</returns>
    public static ScriptProblemReport FromEditor(IReadOnlyList<DiagnosticMarker>? markers, int total)
    {
        if (markers is null || markers.Count == 0) return total <= 0 ? Empty : new(Array.Empty<DiagnosticMarker>(), total);
        var shown = ScriptProblems.Order(markers)
            .Take(ScriptEditorLimits.MaxReportedMarkers)
            .Select(m => m.Message.Length <= ScriptEditorLimits.MaxReportedMessageChars
                ? m
                : m with { Message = ScriptProblems.Truncate(m.Message, ScriptEditorLimits.MaxReportedMessageChars) })
            .ToList();
        return new ScriptProblemReport(shown, Math.Max(total, markers.Count));
    }
}