From 28cca98cfe180693180160c5494d3cc07ea4ab61 Mon Sep 17 00:00:00 2001
From: Yoh Deadfall <yoh.deadfall@hotmail.com>
Date: Thu, 4 Jul 2024 22:24:37 +0300
Subject: [PATCH] OnItemAdded behaves as a list if the rest implements it

---
 .../Linq/ObservableView.OnItemAdded.cs        | 62 +++++++++++++++++--
 .../StateMachines/ListProxyStateMachine.cs    | 28 +++++++++
 test/Kinetic.Tests/ObservableViewTests.cs     |  1 +
 3 files changed, 86 insertions(+), 5 deletions(-)
 create mode 100644 src/Kinetic/Linq/StateMachines/ListProxyStateMachine.cs

diff --git a/src/Kinetic/Linq/ObservableView.OnItemAdded.cs b/src/Kinetic/Linq/ObservableView.OnItemAdded.cs
index acef16b..c086cce 100644
--- a/src/Kinetic/Linq/ObservableView.OnItemAdded.cs
+++ b/src/Kinetic/Linq/ObservableView.OnItemAdded.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Kinetic.Linq.StateMachines;
 
 namespace Kinetic.Linq;
@@ -6,12 +7,63 @@ namespace Kinetic.Linq;
 public static partial class ObservableView
 {
     public static ObserverBuilder<ListChange<TSource>> OnItemAdded<TSource>(this ObserverBuilder<ListChange<TSource>> source, Action<TSource> action) =>
-        source.Do(change =>
-        {
-            if (change.Action is ListChangeAction.Insert or ListChangeAction.Replace)
-                action(change.NewItem);
-        });
+        source.ContinueWith<OnItemAddedStateMachineFactory<TSource>, ListChange<TSource>>(new() { Action = action });
 
     public static ObserverBuilder<ListChange<TSource>> OnItemAdded<TSource>(this ReadOnlyObservableList<TSource> source, Action<TSource> action) =>
         source.Changed.ToBuilder().OnItemAdded(action);
+
+    private struct OnItemAddedStateMachineFactory<TSource> : IStateMachineFactory<ListChange<TSource>, ListChange<TSource>>
+    {
+        public required Action<TSource> Action { get; init; }
+
+        public void Create<TContinuation>(in TContinuation continuation, ObserverStateMachine<ListChange<TSource>> source)
+            where TContinuation : struct, IStateMachine<ListChange<TSource>>
+        {
+            source.ContinueWith<OnItemAddedStateMachine<TSource, TContinuation>>(new(continuation, Action));
+        }
+    }
+
+    private struct OnItemAddedStateMachine<TSource, TContinuation> : IStateMachine<ListChange<TSource>>
+        where TContinuation : struct, IStateMachine<ListChange<TSource>>
+    {
+        private TContinuation _continuation;
+        private readonly Action<TSource> _action;
+
+        public OnItemAddedStateMachine(in TContinuation continuation, Action<TSource> action)
+        {
+            _continuation = continuation;
+            _action = action;
+        }
+
+        public StateMachineBox Box =>
+            _continuation.Box;
+
+        public StateMachine<ListChange<TSource>> Reference =>
+            _continuation.Reference is IReadOnlyList<TSource> list
+            ? new ListProxyStateMachine<TSource, OnItemAddedStateMachine<TSource, TContinuation>>(ref this, list)
+            : StateMachine<ListChange<TSource>>.Create(ref this);
+
+        public StateMachine? Continuation =>
+            _continuation.Reference;
+
+        public void Initialize(StateMachineBox box) =>
+            _continuation.Initialize(box);
+
+        public void Dispose() =>
+            _continuation.Dispose();
+
+        public void OnCompleted() =>
+            _continuation.OnCompleted();
+
+        public void OnError(Exception error) =>
+            _continuation.OnError(error);
+
+        public void OnNext(ListChange<TSource> value)
+        {
+            if (value.Action is ListChangeAction.Insert or ListChangeAction.Replace)
+                _action(value.NewItem);
+
+            _continuation.OnNext(value);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Kinetic/Linq/StateMachines/ListProxyStateMachine.cs b/src/Kinetic/Linq/StateMachines/ListProxyStateMachine.cs
new file mode 100644
index 0000000..3de504e
--- /dev/null
+++ b/src/Kinetic/Linq/StateMachines/ListProxyStateMachine.cs
@@ -0,0 +1,28 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Kinetic.Linq.StateMachines;
+
+internal sealed class ListProxyStateMachine<T, TStateMachine> : StateMachine<ListChange<T>, TStateMachine>, IReadOnlyList<T>
+    where TStateMachine : struct, IStateMachine<ListChange<T>>
+{
+    private readonly IReadOnlyList<T> _list;
+
+    public ListProxyStateMachine(ref TStateMachine stateMachine, IReadOnlyList<T> list) :
+        base(ref stateMachine) => _list = list;
+
+    public ListProxyStateMachine(StateMachineReference<ListChange<T>, TStateMachine> stateMachine, IReadOnlyList<T> list) :
+        base(stateMachine) => _list = list;
+
+    public T this[int index] =>
+        _list[index];
+
+    public int Count =>
+        _list.Count;
+
+    public IEnumerator<T> GetEnumerator() =>
+        _list.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() =>
+        _list.GetEnumerator();
+}
\ No newline at end of file
diff --git a/test/Kinetic.Tests/ObservableViewTests.cs b/test/Kinetic.Tests/ObservableViewTests.cs
index 25fcb71..331f2dd 100644
--- a/test/Kinetic.Tests/ObservableViewTests.cs
+++ b/test/Kinetic.Tests/ObservableViewTests.cs
@@ -385,6 +385,7 @@ public void OnItemRemoved()
             .Subscribe();
 
         list.Add(0);
+        list.RemoveAt(0);
 
         Assert.True(handledBefore);
         Assert.True(handledAfter);