using System.Collections.Concurrent;
using System.Runtime.CompilerServices;

namespace FluidExplorer.Services.Search.Usn;

/// <summary>
/// 索引的紧凑存储：结构体数组（Struct-of-Arrays）而不是对象数组。
///
/// 每条记录只占 45 字节（8+8+8+8+8+4+1），100 万条约 45MB，
/// 再加上名字池（约 2 字节/字符）就构成整个索引；绝无 per-entry 的对象头与 string。
///
/// 并发模型（读多写极少）：
///  * <see cref="Count"/> 用 volatile 发布：写入方先写满数据，最后自增 Count；读方只需读一次 Count 再顺序访问。
///  * 结构只增不减（删除只打墓碑标志位），因此已经发布的 [0, Count) 区间永远有效。
///  * 容量不足时 <see cref="Grow"/> 采用 copy-on-write，整体替换数组；老快照对正在查询的线程依然合法。
/// </summary>
internal sealed class IndexStore
{
    internal const byte FlagDeleted = 0x01;
    internal const byte FlagDirectory = 0x02;
    internal const byte FlagSizeKnown = 0x04;

    internal readonly ulong[] Frn;            // 归一化 FRN（低 48 位记录号）
    internal readonly ulong[] ParentFrn;      // 归一化父目录 FRN
    internal readonly long[] NameRef;         // NamePool.Pack(偏移, 长度)
    internal readonly long[] Size;            // -1 = 未知（USN 降级模式）
    internal readonly long[] ModifiedTicks;   // UTC ticks；0 = 未知
    internal readonly uint[] Attributes;      // FILE_ATTRIBUTE_*
    internal readonly byte[] Flags;

    /// <summary>
    /// 名字池与数组快照绑定在一起：查询只需抓取一次 store 引用就能得到一致的 (名字池, 数组, 条数)。
    /// 关键：扩容（<see cref="Grow"/>）必须<b>复用同一个名字池</b> —— NameRef 里存的是池内偏移，
    /// 换池等于让所有老记录的名字全部失效。
    /// </summary>
    internal readonly NamePool Names;

    internal readonly int Capacity;

    /// <summary>已发布条数。写入方必须在写完所有字段之后再自增它。</summary>
    internal volatile int Count;

    internal IndexStore(int capacity) : this(capacity, new NamePool())
    {
    }

    private IndexStore(int capacity, NamePool names)
    {
        if (capacity < 16) capacity = 16;
        Capacity = capacity;
        Names = names;
        Frn = new ulong[capacity];
        ParentFrn = new ulong[capacity];
        NameRef = new long[capacity];
        Size = new long[capacity];
        ModifiedTicks = new long[capacity];
        Attributes = new uint[capacity];
        Flags = new byte[capacity];
    }

    private IndexStore(IndexStore old, int capacity) : this(capacity, old.Names)
    {
        int n = old.Count;
        Array.Copy(old.Frn, Frn, n);
        Array.Copy(old.ParentFrn, ParentFrn, n);
        Array.Copy(old.NameRef, NameRef, n);
        Array.Copy(old.Size, Size, n);
        Array.Copy(old.ModifiedTicks, ModifiedTicks, n);
        Array.Copy(old.Attributes, Attributes, n);
        Array.Copy(old.Flags, Flags, n);
        Count = n;
    }

    /// <summary>扩容（copy-on-write）。返回新快照，旧快照仍然可被并发查询安全使用。</summary>
    internal static IndexStore Grow(IndexStore old, int minCapacity)
    {
        int capacity = old.Capacity;
        while (capacity < minCapacity) capacity = capacity < 1024 ? capacity * 2 : capacity + (capacity >> 1);
        return new IndexStore(old, capacity);
    }

    internal bool IsDeleted(int i) => (Flags[i] & FlagDeleted) != 0;

    internal bool IsDirectory(int i) => (Flags[i] & FlagDirectory) != 0;

    /// <summary>读名字（零分配）。</summary>
    internal ReadOnlySpan<char> GetName(int i)
    {
        long nameRef = Volatile.Read(ref NameRef[i]);
        return Names.Get(NamePool.UnpackOffset(nameRef), NamePool.UnpackLength(nameRef));
    }
}

/// <summary>
/// FRN（低 48 位记录号）→ 索引下标的映射。
///
/// 策略：构建期用普通 Dictionary 最快；构建结束后调用 <see cref="Optimize"/>，
/// 如果记录号足够密集（maxRecord &lt;= 8 * count），就换成“记录号直接寻址”的 int[]，
/// 100 万文件只占几 MB（而 Dictionary 要 30~40MB）。
/// 稀疏卷或监听期新增的越界记录号退回到 <see cref="ConcurrentDictionary{TKey,TValue}"/> 侧表。
/// </summary>
internal sealed class FrnMap
{
    private const int NoIndex = 0;
    private const int DenseSlack = 8;

    private Dictionary<ulong, int>? _buildMap;
    private int[]? _dense;                       // 记录号 → 下标+1；0 表示不存在
    private ConcurrentDictionary<ulong, int>? _sparse;

    internal FrnMap(int estimatedCount)
    {
        _buildMap = new Dictionary<ulong, int>(Math.Max(16, estimatedCount));
    }

    internal int Count => _buildMap?.Count ?? _sparse?.Count ?? _dense?.Length ?? 0;

    /// <summary>构建期写入（单线程，无锁，最快）。</summary>
    internal void AddBuild(ulong frn, int index)
    {
        _buildMap![UsnNative.NormalizeFrn(frn)] = index;
    }

    /// <summary>构建完成后调用：把构建期的 Dictionary 压缩成密集数组或稀疏侧表。</summary>
    internal void Optimize()
    {
        var map = _buildMap ?? throw new InvalidOperationException("FrnMap 已经压缩过。");
        _buildMap = null;

        ulong maxRecord = 0;
        foreach (var key in map.Keys)
        {
            if (key > maxRecord) maxRecord = key;
        }

        // 密集数组代价 = (maxRecord+1)*4 字节；只要不超过 8 个记录号/条目的开销就值得。
        if (map.Count > 0 && maxRecord <= (ulong)map.Count * DenseSlack)
        {
            var dense = new int[maxRecord + 1];
            foreach (var (key, value) in map)
            {
                dense[key] = value + 1;
            }
            Volatile.Write(ref _dense, dense);
            return;
        }

        var sparse = new ConcurrentDictionary<ulong, int>();
        foreach (var (key, value) in map)
        {
            sparse[key] = value;
        }
        Volatile.Write(ref _sparse, sparse);
    }

    /// <summary>监听期写入（可能并发于查询，必须线程安全）。</summary>
    internal void Set(ulong frn, int index)
    {
        ulong record = UsnNative.NormalizeFrn(frn);
        var dense = Volatile.Read(ref _dense);
        if (dense is not null && record < (ulong)dense.Length)
        {
            Volatile.Write(ref dense[record], index + 1);
            return;
        }
        var sparse = _sparse;
        if (sparse is null)
        {
            var created = new ConcurrentDictionary<ulong, int>();
            sparse = Interlocked.CompareExchange(ref _sparse, created, null) ?? created;
        }
        sparse[record] = index;
    }

    /// <summary>批量覆盖（重建索引时用，单线程）。</summary>
    internal void SetUnsafe(ulong frn, int index)
    {
        ulong record = UsnNative.NormalizeFrn(frn);
        var dense = _dense;
        if (dense is not null && record < (ulong)dense.Length)
        {
            dense[record] = index + 1;
            return;
        }
        _sparse![record] = index;
    }

    internal bool TryGet(ulong frn, out int index)
    {
        ulong record = UsnNative.NormalizeFrn(frn);
        var dense = Volatile.Read(ref _dense);
        if (dense is not null && record < (ulong)dense.Length)
        {
            int slot = Volatile.Read(ref dense[record]);
            if (slot == NoIndex)
            {
                index = -1;
                return false;
            }
            index = slot - 1;
            return true;
        }
        var sparse = Volatile.Read(ref _sparse);
        if (sparse is not null && sparse.TryGetValue(record, out index)) return true;
        index = -1;
        return false;
    }

    /// <summary>NormizeFrn 的别名，便于调用点表达意图。</summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal static ulong Normalize(ulong frn) => UsnNative.NormalizeFrn(frn);
}