using Moq;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;

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

/// <summary>
/// Gitea #66: member add/update now asks the repository for a template's analysis closure
/// rather than the whole analysis graph. Test classes keep seeding the whole graph through
/// <c>GetAllTemplatesForAnalysisAsync</c>; this wires <c>GetTemplateAnalysisClosureAsync</c>
/// to serve the real closure walk over that seeded graph, so every existing scenario runs the
/// service against the reduced set — the same set the production repository returns.
/// </summary>
internal static class AnalysisClosureMock
{
    /// <summary>Wires the closure method to filter whatever the full-graph setup returns.</summary>
    /// <param name="repoMock">The repository mock.</param>
    /// <param name="closureRequests">Optional sink recording each requested closure root.</param>
    public static void ServeClosureFromFullGraph(
        this Mock<ITemplateEngineRepository> repoMock,
        List<int>? closureRequests = null)
    {
        repoMock
            .Setup(r => r.GetTemplateAnalysisClosureAsync(It.IsAny<int>(), It.IsAny<CancellationToken>()))
            .Returns((int templateId, CancellationToken ct) =>
            {
                closureRequests?.Add(templateId);
                return TemplateAnalysisClosure.CollectAsync(
                    templateId,
                    async (ids, token) =>
                    {
                        var all = await repoMock.Object.GetAllTemplatesForAnalysisAsync(token)
                                  ?? Array.Empty<Template>();
                        return all.Where(t => ids.Contains(t.Id)).ToList();
                    },
                    ct);
            });
    }

    /// <summary>
    /// Gitea #86: the descendant reconcile now asks for the reconcile closure (derived subtree +
    /// the template's chain) instead of <c>GetAllTemplatesAsync</c>. Wires it to run the real
    /// closure walk over whatever the full tracked-graph setup returns, so every existing
    /// propagation scenario exercises the service against the reduced set. Also serves the
    /// chain-only read the inherited-member resync falls back to for a leaf (Gitea #89).
    /// </summary>
    /// <param name="repoMock">The repository mock.</param>
    /// <param name="closureRequests">Optional sink recording each requested closure root.</param>
    public static void ServeReconcileClosureFromFullGraph(
        this Mock<ITemplateEngineRepository> repoMock,
        List<int>? closureRequests = null)
    {
        async Task<IReadOnlyList<Template>> All(CancellationToken token) =>
            await repoMock.Object.GetAllTemplatesAsync(token) ?? Array.Empty<Template>();

        repoMock
            .Setup(r => r.GetTemplateReconcileClosureAsync(It.IsAny<int>(), It.IsAny<CancellationToken>()))
            .Returns((int templateId, CancellationToken ct) =>
            {
                closureRequests?.Add(templateId);
                return TemplateReconcileClosure.CollectAsync(
                    templateId,
                    async (parentIds, token) => (await All(token))
                        .Where(t => t.ParentTemplateId is int p && parentIds.Contains(p)).ToList(),
                    async (ids, token) => (await All(token)).Where(t => ids.Contains(t.Id)).ToList(),
                    ct);
            });

        // Gitea #89: the resync of a template nobody derives from falls back to its chain.
        repoMock
            .Setup(r => r.GetTemplateChainAsync(It.IsAny<int>(), It.IsAny<bool>(), It.IsAny<CancellationToken>()))
            .Returns((int templateId, bool _, CancellationToken ct) =>
                TemplateReconcileClosure.CollectChainAsync(
                    templateId,
                    async (ids, token) => (await All(token)).Where(t => ids.Contains(t.Id)).ToList(),
                    ct));
    }
}