namespace Invercargill.Modifiers {

    public class Skip<T> : Enumerable<T> {

        private Enumerable<T> input;
        private int n_items {get; set;}

        public Skip(Enumerable<T> input, int skip) {
            this.input = input;
            n_items = skip;
        }

        public override int? peek_count() {
            var c = input.peek_count();
            if(c == null)
                return null;
            return int.max(0, c - n_items);
        }

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

        public override bool iterate_if (Invercargill.PredicateDelegate<T> handler) {
            var c = 0;
            return input.iterate_if(i => {
                if(c >= n_items) {
                    c++;
                    return handler(i);
                }
                c++;
                return true;
            });
        }

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

            return new AdvanceTracker<T>((out obj) => {
                obj = null;
                while(c < n_items) {
                    if(!tracker.has_next()) {
                        return false;
                    }
                    tracker.get_next ();
                    c++;
                }
                
                if(tracker.has_next()) {
                    obj = tracker.get_next();
                    return true;
                }
                return false;
            });
        }
    }

}