using ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.InboundApi;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Scripts;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Transport;

namespace ZB.MOM.WW.ScadaBridge.Transport.Export;

/// <summary>
/// Expands an <see cref="ExportSelection"/> into the full set of entities that
/// must be in the bundle for the selection to be self-consistent. Walks the
/// dependency edges documented in §6.1 of the Transport design doc:
/// <list type="bullet">
///   <item>Template composes Template (via TemplateComposition.ComposedTemplateId).</item>
///   <item>Template references SharedScript (by name, scanned in script bodies).</item>
///   <item>Template references ExternalSystem (by name, scanned in script bodies + attribute DataSourceReference).</item>
///   <item>ApiMethod references SharedScript (by name, scanned in ApiMethod.Script).</item>
///   <item>Selected Template's folder chain (ancestor folders included).</item>
///   <item>ExternalSystemDefinition pulls its ExternalSystemMethods.</item>
/// </list>
/// Templates are returned topologically sorted (base-before-derived) via Kahn's
/// algorithm so importers can apply them in order.
/// </summary>
public sealed class DependencyResolver
{
    private readonly ITemplateEngineRepository _templates;
    private readonly IExternalSystemRepository _externalSystems;
    private readonly INotificationRepository _notifications;
    private readonly IInboundApiRepository _inboundApi;

    /// <summary>Initializes a new instance of <see cref="DependencyResolver"/>.</summary>
    /// <param name="templates">Repository for template and shared script access.</param>
    /// <param name="externalSystems">Repository for external system definitions and methods.</param>
    /// <param name="notifications">Repository for notification lists and SMTP configurations.</param>
    /// <param name="inboundApi">Repository for inbound API keys and methods.</param>
    public DependencyResolver(
        ITemplateEngineRepository templates,
        IExternalSystemRepository externalSystems,
        INotificationRepository notifications,
        IInboundApiRepository inboundApi)
    {
        _templates = templates ?? throw new ArgumentNullException(nameof(templates));
        _externalSystems = externalSystems ?? throw new ArgumentNullException(nameof(externalSystems));
        _notifications = notifications ?? throw new ArgumentNullException(nameof(notifications));
        _inboundApi = inboundApi ?? throw new ArgumentNullException(nameof(inboundApi));
    }

    /// <summary>Expands the selection into a fully self-consistent set of entities for bundling.</summary>
    /// <param name="selection">The user's export selection specifying which entities to include.</param>
    /// <param name="ct">Cancellation token.</param>
    /// <returns>A <see cref="ResolvedExport"/> with all transitively required entities.</returns>
    public async Task<ResolvedExport> ResolveAsync(ExportSelection selection, CancellationToken ct)
    {
        ArgumentNullException.ThrowIfNull(selection);

        // ---- Seed: fetch the directly-selected entities ----
        var templates = new Dictionary<int, Template>();
        foreach (var id in selection.TemplateIds.Distinct())
        {
            var t = await _templates.GetTemplateWithChildrenAsync(id, ct).ConfigureAwait(false);
            if (t is not null) templates[t.Id] = t;
        }

        var sharedScripts = new Dictionary<int, SharedScript>();
        foreach (var id in selection.SharedScriptIds.Distinct())
        {
            var s = await _templates.GetSharedScriptByIdAsync(id, ct).ConfigureAwait(false);
            if (s is not null) sharedScripts[s.Id] = s;
        }

        var externalSystems = new Dictionary<int, ExternalSystemDefinition>();
        foreach (var id in selection.ExternalSystemIds.Distinct())
        {
            var es = await _externalSystems.GetExternalSystemByIdAsync(id, ct).ConfigureAwait(false);
            if (es is not null) externalSystems[es.Id] = es;
        }

        var dbConnections = new Dictionary<int, DatabaseConnectionDefinition>();
        foreach (var id in selection.DatabaseConnectionIds.Distinct())
        {
            var db = await _externalSystems.GetDatabaseConnectionByIdAsync(id, ct).ConfigureAwait(false);
            if (db is not null) dbConnections[db.Id] = db;
        }

        var notificationLists = new Dictionary<int, NotificationList>();
        foreach (var id in selection.NotificationListIds.Distinct())
        {
            var nl = await _notifications.GetNotificationListByIdAsync(id, ct).ConfigureAwait(false);
            if (nl is not null) notificationLists[nl.Id] = nl;
        }

        var smtpConfigs = new Dictionary<int, SmtpConfiguration>();
        foreach (var id in selection.SmtpConfigurationIds.Distinct())
        {
            var sm = await _notifications.GetSmtpConfigurationByIdAsync(id, ct).ConfigureAwait(false);
            if (sm is not null) smtpConfigs[sm.Id] = sm;
        }

        // Inbound API keys are intentionally NOT resolved into the bundle: per the
        // inbound-API-key re-architecture (C4) keys are not transported between
        // environments. Only API methods travel.
        var apiMethods = new Dictionary<int, ApiMethod>();
        foreach (var id in selection.ApiMethodIds.Distinct())
        {
            var m = await _inboundApi.GetApiMethodByIdAsync(id, ct).ConfigureAwait(false);
            if (m is not null) apiMethods[m.Id] = m;
        }

        // ---- Dependency expansion ----
        if (selection.IncludeDependencies)
        {
            await ExpandTemplateClosureAsync(templates, ct).ConfigureAwait(false);
            await ExpandSharedScriptsFromTemplatesAsync(templates, sharedScripts, ct).ConfigureAwait(false);
            await ExpandSharedScriptsFromApiMethodsAsync(apiMethods, sharedScripts, ct).ConfigureAwait(false);
            await ExpandExternalSystemsFromTemplatesAsync(templates, externalSystems, ct).ConfigureAwait(false);
        }

        // ExternalSystemMethods always travel with their parent ExternalSystem.
        var externalSystemMethods = new List<ExternalSystemMethod>();
        foreach (var es in externalSystems.Values.OrderBy(x => x.Name, StringComparer.Ordinal))
        {
            var methods = await _externalSystems
                .GetMethodsByExternalSystemIdAsync(es.Id, ct)
                .ConfigureAwait(false);
            externalSystemMethods.AddRange(methods);
        }

        // Folder ancestor chain — always pull, regardless of IncludeDependencies,
        // so the imported tree never references missing parents.
        var folders = await ResolveFolderChainAsync(templates.Values, ct).ConfigureAwait(false);

        // ---- Topological sort of templates (base-before-derived) ----
        var orderedTemplates = TopologicallySortTemplates(templates.Values);

        // ---- Build deterministic content manifest ----
        var manifest = BuildContentManifest(
            folders,
            orderedTemplates,
            sharedScripts.Values,
            externalSystems.Values,
            externalSystemMethods,
            dbConnections.Values,
            notificationLists.Values,
            smtpConfigs.Values,
            apiMethods.Values);

        return new ResolvedExport(
            TemplateFolders: folders,
            Templates: orderedTemplates,
            SharedScripts: sharedScripts.Values.OrderBy(s => s.Name, StringComparer.Ordinal).ToList(),
            ExternalSystems: externalSystems.Values.OrderBy(e => e.Name, StringComparer.Ordinal).ToList(),
            ExternalSystemMethods: externalSystemMethods,
            DatabaseConnections: dbConnections.Values.OrderBy(d => d.Name, StringComparer.Ordinal).ToList(),
            NotificationLists: notificationLists.Values.OrderBy(n => n.Name, StringComparer.Ordinal).ToList(),
            SmtpConfigs: smtpConfigs.Values.OrderBy(s => s.Host, StringComparer.Ordinal).ToList(),
            ApiMethods: apiMethods.Values.OrderBy(a => a.Name, StringComparer.Ordinal).ToList(),
            ContentManifest: manifest);
    }

    // ---- Template composition closure ----
    private async Task ExpandTemplateClosureAsync(Dictionary<int, Template> templates, CancellationToken ct)
    {
        var queue = new Queue<Template>(templates.Values);
        while (queue.Count > 0)
        {
            var current = queue.Dequeue();
            foreach (var comp in current.Compositions)
            {
                if (templates.ContainsKey(comp.ComposedTemplateId)) continue;
                var composed = await _templates
                    .GetTemplateWithChildrenAsync(comp.ComposedTemplateId, ct)
                    .ConfigureAwait(false);
                if (composed is null) continue;
                templates[composed.Id] = composed;
                queue.Enqueue(composed);
            }
        }
    }

    // ---- SharedScript pulls from template script bodies + attributes ----
    private async Task ExpandSharedScriptsFromTemplatesAsync(
        Dictionary<int, Template> templates,
        Dictionary<int, SharedScript> sharedScripts,
        CancellationToken ct)
    {
        var allShared = await _templates.GetAllSharedScriptsAsync(ct).ConfigureAwait(false);
        foreach (var shared in allShared)
        {
            if (sharedScripts.ContainsKey(shared.Id)) continue;
            if (TemplatesReferenceName(templates.Values, shared.Name))
            {
                sharedScripts[shared.Id] = shared;
            }
        }
    }

    // ---- SharedScript pulls from ApiMethod.Script bodies ----
    private async Task ExpandSharedScriptsFromApiMethodsAsync(
        Dictionary<int, ApiMethod> apiMethods,
        Dictionary<int, SharedScript> sharedScripts,
        CancellationToken ct)
    {
        if (apiMethods.Count == 0) return;
        var allShared = await _templates.GetAllSharedScriptsAsync(ct).ConfigureAwait(false);
        foreach (var shared in allShared)
        {
            if (sharedScripts.ContainsKey(shared.Id)) continue;
            if (apiMethods.Values.Any(m => ContainsIdentifier(m.Script, shared.Name)))
            {
                sharedScripts[shared.Id] = shared;
            }
        }
    }

    // ---- ExternalSystem pulls from template script/attribute bodies ----
    private async Task ExpandExternalSystemsFromTemplatesAsync(
        Dictionary<int, Template> templates,
        Dictionary<int, ExternalSystemDefinition> externalSystems,
        CancellationToken ct)
    {
        var allSystems = await _externalSystems.GetAllExternalSystemsAsync(ct).ConfigureAwait(false);
        foreach (var es in allSystems)
        {
            if (externalSystems.ContainsKey(es.Id)) continue;
            if (TemplatesReferenceName(templates.Values, es.Name))
            {
                externalSystems[es.Id] = es;
            }
        }
    }

    private static bool TemplatesReferenceName(IEnumerable<Template> templates, string name)
    {
        foreach (var t in templates)
        {
            foreach (var s in t.Scripts)
            {
                if (ContainsIdentifier(s.Code, name)) return true;
            }
            foreach (var a in t.Attributes)
            {
                if (a.DataSourceReference is not null && ContainsIdentifier(a.DataSourceReference, name)) return true;
                if (a.Value is not null && ContainsIdentifier(a.Value, name)) return true;
            }
        }
        return false;
    }

    /// <summary>
    /// Substring scan with word-boundary guarding: the name must not be a partial
    /// match of a longer identifier. Cheap, dependency-free, sufficient for the
    /// v1 export-time scan (callers can always over-include with explicit ids).
    /// </summary>
    private static bool ContainsIdentifier(string? haystack, string name)
    {
        if (string.IsNullOrEmpty(haystack) || string.IsNullOrEmpty(name)) return false;
        var idx = 0;
        while (true)
        {
            var hit = haystack.IndexOf(name, idx, StringComparison.Ordinal);
            if (hit < 0) return false;
            var before = hit == 0 ? '\0' : haystack[hit - 1];
            var afterIdx = hit + name.Length;
            var after = afterIdx >= haystack.Length ? '\0' : haystack[afterIdx];
            if (!IsIdentifierChar(before) && !IsIdentifierChar(after)) return true;
            idx = hit + 1;
        }
    }

    private static bool IsIdentifierChar(char c) => c == '_' || char.IsLetterOrDigit(c);

    // ---- Folder ancestor chain ----
    private async Task<IReadOnlyList<TemplateFolder>> ResolveFolderChainAsync(
        IEnumerable<Template> templates,
        CancellationToken ct)
    {
        var allFolders = await _templates.GetAllFoldersAsync(ct).ConfigureAwait(false);
        var byId = allFolders.ToDictionary(f => f.Id);

        var needed = new Dictionary<int, TemplateFolder>();
        foreach (var t in templates)
        {
            var fid = t.FolderId;
            while (fid is not null && byId.TryGetValue(fid.Value, out var folder))
            {
                if (!needed.TryAdd(folder.Id, folder)) break; // already walked this chain
                fid = folder.ParentFolderId;
            }
        }

        // Root-first ordering so importers create parents before children.
        return needed.Values
            .OrderBy(f => DepthOf(f, byId))
            .ThenBy(f => f.SortOrder)
            .ThenBy(f => f.Name, StringComparer.Ordinal)
            .ToList();
    }

    private static int DepthOf(TemplateFolder folder, IReadOnlyDictionary<int, TemplateFolder> byId)
    {
        var depth = 0;
        var current = folder;
        while (current.ParentFolderId is int pid && byId.TryGetValue(pid, out var parent))
        {
            depth++;
            current = parent;
            if (depth > 1024) break; // defensive: folder graph is acyclic by schema
        }
        return depth;
    }

    // ---- Kahn's algorithm: order templates base-before-derived ----
    /// <summary>Sorts templates in base-before-derived order using Kahn's algorithm.</summary>
    /// <param name="templates">The templates to sort; must form an acyclic composition graph.</param>
    /// <returns>Templates sorted so composed (base) templates appear before their composing (derived) templates.</returns>
    internal static List<Template> TopologicallySortTemplates(IEnumerable<Template> templates)
    {
        // Edge: composed --> composing (composed must appear first).
        var nodes = templates.ToDictionary(t => t.Id);
        var inDegree = nodes.ToDictionary(kv => kv.Key, _ => 0);
        var outEdges = nodes.ToDictionary(kv => kv.Key, _ => new List<int>());

        foreach (var t in nodes.Values)
        {
            foreach (var comp in t.Compositions)
            {
                if (!nodes.ContainsKey(comp.ComposedTemplateId)) continue;
                outEdges[comp.ComposedTemplateId].Add(t.Id);
                inDegree[t.Id]++;
            }
        }

        var queue = new Queue<int>(
            inDegree.Where(kv => kv.Value == 0)
                    .OrderBy(kv => nodes[kv.Key].Name, StringComparer.Ordinal)
                    .Select(kv => kv.Key));

        var result = new List<Template>(nodes.Count);
        while (queue.Count > 0)
        {
            var id = queue.Dequeue();
            result.Add(nodes[id]);
            foreach (var next in outEdges[id].OrderBy(x => nodes[x].Name, StringComparer.Ordinal))
            {
                if (--inDegree[next] == 0) queue.Enqueue(next);
            }
        }

        if (result.Count != nodes.Count)
            throw new InvalidOperationException("Template composition graph is cyclic");
        return result;
    }

    private static IReadOnlyList<ManifestContentEntry> BuildContentManifest(
        IReadOnlyList<TemplateFolder> folders,
        IReadOnlyList<Template> templates,
        IEnumerable<SharedScript> sharedScripts,
        IEnumerable<ExternalSystemDefinition> externalSystems,
        IEnumerable<ExternalSystemMethod> externalSystemMethods,
        IEnumerable<DatabaseConnectionDefinition> dbConnections,
        IEnumerable<NotificationList> notificationLists,
        IEnumerable<SmtpConfiguration> smtpConfigs,
        IEnumerable<ApiMethod> apiMethods)
    {
        var entries = new List<ManifestContentEntry>();

        foreach (var f in folders)
        {
            entries.Add(new ManifestContentEntry("TemplateFolder", f.Name, 1, Array.Empty<string>()));
        }
        foreach (var t in templates)
        {
            var deps = t.Compositions
                .Select(c => $"Template:{(templates.FirstOrDefault(x => x.Id == c.ComposedTemplateId)?.Name ?? c.ComposedTemplateId.ToString())}")
                .OrderBy(x => x, StringComparer.Ordinal)
                .ToList();
            entries.Add(new ManifestContentEntry("Template", t.Name, 1, deps));
        }
        foreach (var s in sharedScripts.OrderBy(x => x.Name, StringComparer.Ordinal))
        {
            entries.Add(new ManifestContentEntry("SharedScript", s.Name, 1, Array.Empty<string>()));
        }
        foreach (var es in externalSystems.OrderBy(x => x.Name, StringComparer.Ordinal))
        {
            entries.Add(new ManifestContentEntry("ExternalSystem", es.Name, 1, Array.Empty<string>()));
        }
        var methodsBySystem = externalSystemMethods.GroupBy(m => m.ExternalSystemDefinitionId);
        var systemById = externalSystems.ToDictionary(x => x.Id);
        foreach (var grp in methodsBySystem.OrderBy(g => systemById.TryGetValue(g.Key, out var es) ? es.Name : string.Empty, StringComparer.Ordinal))
        {
            var systemName = systemById.TryGetValue(grp.Key, out var es) ? es.Name : grp.Key.ToString();
            foreach (var m in grp.OrderBy(x => x.Name, StringComparer.Ordinal))
            {
                entries.Add(new ManifestContentEntry(
                    "ExternalSystemMethod",
                    $"{systemName}.{m.Name}",
                    1,
                    new[] { $"ExternalSystem:{systemName}" }));
            }
        }
        foreach (var d in dbConnections.OrderBy(x => x.Name, StringComparer.Ordinal))
        {
            entries.Add(new ManifestContentEntry("DatabaseConnection", d.Name, 1, Array.Empty<string>()));
        }
        foreach (var n in notificationLists.OrderBy(x => x.Name, StringComparer.Ordinal))
        {
            entries.Add(new ManifestContentEntry("NotificationList", n.Name, 1, Array.Empty<string>()));
        }
        foreach (var s in smtpConfigs.OrderBy(x => x.Host, StringComparer.Ordinal))
        {
            entries.Add(new ManifestContentEntry("SmtpConfiguration", s.Host, 1, Array.Empty<string>()));
        }
        // Inbound API keys are not transported (re-arch C4) — no ApiKey manifest entries.
        foreach (var m in apiMethods.OrderBy(x => x.Name, StringComparer.Ordinal))
        {
            entries.Add(new ManifestContentEntry("ApiMethod", m.Name, 1, Array.Empty<string>()));
        }

        return entries;
    }
}
