using Invercargill.DataStructures;
using Invercargill.Modifiers;
using Invercargill.Mapping;

namespace Invercargill {

    public abstract class Enumerable<T> : Object {

        public abstract Tracker<T> get_tracker();
        public abstract int? peek_count();
        public abstract EnumerableInfo get_info();

        // Returns false if iteration was interrupted
        // Returns true if iteration reached natural end
        public virtual bool iterate_if(PredicateDelegate<T> handler) {
            var tracker = get_tracker();
            while(tracker.has_next()) {
                if(!handler(tracker.get_next())) {
                    return false;
                }
            }
            return true;
        }

        public virtual void iterate(ItemDelegate<T>? handler = null) {
            if(handler != null) {
                iterate_if(i => {
                    handler(i);
                    return true;
                });
                return;
            }

            iterate_if(i => true);
        }

        public virtual Series<T> to_series() {
            var series = new Series<T>();
            iterate(i => series.add(i));
            return series;
        }

        public virtual Gee.Collection<T> to_gee_collection() {
            var collection = new Gee.LinkedList<T>();
            iterate(i => collection.add(i));
            return collection;
        }

        public virtual Tracker<T> iterator() {
            return get_tracker();
        }

        public virtual T[] to_array() {
            var array = new T[1024];
            var index = 0;
            foreach (var item in this) {
                if(index >= array.length) {
                    array.resize(array.length*2);
                }
                safely_assign_to_array<T>(array, index, item);
                index++;
            }
            array.resize(index);
            return array;
        }

        public virtual int count(PredicateDelegate<T>? predicate = null) {
            var enumerable = this;
            // When no predicate is passed, see if we can peek at the count of
            // the enumerable before iterating.
            if(predicate == null) {
                var peek = peek_count();
                if(peek != null) {
                    return peek;
                }
            }
            else {
                enumerable = this.where(predicate);
            }

            var count = 0;
            enumerable.iterate(i => count++);
            return count;
        }

        public virtual bool any(PredicateDelegate<T>? predicate = null) {
            var result = false;
            var p = resolve_nullable_predicate(predicate);
            iterate_if(i => {
                if(p(i)) {
                    result = true;
                    return false;
                }
                return true;
            });

            return result;
        }

        public virtual bool all(PredicateDelegate<T> predicate) {
            return !any(i => !predicate(i));
        }

        public virtual bool no(PredicateDelegate<T>? predicate = null) {
            var p = resolve_nullable_predicate(predicate);
            return all(i => !p(i));
        }

        public virtual Enumerable<T> where(owned PredicateDelegate<T> predicate) {
            return new Filter<T>(this, (owned)predicate);
        }

        public virtual Enumerable<T> from(owned PredicateDelegate<T> predicate) {
            return new From<T>(this, (owned)predicate);
        }

        public virtual Enumerable<T> until(owned PredicateDelegate<T> predicate) {
            return new Until<T>(this, (owned)predicate);
        }

        public virtual Enumerable<Tout> select_where<Tout>(owned FilterTransformDelegate<T, Tout> transform) {
            return new FilterTransform<T, Tout>(this, (owned)transform);
        }

        public virtual Enumerable<Tout> select<Tout>(owned TransformDelegate<T, Tout> transform) {
            return new Transform<T, Tout>(this, (owned)transform);
        }

        public virtual Attempts<Tout> attempt_select<Tout>(owned AttemptTransformDelegate<T, Tout> transform) {
            return select<Attempt<Tout>>(i => new Attempt<Tout>(() => transform(i))).assert_promotion<Attempts>();
        }

        public virtual Attempts<Tout> attempt_select_nested<Tout>(owned AttemptTransformDelegate<T, Enumerable<Attempt<Tout>>> transform) {
            return attempt_select<Enumerable<Attempt<Tout>>>((owned)transform)
                .as_enumerable()
                .select_many<Attempt<Tout>>(a => a.success ? a.result : Invercargill.single<Attempt<Tout>>(new Attempt<Tout>.unsuccessful(a.error)))
                .assert_promotion<Attempts>();
        }

        public virtual Enumerable<Pair<TFirst, TSecond>> select_pairs<TFirst, TSecond>(owned TransformDelegate<T, TFirst> transform1, owned TransformDelegate<T, TSecond> transform2) {
            return select<Pair<TFirst, TSecond>>(i => new Pair<TFirst, TSecond>(transform1(i), true, transform2(i), true));
        }

        public virtual Enumerable<Tout> select_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> transform) {
            return new MergeQuery<Tout>(select((owned)transform));
        }

        public virtual Enumerable<T> sort(owned CompareDelegate<T> compare) {
            return new Sort<T>(this, (owned)compare);
        }

        public virtual Enumerable<T> concat(Enumerable<T> other) {
            return new Concat<T>(this, other);
        }

        public virtual Enumerable<T> take(int count) {
            return new Take<T>(this, count);
        }

        public virtual Enumerable<T> skip(int count) {
            return new Skip<T>(this, count);
        }

        public virtual Enumerable<Tout> cast<Tout>() {
            return select<Tout>(i => (Tout)i);
        }

        public virtual Enumerable<Tout> parallel_select<Tout>(owned TransformDelegate<T, Tout> transform, uint workers = 0) {
            var actual_workers = workers;
            if(actual_workers < 1) {
                actual_workers = get_num_processors();
            }
            return new Parallel<T, Tout>(this, (owned)transform, (int)actual_workers);
        }

        public virtual void parallel_iterate(ItemDelegate<T> handler, uint workers = 0) {
            parallel_select<T>(i => {
                handler(i);
                return i;
            }, workers)
            .iterate();
        }

        public virtual Enumerable<SelectionContext<T, Tout>> contextualised_select<Tout>(owned TransformDelegate<T, Tout> transform) {
            return select<SelectionContext<T, Tout>>((i) => new SelectionContext<T, Tout>() {
                origin = i,
                result = transform(i)
            });
        }

        public virtual Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) {
            var aggregate = initial;
            iterate(i => {
                aggregate = aggregate_func(aggregate, i);
            });
            return aggregate;
        }

        public virtual T max(TransformDelegate<T, int> int_delegate) {
            T item = null;
            var first = true;
            var value = 0;
            foreach (var i in this) {
                if(first) {
                    first = false;
                    item = i;
                    value = int_delegate(i);
                    continue;
                }
                var item_value = int_delegate(i);
                if(item_value > value) {
                    value = item_value;
                    item = i;
                }
            }

            return item;
        }

        public virtual T min(TransformDelegate<T, int> int_delegate) {
            T item = null;
            var first = true;
            var value = 0;
            foreach (var i in this) {
                if(first) {
                    first = false;
                    item = i;
                    value = int_delegate(i);
                    continue;
                }
                var item_value = int_delegate(i);
                if(item_value < value) {
                    value = item_value;
                    item = i;
                }
            }

            return item;
        }

        public virtual bool contains(T item, EqualityDelegate<T>? equator = null) {
            var func = equator ?? Operators.equality<T>();
            return any(i => func(i, item));
        }

        public virtual Enumerable<TOut> zip<TOther, TOut>(Enumerable<TOther> other, owned ZipperTransformDelegate<T, TOther, TOut> transform) {
            return new Zip<T, TOther, TOut>(this, other, (owned)transform);
        }

        public virtual Enumerable<Pair<T, Tother>> pair_up<Tother>(Enumerable<Tother> other) {
            return zip<Tother, Pair<T, Tother>>(other, (t1v, t1vs, t2v, t2vs) => new Pair<T, Tother>(t1v, t1vs, t2v, t2vs));
        }

        public virtual Enumerable<T> interleave(Enumerable<T> other) {
            return new Interleave<T>(this, other);
        }

        public virtual Enumerable<Tout> fork<Tout>(owned TransformDelegate<T, Tout> fork1, owned TransformDelegate<T, Tout> fork2) {
            var seq = to_series();
            return seq.select<Tout>((owned)fork1).interleave(seq.select<Tout>((owned)fork2));
        }

        public virtual Enumerable<Tout> fork_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> fork1, owned TransformDelegate<T, Enumerable<Tout>> fork2) {
            return new MergeQuery<Tout>(fork((owned)fork1, (owned)fork2));
        }

        public virtual bool matches(Enumerable<T> other, EqualityDelegate<T> equals) {
            return zip<T, bool>(other, (t1v, t1vs, t2v, t2vs) => t1vs == t2vs && equals(t1v, t2v)).all(r => r);
        }

        public virtual Enumerable<T> act(ItemDelegate<T> handler) {
            return select<T>(i => {
                handler(i);
                return i;
            });
        }

        public virtual Enumerable<T> distinct(owned EqualityDelegate<T>? comparison = null) {
            return distinct_by<T>(i => i, (owned)comparison);
        }

        public virtual Enumerable<T> distinct_by<TProp>(owned TransformDelegate<T, TProp> property_selector, owned EqualityDelegate<TProp>? property_equality) {
            var func = property_equality ?? Operators.equality<T>();
            return new Unique<T, TProp>(this, (owned)property_selector, (owned)func);
        }

        public virtual Enumerable<Grouping<TKey, T>> group_by<TKey>(owned TransformDelegate<T, TKey> key_selector, owned EqualityDelegate<TKey>? key_equality = null) {
            var equality = key_equality ?? Operators.equality<TKey>();
            var keys = select<TKey>(i => key_selector(i)).distinct((a, b) => equality(a, b));
            return keys.select<Grouping<TKey, T>>(g => new Grouping<TKey, T>(g, this.where(i => equality(g, key_selector(i)))));
        }

        public virtual Enumerable<T> @with(T item, uint times = 1) {
            return concat(range(0, (int)times, 1).select<T>(i => item));
        }

        public virtual T first(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
            if(tracker.has_next()) {
                return tracker.get_next();
            }
            throw new SequenceError.NO_ELEMENTS("The sequence contains no elements");
        }

        public virtual T? first_or_default(owned PredicateDelegate<T>? predicate = null) {
            var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
            if(tracker.has_next()) {
                return tracker.get_next();
            }
            return null;
        }

        public virtual T last(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
            if(!tracker.has_next()) {
                throw new SequenceError.NO_ELEMENTS("The sequence contains no elements");
            }
            while(true) {
                T item = tracker.get_next();
                if(!tracker.has_next()) {
                    return item;
                }
            }
        }

        public virtual T? last_or_default(owned PredicateDelegate<T>? predicate = null) {
            var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
            if(!tracker.has_next()) {
                return null;
            }
            while(true) {
                T item = tracker.get_next();
                if(!tracker.has_next()) {
                    return item;
                }
            }
        }

        public virtual T single(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
            if(tracker.has_next()) {
                var item = tracker.get_next();
                if(tracker.has_next()) {
                    throw new SequenceError.MULTUPLE_ELEMENTS("The sequence contains more than one element");
                }
                return item;
            }
            throw new SequenceError.NO_ELEMENTS("The sequence contains no elements");
        }

        public virtual T single_or_default(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
            var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
            if(tracker.has_next()) {
                var item = tracker.get_next();
                if(tracker.has_next()) {
                    throw new SequenceError.MULTUPLE_ELEMENTS("The sequence contains more than one element");
                }
                return item;
            }
            return null;
        }

        public virtual string to_string(TransformDelegate<T, string> stringifier, string seperator = "") {
            bool is_first = true;
            return aggregate<string>("", (s, v) => {
                if(is_first) {
                    is_first = false;
                    return stringifier(v);
                }
                return s + seperator + stringifier(v);
            });
        }

        public virtual Object[] to_object_array() throws SequenceError {
            if(!typeof(T).is_object()) {
                throw new SequenceError.INVALID_TYPE("Can only make an object array of an Enumerable<T> where T is derrived from GLib.Object");
            }
            return select<Object>(i => (Object)i).to_array();
        }

        public virtual Vector<T> to_vector() {
            var vector = new Vector<T>();
            vector.add_all(this);
            return vector;
        }

        public virtual Type element_type { get {
            return typeof(T);
        }}

        public virtual TPromotion promote_to<TPromotion>() throws PromotionError {
            var type = typeof(TPromotion);
            if(get_type().is_a(type)) {
                // Don't promote if we are already target type
                return this;
            }

            resolve_promotion<TPromotion>(ref type);

            if(!type.is_instantiatable()) {
                throw new PromotionError.INVALID_PROMOTION_TYPE(@"Promotion type $(type.name()) is not instansiatable.");
            }
            if(!type.is_a(typeof(Promotion))) {
                throw new PromotionError.INVALID_PROMOTION_TYPE(@"Promotion type $(type.name()) does not implement Invercargill.Promotion.");
            }
            if(!type.is_a(typeof(Enumerable)) && typeof(TPromotion) == type) {
                throw new PromotionError.INVALID_PROMOTION_TYPE(@"Non-resolved promotion type $(type.name()) does not inherit from Invercargill.Enumerable.");
            }

            var promotion = Object.new(type);
            if(!((Promotion)promotion).can_wrap(element_type)) {
                throw new PromotionError.INCOMPATIBLE_ELEMENT_TYPE(@"Enumerable has an element type of $(element_type.name()) which cannot be wrapped by $(type.name())");
            }

            return ((Promotion)promotion).wrap(this);
        }

        public virtual TPromotion assert_promotion<TPromotion>() {
            try {
                return promote_to<TPromotion>();
            }
            catch (PromotionError error) {
                var base_type = get_type();
                var type = typeof(TPromotion);
                critical(@"Cannot promote type $(base_type.name()) to $(type.name()): $(error.message)");
                assert_not_reached();
            }
        }

        public virtual Enumerable<T> seal() {
            if(this.get_type().is_a(typeof(Sealed))) {
                return this;
            }
            return new Sealed<T>(this);
        }

        public virtual Enumerable<T> cache() {
            if(this.get_type().is_a(typeof(Cache))) {
                return this;
            }
            return new Cache<T>(this);
        }

        public virtual Dictionary<TKey, T> to_dictionary<TKey>(TransformDelegate<T, TKey> key_selecter, HashDelegate<TKey>? key_hash_func = null, EqualityDelegate<TKey>? key_equal_func = null) {
            var dict = new Dictionary<TKey, T>(key_hash_func, key_equal_func);       
            iterate(i => dict.add(key_selecter(i), i));
            return dict;
        }

        public virtual 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) {
            var dict = new Dictionary<TKey, T>(key_hash_func, key_equal_func);       
            iterate(i => dict.add(key_selecter(i), value_selecter(i)));
            return dict;
        }

        public virtual HashSet<T> to_hash_set(HashDelegate<T>? hash_func = null, EqualityDelegate<T>? equal_func = null) {
            var @set = new HashSet<T>(hash_func, equal_func);       
            @set.union_with(this);
            return @set;
        }

        public virtual Enumerable<PositionItemPair<T>> with_positions() {
            return new Position<T>(this);
        }

        public virtual Elements to_elements() {
            var series = new ElementSeries();
            if(typeof(T).is_a(typeof(Element))) {
                series.add_all((Enumerable<Element>)this);
            }
            else {
                series.add_all(select<Element>(i => new NativeElement<T>(i)));
            }
            return series;
        }

        public virtual Attempts<Tout> attempt_map_with<Tout>(Mapper<Tout, T> mapper) {
            return attempt_select<Tout>(o => mapper.materialise(o));
        }

        public virtual Enumerable<T> as_enumerable() {
            return this;
        }

        public virtual void debug_dump(TransformDelegate<T, string> stringifier, string additional_message = "", DebugOutputDelegate? output_func = null, bool formatting = true) {
            DebugPrinter.print_enumerable_dump<T>(this, stringifier, additional_message, output_func, formatting);
        }

        public virtual Enumerable<T> debug_type(string additional_message = "", DebugOutputDelegate? output_func = null, bool formatting = true) {
            DebugPrinter.print_enumerable_information(get_info(), additional_message, output_func, formatting);
            return this;
        }

        public virtual Enumerable<T> debug_trace(owned TransformDelegate<T, string> stringifier, string additional_message = "", owned DebugOutputDelegate? output_func = null, bool formatting = true) {
            return new TraceEnumerable<T>(this, get_info(), (owned)stringifier, additional_message, (owned)output_func, formatting);
        }

        private PredicateDelegate<T> resolve_nullable_predicate(PredicateDelegate<T>? predicate) {
            if(predicate == null) {
                return (p) => true;
            }
            return predicate;
        }

    }

}