using System.Collections.Concurrent;
using ZB.MOM.WW.Secrets.Abstractions;

namespace ZB.MOM.WW.Secrets.Ui.Tests.Fakes;

/// <summary>
/// A hand-written <see cref="ISecretStore"/> test double (the family does not use Moq) that keeps
/// an in-memory table of rows and records every <see cref="UpsertAsync"/> and
/// <see cref="DeleteAsync"/> call so a test can assert on the mutation trail.
/// </summary>
public sealed class RecordingSecretStore : ISecretStore
{
    private readonly ConcurrentDictionary<string, StoredSecret> _rows = new();
    private readonly ConcurrentQueue<StoredSecret> _upserts = new();
    private readonly ConcurrentQueue<(SecretName Name, string? Actor)> _deletes = new();

    /// <summary>Rows upserted, in call order.</summary>
    public IReadOnlyList<StoredSecret> Upserts => _upserts.ToArray();

    /// <summary>Delete calls (name + recorded actor), in call order.</summary>
    public IReadOnlyList<(SecretName Name, string? Actor)> Deletes => _deletes.ToArray();

    /// <summary>When set, <see cref="UpsertAsync"/> throws this to drive the mutation-failure path.</summary>
    public Exception? UpsertFault { get; set; }

    /// <summary>When set, <see cref="DeleteAsync"/> throws this to drive the mutation-failure path.</summary>
    public Exception? DeleteFault { get; set; }

    /// <summary>Seeds a row so <see cref="GetAsync"/> and <see cref="ListAsync"/> can return it.</summary>
    /// <param name="row">The row to seed.</param>
    public void Seed(StoredSecret row) => _rows[row.Name.Value] = row;

    /// <inheritdoc />
    public Task<StoredSecret?> GetAsync(SecretName name, CancellationToken ct)
        => Task.FromResult(_rows.TryGetValue(name.Value, out StoredSecret? row) ? row : null);

    /// <inheritdoc />
    public Task UpsertAsync(StoredSecret row, CancellationToken ct)
    {
        if (UpsertFault is not null)
        {
            throw UpsertFault;
        }

        _rows[row.Name.Value] = row;
        _upserts.Enqueue(row);
        return Task.CompletedTask;
    }

    /// <inheritdoc />
    public Task<bool> DeleteAsync(SecretName name, string? actor, CancellationToken ct)
    {
        if (DeleteFault is not null)
        {
            throw DeleteFault;
        }

        _deletes.Enqueue((name, actor));
        return Task.FromResult(_rows.TryRemove(name.Value, out _));
    }

    /// <inheritdoc />
    public Task<IReadOnlyList<SecretMetadata>> ListAsync(bool includeDeleted, CancellationToken ct)
    {
        IReadOnlyList<SecretMetadata> projection = _rows.Values
            .Where(r => includeDeleted || !r.IsDeleted)
            .Select(r => new SecretMetadata
            {
                Name = r.Name,
                Description = r.Description,
                ContentType = r.ContentType,
                KekId = r.KekId,
                Revision = r.Revision,
                IsDeleted = r.IsDeleted,
                CreatedUtc = r.CreatedUtc,
                UpdatedUtc = r.UpdatedUtc,
                CreatedBy = r.CreatedBy,
                UpdatedBy = r.UpdatedBy,
            })
            .ToArray();
        return Task.FromResult(projection);
    }

    /// <inheritdoc />
    public Task<IReadOnlyList<SecretManifestEntry>> GetManifestAsync(CancellationToken ct)
        => throw new NotSupportedException();

    /// <inheritdoc />
    public Task ApplyReplicatedAsync(StoredSecret row, CancellationToken ct)
        => throw new NotSupportedException();

    /// <inheritdoc />
    public Task<bool> ApplyRewrapAsync(
        StoredSecret rewrappedRow, byte[] expectedCurrentWrappedDek, CancellationToken ct)
        => throw new NotSupportedException();
}