namespace Invercargill.Wrappers {

    public class Array<T> : Enumerable<T>, Lot<T>, ReadOnlyAddressable<T> {

        private T[] array;

        public Array(T[] input) {
            array = new T[input.length];
            for(uint i = 0; i < array.length; i++) {
                safely_assign_to_array<T>(array, i, safely_read_array<T>(input, i));
            }
        }

        public override Tracker<T> get_tracker() {
            var i = 0;
            return new LambdaTracker<T>(
                () => {
                    return i < array.length;
                },
                () => {
                    var res = safely_read_array<T>(array, i);
                    i++;
                    return res;
                });
        }

        public new T get(uint index) throws IndexError {
            if(index >= array.length) {
                throw new IndexError.INDEX_EXCEEDS_UPPER_BOUNDS(@"Tried to access index $(index) on a wrapped array with $(array.length) item(s)");
            }
            return safely_read_array<T>(array, index);
        }

        public bool try_get(uint index, out T value) {
            if(index >= array.length) {
                value = null;
                return false;
            }
            value = safely_read_array<T>(array, index);
            return true;
        }

        public uint? first_index_of(Invercargill.PredicateDelegate<T> predicate) {
            for(uint i = 0; i < array.length; i++) {
                var item = safely_read_array<T>(array, i);
                if(predicate(item)) {
                    return i;
                }
            }
            return null;
        }

    }

}