namespace Invercargill {

    public class Series<T> : Enumerable<T> {
     
        internal class SeriesItem<T> {
            public SeriesItem next = null;
            public T value;

            public SeriesItem(T value) {
                this.value = value;
            }

            // Carefully unlink series items when destructed.
            // Very large series sometimes cause a segfault without this
            ~SeriesItem() {
                var n = next;
                while(n != null) {
                    var c = n;
                    n = n.next;
                    c.next = null;
                }
            }
        }

        internal SeriesItem<T> root;
        internal SeriesItem<T> end;
        private int n_items = 0;

        public Series() {}

        public override Tracker<T> get_tracker() {
            var current = root;

            return new LambdaTracker<T>(
                () => current != null,
                () => {
                    var val = current.value;
                    current = current.next;
                    return val;
                });
        }

        public override T[] to_array () {
            var arr = new T[n_items];
            var count = 0;
            iterate(i => {
                arr[count] = i;
                count++;
            });
            return arr;
        }

        public void add(T item) {
            lock(root) {
                n_items++;
                var si = new SeriesItem<T>(item);
                if(root == null) {
                    root = si;
                    end = si;
                    return;
                }
                end.next = si;
                end = si;
            }
        }

        public void add_all(Enumerable<T> items) {
            items.iterate(i => add(i));
        }

        public override int count() {
            return n_items;
        }

    }

}