using System;
using System.Collections.Generic;
using System.Threading;

public delegate void ObservablePropertySubscriber<in T>(T oldValue, T newValue);

public interface IObservableProperty<out T>
{
    /// <summary>
    /// The current value of the observable property
    /// </summary>
    T Value { get; }

    /// <summary>
    /// Subscribe to changes from this property
    /// </summary>
    /// <remarks>
    /// <paramref name="subscriber"/> will be called on a captured <see cref="SynchronizationContext"/>
    /// </remarks>
    void Subscribe(ObservablePropertySubscriber<T> subscriber, CancellationToken token);

    /// <summary>
    /// Subscribe to changes from this property
    /// </summary>
    /// <remarks>
    /// <paramref name="subscriber"/> will NOT be called on a captured <see cref="SynchronizationContext"/>
    /// </remarks>
    void SubscribeSynchronously(ObservablePropertySubscriber<T> subscriber, CancellationToken token);

    /// <summary>
    /// Subscribe to changes from this property. <paramref name="subscriber"/> will be called immediately with the current value
    /// </summary>
    /// <remarks>
    /// <paramref name="subscriber"/> will be called on a captured <see cref="SynchronizationContext"/>
    /// </remarks>
    void SubscribeAndNotify(ObservablePropertySubscriber<T> subscriber, CancellationToken token);
}

public class ObservableProperty<T> : PublisherBase<ObservablePropertySubscriber<T>>, IObservableProperty<T>
{
    private readonly object _valueLock = new();
    private readonly IEqualityComparer<T> _comparer;

    private readonly T _initialValue;

    private T _value;
    public T Value
    {
        get
        {
            lock (_valueLock)
            {
                return _value;
            }
        }
    }

    public ObservableProperty(T initialValue, IEqualityComparer<T>? comparer = null)
    {
        _comparer = comparer ?? EqualityComparer<T>.Default;
        _initialValue = initialValue;
        _value = initialValue;
    }

    public void SubscribeAndNotify(ObservablePropertySubscriber<T> subscriber, CancellationToken token)
    {
        AddSubscriber(subscriber, SynchronizationContext.Current ?? new SynchronizationContext(), token);

        if (!token.IsCancellationRequested)
        {
            T value;
            lock (_valueLock)
            {
                value = _value;
            }
            subscriber(_initialValue, value);
        }
    }

    public void Publish(T newValue)
    {
        T oldValue;
        lock (_valueLock)
        {
            oldValue = _value;
            if (_comparer.Equals(oldValue, newValue))
            {
                return;
            }

            _value = newValue;
        }

        Publish(x => x.Invoke(oldValue, newValue));
    }

    public void UpdateValue(Func<T, T> updater)
    {
        // We're calling upwards within a lock! The caller must be careful to limit the scope of this
        T oldValue;
        T newValue;
        lock (_valueLock)
        {
            oldValue = _value;
            newValue = updater(_value);
            if (_comparer.Equals(oldValue, newValue))
            {
                return;
            }

            _value = newValue;
        }

        Publish(x => x.Invoke(oldValue, newValue));
    }

    private class Subscriber
    {
        public ObservablePropertySubscriber<T> Delegate { get; init; } = null!;
        public SynchronizationContext SynchronizationContext { get; init; } = null!;
    }
}