[DebuggerTypeProxy(typeof(SharedLockDebugView))]
internal sealed class SharedLock : IDisposable
{
    private readonly ReaderWriterLockSlim Lock;

    internal SharedLock(LockRecursionPolicy recursionPolicy = LockRecursionPolicy.NoRecursion)
    {
        this.Lock = new(recursionPolicy);
    }

    internal static class Cookie
    {
        internal readonly ref struct ReadLock
        {
            private readonly ReaderWriterLockSlim Lock;

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal ReadLock(ReaderWriterLockSlim rwLock)
            {
                this.Lock = rwLock;
                rwLock.EnterReadLock();
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal void Dispose()
            {
                this.Lock.ExitReadLock();
            }
        }

        internal readonly ref struct UpgradableReadLock
        {
            private readonly ReaderWriterLockSlim Lock;

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal UpgradableReadLock(ReaderWriterLockSlim rwLock)
            {
                this.Lock = rwLock;
                rwLock.EnterUpgradeableReadLock();
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal void Dispose()
            {
                this.Lock.ExitUpgradeableReadLock();
            }
        }

        internal readonly ref struct WriteLock
        {
            private readonly ReaderWriterLockSlim Lock;

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal WriteLock(ReaderWriterLockSlim rwLock)
            {
                this.Lock = rwLock;
                rwLock.EnterWriteLock();
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal void Dispose()
            {
                this.Lock.ExitWriteLock();
            }
        }
    }

    internal Cookie.ReadLock Read => new(this.Lock);
    internal Cookie.UpgradableReadLock UpgradableRead => new(this.Lock);
    internal Cookie.WriteLock Write => new(this.Lock);

    public void Dispose()
    {
        this.Lock.Dispose();
    }

    private class SharedLockDebugView
    {
        private readonly SharedLock Lock;

        public SharedLockDebugView(SharedLock sharedLock)
        {
            this.Lock = sharedLock;
        }

        public bool IsRecursive => this.Lock.Lock.RecursionPolicy != LockRecursionPolicy.NoRecursion;
        public bool HasLock => this.HasReadLock || this.HasWriteLock || this.HasUpgradeableReadLock;
        public bool HasReadLock => this.Lock.Lock.IsReadLockHeld;
        public bool HasWriteLock => this.Lock.Lock.IsWriteLockHeld;
        public bool HasUpgradeableReadLock => this.Lock.Lock.IsUpgradeableReadLockHeld;
        public ReaderWriterLockSlim UnderlyingLock => this.Lock.Lock;
    }
}