namespace Invercargill.Modifiers {

    public class Chunk<T> : Enumerable<Enumerable<T>> {
        private uint chunk_size;
        private Enumerable<T> input;

        public Chunk(Enumerable<T> input, uint chunk_size) {
            this.input = input;
            this.chunk_size = chunk_size;
        }

        public override uint? peek_count() {
            var inner = input.peek_count();
            if(inner == null) {
                return null;
            }

            return (inner / chunk_size) + (inner % chunk_size == 0 ? 0 : 1);
        }

        public override EnumerableInfo get_info() {
            return new EnumerableInfo.infer_single(this, EnumerableCategory.COMPUTED, input);
        }        

        public override Tracker<Enumerable<T>> get_tracker() {
            var tracker = input.get_tracker();

            return new LambdaTracker<Enumerable<T>>(
                () => tracker.has_next(),
                () => {
                    var items = new DataStructures.Series<T>();
                    for(int i = 0; i < chunk_size && tracker.has_next(); i++) {
                        items.add(tracker.get_next());
                    }
                    return items.seal();
                });
        }
    }

}