using Invercargill.DataStructures;
using Invercargill.Mapping;

namespace Invercargill {

    public abstract class Proxy<T> : Enumerable<T> {

        protected Enumerable<T> inner { get; set; }

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

        public override int? peek_count() {
            return inner.peek_count();
        }

        public override Tracker<T> get_tracker() {
            return inner.get_tracker();
        }

        public override bool iterate_if(PredicateDelegate<T> handler) {
            return inner.iterate_if(handler);
        }

        public override void iterate(ItemDelegate<T>? handler = null) {
            inner.iterate(handler);
        }

        public override Series<T> to_series() {
            return inner.to_series();
        }
    
        public override Tracker<T> iterator() {
            return inner.iterator();
        }
    
        public override T[] to_array() {
            return inner.to_array();
        }
    
        public override int count(PredicateDelegate<T>? predicate = null) {
            return inner.count(predicate);
        }
    
        public override bool any(PredicateDelegate<T> predicate = (i) => true) {
            return inner.any(predicate);
        }
    
        public override bool all(PredicateDelegate<T> predicate) {
            return inner.all(predicate);
        }
    
        public override bool no(PredicateDelegate<T> predicate = (i) => true) {
            return inner.no(predicate);
        }
    
        public override Enumerable<T> where(owned PredicateDelegate<T> predicate) {
            return inner.where((owned)predicate);
        }
    
        public override Enumerable<TOut> select<TOut>(owned TransformDelegate<T, TOut> transform) {
            return inner.select((owned)transform);
        }
    
        public override Enumerable<TOut> select_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> transform) {
            return inner.select_many((owned)transform);
        }
    
        public override Enumerable<T> sort(owned CompareDelegate<T> compare) {
            return inner.sort((owned)compare);
        }
    
        public override Enumerable<T> concat(Enumerable<T> other) {
            return inner.concat(other);
        }
    
        public override Enumerable<T> take(int count) {
            return inner.take(count);
        }
    
        public override Enumerable<T> skip(int count) {
            return inner.skip(count);
        }
    
        public override Enumerable<TOut> cast<TOut>() {
            return inner.cast<TOut>();
        }
    
        public override Enumerable<TOut> parallel_select<TOut>(owned TransformDelegate<T, TOut> transform, uint workers = 0) {
            return inner.parallel_select((owned)transform, workers);
        }
    
        public override void parallel_iterate(ItemDelegate<T> handler, uint workers = 0) {
            inner.parallel_iterate(handler, workers);
        }
    
        public override Enumerable<SelectionContext<T, TOut>> contextualised_select<TOut>(owned TransformDelegate<T, TOut> transform) {
            return inner.contextualised_select((owned)transform);
        }
    
        public override TOut aggregate<TOut>(TOut initial, AggregateDelegate<TOut, T> aggregate_func) {
            return inner.aggregate(initial, aggregate_func);
        }
    
        public override T max(TransformDelegate<T, int> int_delegate) {
            return inner.max(int_delegate);
        }
    
        public override T min(TransformDelegate<T, int> int_delegate) {
            return inner.min(int_delegate);
        }
    
        public override bool contains(T item, EqualityDelegate<T>? equator = null) {
            return inner.contains(item, equator);
        }
    
        public override Enumerable<Pair<T, TOther>> pair_up<TOther>(Enumerable<TOther> other) {
            return inner.pair_up(other);
        }
    
        public override Enumerable<T> interleave(Enumerable<T> other) {
            return inner.interleave(other);
        }
    
        public override Enumerable<TOut> fork<TOut>(owned TransformDelegate<T, TOut> fork1, owned TransformDelegate<T, TOut> fork2) {
            return inner.fork((owned)fork1, (owned)fork2);
        }
    
        public override Enumerable<TOut> fork_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> fork1, owned TransformDelegate<T, Enumerable<TOut>> fork2) {
            return inner.fork_many((owned)fork1, (owned)fork2);
        }
    
        public override bool matches(Enumerable<T> other, EqualityDelegate<T> equals) {
            return inner.matches(other, equals);
        }
    
        public override Enumerable<T> with(T item, uint times = 1) {
            return inner.with(item, times);
        }
    
        public override T first(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            return inner.first((owned)predicate);
        }
    
        public override T? first_or_default(owned PredicateDelegate<T>? predicate = null) {
            return inner.first_or_default((owned)predicate);
        }
    
        public override T last(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            return inner.last((owned)predicate);
        }
    
        public override T? last_or_default(owned PredicateDelegate<T>? predicate = null) {
            return inner.last_or_default((owned)predicate);
        }
    
        public override T single(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            return inner.single((owned)predicate);
        }
    
        public override T? single_or_default(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            return inner.single_or_default((owned)predicate);
        }
    
        public override string to_string(StringifyDelegate<T>? stringifier = null, string separator = "") {
            return inner.to_string(stringifier, separator);
        }
    
        public override Object[] to_object_array() throws SequenceError {
            return inner.to_object_array();
        }
    
        public override Vector<T> to_vector() {
            return inner.to_vector();
        }
    
        public override Type element_type { 
            get {
                return inner.element_type;
            }
        }
    
        public override TPromotion promote_to<TPromotion>() throws PromotionError {
            return inner.promote_to<TPromotion>();
        }
    
        public override TPromotion assert_promotion<TPromotion>() {
            return inner.assert_promotion<TPromotion>();
        }

        public override Enumerable<T> seal() {
            return inner.seal();
        }

        public override Dictionary<TKey, T> to_dictionary<TKey>(TransformDelegate<T, TKey> key_selecter, HashDelegate<TKey>? key_hash_func = null, EqualityDelegate<TKey>? key_equal_func = null) {
            return inner.to_dictionary<TKey>(key_selecter, key_hash_func, key_equal_func);
        }

        public override Dictionary<TKey, TValue> select_to_dictionary<TKey, TValue>(TransformDelegate<T, TKey> key_selecter, TransformDelegate<T, TValue> value_selecter, HashDelegate<TKey>? key_hash_func = null, EqualityDelegate<TKey>? key_equal_func = null) {
            return inner.select_to_dictionary<TKey, TValue>(key_selecter, value_selecter, key_hash_func, key_equal_func);
        }

        public override Enumerable<Pair<TFirst, TSecond>> select_pairs<TFirst, TSecond>(owned TransformDelegate<T, TFirst> transform1, owned TransformDelegate<T, TSecond> transform2) {
            return inner.select_pairs<TFirst, TSecond>((owned) transform1, (owned) transform2);
        }

        public override Enumerable<PositionItemPair<T>> with_positions() {
            return inner.with_positions();
        }
        public override HashSet<T> to_hash_set(HashDelegate<T>? hash_func = null, EqualityDelegate<T>? equal_func = null) {
            return inner.to_hash_set(hash_func, equal_func);
        }
        public override Elements to_elements() {
            return inner.to_elements();
        }

        public override Enumerable<TOut> select_where<TOut>(owned FilterTransformDelegate<T, TOut> transform) {
            return inner.select_where<TOut>((owned)transform);
        }

        public override Attempts<TOut> attempt_select<TOut>(owned AttemptTransformDelegate<T, TOut> transform) {
            return inner.attempt_select<TOut>((owned)transform);
        }

        public override Attempts<TOut> attempt_select_nested<TOut>(owned AttemptTransformDelegate<T, Enumerable<Attempt<TOut>>> transform) {
            return inner.attempt_select_nested<TOut>((owned)transform);
        }   

        public override Enumerable<T> cache() {
            return inner.cache();
        }

        public override Attempts<TOut> attempt_map_with<TOut>(Mapper<TOut, T> mapper) {
            return inner.attempt_map_with<TOut>(mapper);
        }
        
        public override Enumerable<T> as_enumerable() {
            return inner.as_enumerable();
        }

    }

}