using Invercargill.DataStructures;
namespace Invercargill.Modifiers {

    public class SymmetricDifference<T, TKey> : Enumerable<T> {

        private Enumerable<T> e1;
        private Enumerable<T> e2;
        private TransformDelegate<T, TKey> key_sf;
        private HashDelegate<TKey> key_hf;
        private EqualityDelegate<TKey> key_ef;

        public SymmetricDifference(Enumerable<T> first, Enumerable<T> second, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? key_hasher = null, owned EqualityDelegate<TKey>? key_equator = null) {
            e1 = first;
            e2 = second;
            key_sf = (owned)key_selector;
            key_ef = (owned)key_equator ?? Operators.equality<TKey>();
            key_hf = (owned)key_hasher ?? Operators.hash<TKey>();
        }

        public override int? peek_count() {
            return null;
        }

        public override EnumerableInfo get_info() {
            return new EnumerableInfo.infer(this, EnumerableCategory.COMPUTED, Iterate.these(e1, e2));
        }

        public override Tracker<T> get_tracker() {
            var result = e1.to_hash_set(i => key_hf(key_sf(i)), (a, b) => key_ef(key_sf(a), key_sf(b)));
            result.symmetric_except_with(e2);
            return result.get_tracker();
        }

    }

}