using System.Collections.Concurrent;
using System.Security.Cryptography;
using System.Text;

namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Validation;

/// <summary>
/// Process-wide cache of script compile verdicts, keyed on the pair
/// (globals surface, SHA-256 hash of the script code). The verdict (clean/compiles,
/// or the name-free error text) is a pure function of the code plus the
/// compile-time-static <c>ScriptTrustPolicy</c> AND the globals surface it was
/// compiled against, so it is sound to memoise it across the whole process: an
/// unchanged script runs the forbidden-API analysis and the Roslyn compile exactly
/// once, removing both the repeat CPU cost and the repeat compiled-assembly load.
///
/// <para>
/// The globals surface is part of the key because a verdict is NOT interchangeable
/// across surfaces: a trigger expression that compiles clean against
/// <c>TriggerCompileSurface</c> is not vetted for a <c>ScriptCompileSurface</c>
/// script body (different globals resolve different identifiers), so a code-only key
/// could return a stale "clean" for code never compiled against the caller's surface.
/// Keeping the surface in the key makes that cross-surface reuse structurally
/// impossible even as more compile surfaces gain cache entries.
/// </para>
///
/// <para>
/// The stored error is deliberately <em>name-free</em> — the caller's script name is
/// formatted into the returned message at read time, so two callers submitting the
/// same bad code each see their own name in the failure text while sharing one verdict.
/// </para>
///
/// <para>
/// Bounded at <see cref="MaxEntries"/> entries; on overflow the cache is simply
/// cleared (the verdict is cheap to recompute, so a coarse reset is safe and avoids
/// eviction bookkeeping). <see cref="Hits"/>/<see cref="Count"/>/<see cref="Clear"/>
/// are exposed for tests and diagnostics.
/// </para>
/// </summary>
public static class ScriptCompileVerdictCache
{
    /// <summary>Upper bound on cached entries; the cache is cleared wholesale on overflow.</summary>
    private const int MaxEntries = 4096;

    private static readonly ConcurrentDictionary<string, (bool Ok, string? Error)> Cache = new();
    private static long _hits;

    /// <summary>Number of cache hits observed since the last <see cref="Clear"/>.</summary>
    public static long Hits => Interlocked.Read(ref _hits);

    /// <summary>Current number of cached verdicts.</summary>
    public static int Count => Cache.Count;

    /// <summary>
    /// Returns the cached verdict for the pair (<paramref name="surface"/>,
    /// <paramref name="code"/>), or computes it via <paramref name="factory"/> and
    /// caches it on a miss. A hit increments <see cref="Hits"/>. The verdict's error
    /// text must be name-free — the caller formats the script name in on return.
    /// </summary>
    /// <param name="surface">
    /// The globals-surface discriminator (e.g. <c>nameof(ScriptCompileSurface)</c> or
    /// <c>nameof(TriggerCompileSurface)</c>). Part of the key so a verdict computed
    /// against one surface is never reused for another.
    /// </param>
    /// <param name="code">The script source code to look up (hashed to form the cache key).</param>
    /// <param name="factory">Computes the verdict on a cache miss.</param>
    /// <returns>The cached or newly computed compile verdict.</returns>
    public static (bool Ok, string? Error) GetOrAdd(string surface, string code, Func<(bool Ok, string? Error)> factory)
    {
        var key = surface + ":" + Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(code)));

        if (Cache.TryGetValue(key, out var verdict))
        {
            Interlocked.Increment(ref _hits);
            return verdict;
        }

        verdict = factory();

        // Coarse bound: on overflow drop everything rather than track evictions.
        if (Cache.Count >= MaxEntries)
            Cache.Clear();

        Cache[key] = verdict;
        return verdict;
    }

    /// <summary>Clears all cached verdicts and resets the hit counter.</summary>
    public static void Clear()
    {
        Cache.Clear();
        Interlocked.Exchange(ref _hits, 0);
    }
}