namespace Bts.DataStream;

using BCG;

using bts.api.core;

using Bts.DataStreamCore;

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


public class TableUpdateDataPacket<T> : IDataPacket<T> where T : IBlueRow {
   readonly TableUpdate<T, int> table;
   readonly IBlueTableSchema schema;

   public TableUpdateDataPacket(TableUpdate<T, int> table, IBlueTableSchema schema) {
      this.table = table;
      this.schema = schema;
   }

   public IBlueRowCollection<T> newRows {
      get {
         var rv = new BlueTableImmutable<T>(schema);
         return rv;
      }
   }

   public IBlueRowCollection<T> addedRows => throw new NotImplementedException();

   public IBlueRowCollection<T> deletedRows => throw new NotImplementedException();

   class MyRowCollection : IBlueRowCollection<T> {
      readonly TableUpdate<T, int> table;
      readonly IEnumerable<T> items;
      Lazy<SortedList<int, T>> itemList;

      public MyRowCollection(IEnumerable<T> items, IBlueTableSchema schema) {
         this.items = items;
         this.schema = schema;
         itemList = new(() => {
            var rv = new SortedList<int, T>();
            foreach (var item in this.items) {
               rv.Add(item.Id(), item);
            }
            return rv;
         });
      }

      public int Count => itemList.Value.Count;
      public bool IsSynchronized => false;
      public object SyncRoot => this;

      public T this[int id] => itemList.Value[id];

      public IBlueTableSchema schema { get; }

      public bool containsID(int id) =>
         itemList.Value.ContainsKey(id);

      public void CopyTo(Array array, int index) {
      }

      public IEnumerator<T> GetEnumerator() {
         throw new NotImplementedException();
      }

      IEnumerator IEnumerable.GetEnumerator() {
         throw new NotImplementedException();
      }
   }
}