using Microsoft.Extensions.Logging;
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;

namespace ZB.MOM.WW.OtOpcUa.OpcUaServer;

/// <summary>
///     Side-effecting orchestrator over <see cref="Phase7Plan"/>. Drives an
///     <see cref="IOpcUaAddressSpaceSink"/> to materialise the diff between two
///     <see cref="Phase7CompositionResult"/> snapshots:
///
///     <list type="bullet">
///         <item>RemovedEquipment / RemovedAlarms — write Bad-quality on every removed
///             node id then call <c>RebuildAddressSpace</c> at the end so the sink can
///             actually tear down the OPC UA folders + variables.</item>
///         <item>AddedEquipment / AddedAlarms — same Rebuild trigger (real SDK NodeManager
///             will repopulate from the persisted artifact). For now we record the work.</item>
///         <item>ChangedEquipment / ChangedAlarms — record what changed; the SDK adapter
///             that lands in F10b will decide between in-place property writes and
///             tear-down + rebuild.</item>
///     </list>
///
///     This is the side-effecting layer Task 47 deferred to F14. It stays pure-of-SDK so
///     production binds a real SDK sink, dev/Mac binds <see cref="NullOpcUaAddressSpaceSink"/>,
///     and tests can capture every call.
/// </summary>
public sealed class Phase7Applier
{
    private readonly IOpcUaAddressSpaceSink _sink;
    private readonly ILogger<Phase7Applier> _logger;

    /// <summary>Initializes a new instance of the Phase7Applier class.</summary>
    /// <param name="sink">The OPC UA address space sink to apply changes to.</param>
    /// <param name="logger">The logger instance.</param>
    public Phase7Applier(IOpcUaAddressSpaceSink sink, ILogger<Phase7Applier> logger)
    {
        ArgumentNullException.ThrowIfNull(sink);
        ArgumentNullException.ThrowIfNull(logger);
        _sink = sink;
        _logger = logger;
    }

    /// <summary>
    ///     Apply <paramref name="plan"/> to the sink. Returns a summary of what was applied so
    ///     callers (OpcUaPublishActor) can correlate the work back to the originating deployment.
    /// </summary>
    /// <param name="plan">The plan to apply.</param>
    /// <returns>A Phase7ApplyOutcome summarizing the applied changes.</returns>
    public Phase7ApplyOutcome Apply(Phase7Plan plan)
    {
        ArgumentNullException.ThrowIfNull(plan);

        if (plan.IsEmpty)
        {
            _logger.LogDebug("Phase7Applier: plan is empty; skipping sink writes");
            return new Phase7ApplyOutcome(RemovedNodes: 0, AddedNodes: 0, ChangedNodes: 0, RebuildCalled: false);
        }

        var ts = DateTime.UtcNow;
        var removedCount = 0;
        foreach (var eq in plan.RemovedEquipment)
        {
            SafeWriteAlarmState(eq.EquipmentId, active: false, acknowledged: false, ts);
            removedCount++;
        }
        foreach (var alarm in plan.RemovedAlarms)
        {
            SafeWriteAlarmState(alarm.ScriptedAlarmId, active: false, acknowledged: false, ts);
            removedCount++;
        }

        var changedCount =
            plan.ChangedEquipment.Count + plan.ChangedDrivers.Count + plan.ChangedAlarms.Count +
            plan.ChangedGalaxyTags.Count;
        var addedCount =
            plan.AddedEquipment.Count + plan.AddedDrivers.Count + plan.AddedAlarms.Count +
            plan.AddedGalaxyTags.Count;

        // Any add/remove of Equipment, ScriptedAlarm, or Galaxy tag topology requires a real
        // address-space rebuild. Driver-instance changes don't touch the address-space topology
        // directly — they go through DriverHostActor's spawn-plan in Runtime.
        var needsRebuild =
            plan.AddedEquipment.Count > 0 || plan.RemovedEquipment.Count > 0 ||
            plan.AddedAlarms.Count > 0 || plan.RemovedAlarms.Count > 0 ||
            plan.AddedGalaxyTags.Count > 0 || plan.RemovedGalaxyTags.Count > 0;

        if (needsRebuild)
        {
            try
            {
                _sink.RebuildAddressSpace();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Phase7Applier: sink.RebuildAddressSpace threw");
            }
        }

        _logger.LogInformation(
            "Phase7Applier: applied plan (added={Added}, removed={Removed}, changed={Changed}, rebuild={Rebuild})",
            addedCount, removedCount, changedCount, needsRebuild);

        return new Phase7ApplyOutcome(removedCount, addedCount, changedCount, needsRebuild);
    }

    /// <summary>
    ///     #85 — build the UNS Area/Line/Equipment folder hierarchy in the address space from a
    ///     composition snapshot. Called by <c>OpcUaPublishActor</c> after a rebuild so OPC UA
    ///     clients browsing the server see proper folder structure instead of flat tag ids.
    ///     Idempotent: each <c>EnsureFolder</c> call returns the existing folder if already
    ///     present, so re-applies are cheap.
    /// </summary>
    /// <param name="composition">The composition result containing the hierarchy to materialise.</param>
    public void MaterialiseHierarchy(Phase7CompositionResult composition)
    {
        ArgumentNullException.ThrowIfNull(composition);

        foreach (var area in composition.UnsAreas)
        {
            SafeEnsureFolder(area.UnsAreaId, parentNodeId: null, displayName: area.DisplayName);
        }
        foreach (var line in composition.UnsLines)
        {
            SafeEnsureFolder(line.UnsLineId, parentNodeId: line.UnsAreaId, displayName: line.DisplayName);
        }
        foreach (var equipment in composition.EquipmentNodes)
        {
            // Equipment with no UnsLineId (legacy / dev rows) hang under the root.
            var parent = string.IsNullOrWhiteSpace(equipment.UnsLineId) ? null : equipment.UnsLineId;
            SafeEnsureFolder(equipment.EquipmentId, parentNodeId: parent, displayName: equipment.DisplayName);
        }

        _logger.LogInformation(
            "Phase7Applier: hierarchy materialised (areas={Areas}, lines={Lines}, equipment={Equipment})",
            composition.UnsAreas.Count, composition.UnsLines.Count, composition.EquipmentNodes.Count);
    }

    /// <summary>
    ///     Materialise Galaxy / SystemPlatform-namespace tags from a composition snapshot:
    ///     for each <see cref="GalaxyTagPlan"/>, ensure its FolderPath segment exists (a folder
    ///     under the namespace root), then ensure a Variable node sits inside that folder for
    ///     the leaf <see cref="GalaxyTagPlan.DisplayName"/>. Variable starts with BadWaitingForInitialData;
    ///     the Galaxy driver's <c>OnDataChange</c> path fills the value in once SubscribeBulk lands.
    ///     Idempotent.
    /// </summary>
    /// <param name="composition">The composition result containing the Galaxy tags to materialise.</param>
    public void MaterialiseGalaxyTags(Phase7CompositionResult composition)
    {
        ArgumentNullException.ThrowIfNull(composition);
        if (composition.GalaxyTags.Count == 0) return;

        // Folders first — each distinct FolderPath becomes one folder under the root.
        var foldersCreated = new HashSet<string>(StringComparer.Ordinal);
        foreach (var tag in composition.GalaxyTags)
        {
            if (string.IsNullOrWhiteSpace(tag.FolderPath)) continue;
            if (!foldersCreated.Add(tag.FolderPath)) continue;
            SafeEnsureFolder(tag.FolderPath, parentNodeId: null, displayName: tag.FolderPath);
        }

        // Variables: NodeId is "<FolderPath>.<DisplayName>" so it matches the MXAccess ref the
        // Galaxy driver subscribes to. Browse-path lookup via OPC UA Translate is the canonical
        // resolution; flat NodeId keeps the address space lookup cheap.
        foreach (var tag in composition.GalaxyTags)
        {
            var nodeId = string.IsNullOrWhiteSpace(tag.FolderPath) ? tag.DisplayName : tag.MxAccessRef;
            var parent = string.IsNullOrWhiteSpace(tag.FolderPath) ? null : tag.FolderPath;
            SafeEnsureVariable(nodeId, parent, tag.DisplayName, tag.DataType);
        }

        _logger.LogInformation(
            "Phase7Applier: Galaxy tags materialised (tags={Tags}, folders={Folders})",
            composition.GalaxyTags.Count, foldersCreated.Count);
    }

    private void SafeEnsureFolder(string nodeId, string? parentNodeId, string displayName)
    {
        try { _sink.EnsureFolder(nodeId, parentNodeId, displayName); }
        catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: EnsureFolder threw for {Node}", nodeId); }
    }

    private void SafeEnsureVariable(string nodeId, string? parentNodeId, string displayName, string dataType)
    {
        try { _sink.EnsureVariable(nodeId, parentNodeId, displayName, dataType); }
        catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: EnsureVariable threw for {Node}", nodeId); }
    }

    private void SafeWriteAlarmState(string nodeId, bool active, bool acknowledged, DateTime ts)
    {
        try { _sink.WriteAlarmState(nodeId, active, acknowledged, ts); }
        catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: WriteAlarmState threw for {Node}", nodeId); }
    }
}

/// <summary>Summary of one apply pass. Useful for tests + audit-log entries on the deploy path.</summary>
public sealed record Phase7ApplyOutcome(
    int RemovedNodes,
    int AddedNodes,
    int ChangedNodes,
    bool RebuildCalled);
