using Invercargill;
namespace InvercargillJson {

    public interface JsonElements : Enumerable<JsonElement>, Elements {

        public virtual Enumerable<JsonArray> as_arrays() {
            return select<JsonArray>(n => new JsonArray.from_existing(n.assert_as<Json.Node>().get_array()));
        }

        public virtual Enumerable<bool> as_bools() {
            return select<bool>(n => n.assert_as<Json.Node>().get_boolean());
        }

        public virtual Doubles as_doubles() {
            return select<double?>(n => n.assert_as<Json.Node>().get_double()).promote_to<Doubles>();
        }

        public virtual Signed64BitIntegers as_integers() {
            return select<int64?>(n => n.assert_as<Json.Node>().get_int()).promote_to<Signed64BitIntegers>();
        }

        public virtual Enumerable<string> as_strings() {
            return select<string>(n => n.assert_as<Json.Node>().get_string());
        }

        public virtual Enumerable<JsonObject> as_objects() {
            return select<JsonObject>(n => new JsonObject.from_existing(n.assert_as<Json.Node>().get_object()));
        }

        public virtual JsonArray to_json_array() {
            var array = new JsonArray();
            array.add_all((Enumerable<JsonElement>)this);
            return array;
        }

    }

    private class JsonElementsPromotionImplementation : Object, Promotion<Element> {
        public bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(JsonElement));
        }
        public Enumerable<Element> wrap(Enumerable<Element> enumerable) {
            return new JsonElementsProxy(enumerable.cast<JsonElement>());
        }
    }

    private class JsonElementsProxy : ProxyEnumerable<JsonElement>, Elements, JsonElements {
        public JsonElementsProxy(Enumerable<JsonElement> elements) {
            inner = elements;
        }
    }

}