using System.Collections.Generic;

namespace GB5Shared.DTO.Qualifier
{
    // ============================================================
    // QualifierFactBag — Hierarchical Fact Store
    //
    // Three scopes, matching MQUALIFIEROUTPUT.OUTPUTSCOPE:
    //   Document  — one set of key-value facts for the whole document
    //   Lines     — per-line key-value facts (index matches source line index)
    //   Groups    — arbitrary named groups (e.g. tax buckets, approval tiers)
    //
    // ExportAll() produces:
    //   { "Document": {...}, "Lines": [...], "Groups": {...} }
    // which is the shape expected by the mapping engine's [FactBag] path prefix.
    //
    // Thread safety: qualifiers at the same DAG execution level run concurrently
    // (QualifierFacadeImpl.ExecuteStageAsync uses Task.WhenAll) against the SAME
    // FactBag instance, so every read/write here is guarded by a single lock --
    // the operations are simple dictionary/list mutations, so a coarse-grained
    // lock is cheap and avoids the finer-grained bugs a per-collection lock
    // scheme would risk.
    // ============================================================
    public sealed class QualifierFactBag
    {
        private readonly object _gate = new();

        private readonly Dictionary<string, object?>                         _document = new();
        private readonly List<Dictionary<string, object?>>                   _lines    = [];
        private readonly Dictionary<string, Dictionary<string, object?>>     _groups   = new();

        // ── Document facts ────────────────────────────────────────────────────────

        public void SetDocumentFact(string key, object? value)
        {
            lock (_gate) { _document[key] = value; }
        }

        public T? GetDocumentFact<T>(string key)
        {
            lock (_gate)
            {
                return _document.TryGetValue(key, out var v) && v is T typed ? typed : default;
            }
        }

        public bool HasDocumentFact(string key)
        {
            lock (_gate) { return _document.ContainsKey(key); }
        }

        // ── Line facts ────────────────────────────────────────────────────────────

        /// <summary>
        /// Ensures the Lines list has at least <paramref name="minCount"/> entries,
        /// padding with empty dictionaries as needed.
        /// </summary>
        public void EnsureLineCapacity(int minCount)
        {
            lock (_gate) { EnsureLineCapacityLocked(minCount); }
        }

        private void EnsureLineCapacityLocked(int minCount)
        {
            while (_lines.Count < minCount)
                _lines.Add(new Dictionary<string, object?>());
        }

        public void SetLineFact(int lineIndex, string key, object? value)
        {
            lock (_gate)
            {
                EnsureLineCapacityLocked(lineIndex + 1);
                _lines[lineIndex][key] = value;
            }
        }

        public T? GetLineFact<T>(int lineIndex, string key)
        {
            lock (_gate)
            {
                if (lineIndex < 0 || lineIndex >= _lines.Count) return default;
                return _lines[lineIndex].TryGetValue(key, out var v) && v is T typed ? typed : default;
            }
        }

        public bool HasLineFact(int lineIndex, string key)
        {
            lock (_gate)
            {
                return lineIndex >= 0 && lineIndex < _lines.Count && _lines[lineIndex].ContainsKey(key);
            }
        }

        public int LineCount
        {
            get { lock (_gate) { return _lines.Count; } }
        }

        // ── Group facts ───────────────────────────────────────────────────────────

        public void SetGroup(string groupKey, string factKey, object? value)
        {
            lock (_gate)
            {
                if (!_groups.TryGetValue(groupKey, out var group))
                {
                    group = new Dictionary<string, object?>();
                    _groups[groupKey] = group;
                }
                group[factKey] = value;
            }
        }

        public T? GetGroupFact<T>(string groupKey, string factKey)
        {
            lock (_gate)
            {
                if (!_groups.TryGetValue(groupKey, out var group)) return default;
                return group.TryGetValue(factKey, out var v) && v is T typed ? typed : default;
            }
        }

        public bool HasGroup(string groupKey)
        {
            lock (_gate) { return _groups.ContainsKey(groupKey); }
        }

        // ── Export ────────────────────────────────────────────────────────────────

        /// <summary>
        /// Produces the canonical hierarchical export used by the mapping engine:
        /// <code>{ "Document": {...}, "Lines": [...], "Groups": {...} }</code>
        /// </summary>
        public IReadOnlyDictionary<string, object?> ExportAll()
        {
            lock (_gate)
            {
                // Snapshot each section to avoid mutation while the caller reads.
                var docSnapshot = new Dictionary<string, object?>(_document);

                var linesSnapshot = new List<IReadOnlyDictionary<string, object?>>(_lines.Count);
                foreach (var line in _lines)
                    linesSnapshot.Add(new Dictionary<string, object?>(line));

                var groupsSnapshot = new Dictionary<string, object?>();
                foreach (var (key, group) in _groups)
                    groupsSnapshot[key] = new Dictionary<string, object?>(group);

                return new Dictionary<string, object?>
                {
                    ["Document"] = docSnapshot,
                    ["Lines"]    = linesSnapshot,
                    ["Groups"]   = groupsSnapshot
                };
            }
        }
    }
}