/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.modeshape.schematic.internal.document;

import java.text.ParseException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import org.modeshape.schematic.document.Array;
import org.modeshape.schematic.document.Binary;
import org.modeshape.schematic.document.Code;
import org.modeshape.schematic.document.CodeWithScope;
import org.modeshape.schematic.document.Document;
import org.modeshape.schematic.document.EditableArray;
import org.modeshape.schematic.document.EditableDocument;
import org.modeshape.schematic.document.MaxKey;
import org.modeshape.schematic.document.MinKey;
import org.modeshape.schematic.document.ObjectId;
import org.modeshape.schematic.document.Symbol;

public class ArrayEditor implements EditableArray {

    private static final long serialVersionUID = 1L;

    private final MutableArray array;
    private final DocumentValueFactory factory;

    public ArrayEditor( MutableArray array,
                        DocumentValueFactory factory ) {
        assert array != null;
        this.array = array;
        this.factory = factory != null ? factory : DefaultDocumentValueFactory.INSTANCE;
    }

    @Override
    public ArrayEditor clone() {
        return new ArrayEditor(this.array.clone(), factory);
    }

    @Override
    public ArrayEditor with( Map<String, Object> changedFields ) {
        return new ArrayEditor((MutableArray)this.array.with(changedFields), factory);
    }

    @Override
    public Document with( String fieldName,
                          Object value ) {
        return new ArrayEditor((MutableArray)this.array.with(fieldName, value), factory);
    }

    @Override
    public ArrayEditor with( ValueTransformer transformer ) {
        return new ArrayEditor((MutableArray)this.array.with(transformer), factory);
    }

    @Override
    public Document withVariablesReplaced( Properties properties ) {
        return new ArrayEditor((MutableArray)this.array.withVariablesReplaced(properties), factory);
    }

    @Override
    public Document withVariablesReplacedWithSystemProperties() {
        return new ArrayEditor((MutableArray)this.array.withVariablesReplacedWithSystemProperties(), factory);
    }

    @Override
    public Array unwrap() {
        return array;
    }

    @Override
    public MutableDocument asMutableDocument() {
        return array;
    }

    @Override
    public Object get( String name ) {
        return array.get(name);
    }

    @Override
    public Boolean getBoolean( String name ) {
        return array.getBoolean(name);
    }

    @Override
    public boolean getBoolean( String name,
                               boolean defaultValue ) {
        return array.getBoolean(name, defaultValue);
    }

    public Object put( String name,
                       Object value ) {
        return array.put(name, value);
    }

    @Override
    public void putAll( Document object ) {
        array.putAll(object);
    }

    @Override
    public void putAll( Map<? extends String, ? extends Object> map ) {
        array.putAll(map);
    }

    @Override
    public void merge( Document other ) {
        array.putAll(other);
    }

    @Override
    public Object remove( String name ) {
        return array.remove(name);
    }

    @Override
    public Integer getInteger( String name ) {
        return array.getInteger(name);
    }

    @Override
    public int getInteger( String name,
                           int defaultValue ) {
        return array.getInteger(name, defaultValue);
    }

    @Override
    public Long getLong( String name ) {
        return array.getLong(name);
    }

    @Override
    public long getLong( String name,
                         long defaultValue ) {
        return array.getLong(name, defaultValue);
    }

    @Override
    public Double getDouble( String name ) {
        return array.getDouble(name);
    }

    @Override
    public double getDouble( String name,
                             double defaultValue ) {
        return array.getDouble(name, defaultValue);
    }

    @Override
    public Number getNumber( String name ) {
        return array.getNumber(name);
    }

    @Override
    public Number getNumber( String name,
                             Number defaultValue ) {
        return array.getNumber(name, defaultValue);
    }

    @Override
    public String getString( String name ) {
        return array.getString(name);
    }

    @Override
    public String getString( String name,
                             String defaultValue ) {
        return array.getString(name, defaultValue);
    }

    @Override
    public EditableArray getArray( String name ) {
        return editable(array.getArray(name), indexFrom(name));
    }

    @Override
    public EditableArray getOrCreateArray( String name ) {
        List<?> existing = array.getArray(name);
        return existing != null ? editable(existing, indexFrom(name)) : setArray(name);
    }

    @Override
    public EditableDocument getDocument( String name ) {
        return editable(array.getDocument(name), indexFrom(name));
    }

    @Override
    public EditableDocument getOrCreateDocument( String name ) {
        Document existing = array.getDocument(name);
        return existing != null ? editable(existing, indexFrom(name)) : setDocument(name);
    }

    @Override
    public boolean isNull( String name ) {
        return array.isNull(name);
    }

    @Override
    public boolean isNullOrMissing( String name ) {
        return array.isNullOrMissing(name);
    }

    @Override
    public MaxKey getMaxKey( String name ) {
        return array.getMaxKey(name);
    }

    @Override
    public MinKey getMinKey( String name ) {
        return array.getMinKey(name);
    }

    @Override
    public Code getCode( String name ) {
        return array.getCode(name);
    }

    @Override
    public CodeWithScope getCodeWithScope( String name ) {
        return array.getCodeWithScope(name);
    }

    @Override
    public ObjectId getObjectId( String name ) {
        return array.getObjectId(name);
    }

    @Override
    public Binary getBinary( String name ) {
        return array.getBinary(name);
    }
    
    @Override
    public Date getDate(String name) {
        return array.getDate(name);
    }
    
    @Override
    public Symbol getSymbol( String name ) {
        return array.getSymbol(name);
    }

    @Override
    public Pattern getPattern( String name ) {
        return array.getPattern(name);
    }

    @Override
    public UUID getUuid( String name ) {
        return array.getUuid(name);
    }

    @Override
    public UUID getUuid( String name,
                         UUID defaultValue ) {
        return array.getUuid(name, defaultValue);
    }

    @Override
    public int getType( String name ) {
        return array.getType(name);
    }

    @Override
    public Map<String, ?> toMap() {
        return array.toMap();
    }

    @Override
    public Iterable<Field> fields() {
        return array.fields();
    }

    @Override
    public boolean containsField( String name ) {
        return array.containsField(name);
    }

    @Override
    public boolean containsAll( Document document ) {
        return array.containsAll(document);
    }

    @Override
    public Set<String> keySet() {
        return array.keySet();
    }

    @Override
    public int size() {
        return array.size();
    }

    @Override
    public void removeAll() {
        array.removeAll();
    }

    @Override
    public EditableArray setBoolean( String name,
                                     boolean value ) {
        return setValue(name, factory.createBoolean(value));
    }

    @Override
    public EditableArray setNumber( String name,
                                    int value ) {
        return setValue(name, factory.createInt(value));
    }

    @Override
    public EditableArray setNumber( String name,
                                    long value ) {
        return setValue(name, factory.createLong(value));
    }

    @Override
    public EditableArray setNumber( String name,
                                    float value ) {
        return setValue(name, factory.createDouble(value));
    }

    @Override
    public EditableArray setNumber( String name,
                                    double value ) {
        return setValue(name, factory.createDouble(value));
    }

    @Override
    public EditableArray setString( String name,
                                    String value ) {
        return setValue(name, factory.createString(value));
    }

    @Override
    public EditableArray setSymbol( String name,
                                    String value ) {
        return setValue(name, factory.createSymbol(value));
    }

    @Override
    public EditableDocument setDocument( String name ) {
        BasicDocument doc = new BasicDocument();
        setValue(name, doc);
        return editable(doc, indexFrom(name));
    }

    @Override
    public EditableDocument setDocument( String name,
                                         Document document ) {
        setValue(name, document);
        return editable(document, indexFrom(name));
    }

    @Override
    public EditableArray setArray( String name ) {
        List<?> array = new BasicArray();
        setValue(name, array);
        return editable(array, indexFrom(name));
    }

    @Override
    public EditableArray setArray( String name,
                                   Array array ) {
        setValue(name, array);
        return editable((List<?>)array, indexFrom(name));
    }

    @Override
    public EditableArray setArray( String name,
                                   Object... values ) {
        setValue(name, Arrays.asList(values));
        return editable((List<?>)array, indexFrom(name));
    }

    @Override
    public EditableArray setDate( String name,
                                  Date value ) {
        return setValue(name, value);
    }

    @Override
    public EditableArray setDate( String name,
                                  String isoDate ) throws ParseException {
        return setValue(name, factory.createDate(isoDate));
    }

    @Override
    public EditableArray setTimestamp( String name,
                                       int timeInSeconds,
                                       int increment ) {
        return setValue(name, factory.createTimestamp(timeInSeconds, increment));
    }

    @Override
    public EditableArray setObjectId( String name,
                                      String hex ) {
        return setValue(name, factory.createObjectId(hex));
    }

    @Override
    public EditableArray setObjectId( String name,
                                      byte[] bytes ) {
        return setValue(name, factory.createObjectId(bytes));
    }

    @Override
    public EditableArray setObjectId( String name,
                                      int time,
                                      int machine,
                                      int process,
                                      int inc ) {
        return setValue(name, factory.createObjectId(time, machine, process, inc));
    }

    @Override
    public EditableArray setRegularExpression( String name,
                                               String pattern ) {
        return setValue(name, factory.createRegex(pattern, null));
    }

    @Override
    public EditableArray setRegularExpression( String name,
                                               String pattern,
                                               int flags ) {
        return setValue(name, factory.createRegex(pattern, BsonUtils.regexFlagsFor(flags)));
    }

    @Override
    public EditableArray setNull( String name ) {
        return setValue(name, factory.createNull());
    }

    @Override
    public EditableArray setBinary( String name,
                                    byte type,
                                    byte[] data ) {
        return setValue(name, factory.createBinary(type, data));
    }

    @Override
    public EditableArray setUuid( String name,
                                  UUID uuid ) {
        return setValue(name, uuid);
    }

    @Override
    public EditableDocument setCode( String name,
                                     String code,
                                     boolean includeScope ) {
        if (includeScope) {
            BasicDocument scope = new BasicDocument();
            setValue(name, factory.createCode(code, scope));
            return editable(scope, indexFrom(name));
        }
        return setValue(name, factory.createCode(code));
    }

    @Override
    public EditableDocument setCode( String name,
                                     String code,
                                     Document scope ) {
        if (scope != null) {
            setValue(name, factory.createCode(code, scope));
            return editable(scope, indexFrom(name));
        }
        return setValue(name, factory.createCode(code));
    }

    protected EditableArray setValue( String name,
                                      Object value ) {
        doSetValue(name, value);
        return this;
    }

    @Override
    public EditableArray setValue( int index,
                                   Object value ) {
        doSetValue(index, value);
        return this;
    }

    @Override
    public EditableArray addValue( Object value ) {
        doAddValue(value);
        return this;
    }

    @Override
    public EditableArray addValueIfAbsent( Object value ) {
        doAddValueIfAbsent(value);
        return this;
    }

    @Override
    public EditableArray addValue( int index,
                                   Object value ) {
        doAddValue(index, value);
        return this;
    }

    protected final int indexFrom( String name ) {
        return Integer.parseInt(name);
    }

    protected Object doSetValue( String name,
                                 Object value ) {
        int index = indexFrom(name);
        return doSetValue(index, value);
    }

    protected Object doSetValue( int index,
                                 Object value ) {
        value = Utility.unwrap(value);
        return array.setValue(index, value);
    }

    protected int doAddValue( Object value ) {
        value = Utility.unwrap(value);
        return array.addValue(value);
    }

    protected void doAddValue( int index,
                               Object value ) {
        value = Utility.unwrap(value);
        array.addValue(index, value);
    }

    protected boolean doAddValueIfAbsent( Object value ) {
        value = Utility.unwrap(value);
        return array.addValueIfAbsent(value);
    }

    protected boolean doRemoveValue( Object value ) {
        value = Utility.unwrap(value);
        return array.removeValue(value);
    }

    protected Object doRemoveValue( int index ) {
        return array.removeValue(index);
    }

    protected boolean doAddAll( Collection<? extends Object> c ) {
        if (c == null || c.isEmpty()) return false;
        for (Object value : c) {
            doAddValue(value);
        }
        return true;
    }

    protected boolean doAddAll( int index,
                                Collection<?> c ) {
        if (c == null || c.isEmpty()) return false;
        for (Object value : c) {
            doAddValue(value);
        }
        return true;
    }

    protected List<Entry> doRemoveAll( Collection<?> c ) {
        return array.removeAllValues(Utility.unwrapValues(c));
    }

    protected List<Entry> doRetainAll( Collection<?> c ) {
        return array.retainAllValues(Utility.unwrapValues(c));
    }

    protected void doClear() {
        array.removeAll();
    }

    protected EditableDocument editable( Document doc,
                                         int index ) {
        if (doc == null) return null;
        assert !(doc instanceof DocumentEditor) : "The document value should not be a DocumentEditor instance";
        if (doc instanceof MutableArray) {
            return createEditableArray((MutableArray)doc, index, factory);
        }
        assert doc instanceof MutableDocument;
        return createEditableDocument((MutableDocument)doc, index, factory);
    }

    protected EditableArray editable( List<?> array,
                                      int index ) {
        if (array == null) return null;
        assert !(array instanceof ArrayEditor) : "The array value should not be an ArrayEditor instance";
        return createEditableArray((BasicArray)array, index, factory);
    }

    private EditableArray editableSublist( List<?> sublist ) {
        assert sublist != null;
        if (sublist instanceof EditableArray) return (EditableArray)array;
        return createEditableSublist((BasicArray)sublist, factory);
    }

    protected EditableDocument createEditableDocument( MutableDocument document,
                                                       int index,
                                                       DocumentValueFactory factory ) {
        return new DocumentEditor(document, factory);
    }

    protected EditableArray createEditableArray( MutableArray array,
                                                 int index,
                                                 DocumentValueFactory factory ) {
        return new ArrayEditor(array, factory);
    }

    protected EditableArray createEditableSublist( MutableArray array,
                                                   DocumentValueFactory factory ) {
        return new ArrayEditor(array, factory);
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public boolean contains( Object o ) {
        return array.contains(o);
    }

    @Override
    public Iterator<Object> iterator() {
        return array.iterator();
    }

    @Override
    public Object[] toArray() {
        return array.toArray();
    }

    @Override
    public <T> T[] toArray( T[] a ) {
        return array.toArray(a);
    }

    @Override
    public boolean add( Object e ) {
        return doAddValue(e) != -1;
    }

    @Override
    public boolean remove( Object o ) {
        return doRemoveValue(o);
    }

    @Override
    public boolean containsAll( Collection<?> c ) {
        return array.containsAll(c);
    }

    @Override
    public boolean addAll( Collection<?> c ) {
        return doAddAll(c);
    }

    @Override
    public boolean addAll( int index,
                           Collection<?> c ) {
        return doAddAll(index, c);
    }

    @Override
    public boolean removeAll( Collection<?> c ) {
        List<Entry> removed = doRemoveAll(c);
        return !removed.isEmpty();
    }

    @Override
    public boolean retainAll( Collection<?> c ) {
        List<Entry> removed = doRetainAll(c);
        return !removed.isEmpty();
    }

    @Override
    public void clear() {
        doClear();
    }

    @Override
    public Object get( int index ) {
        Object value = array.get(index);
        if (value instanceof Document) {
            value = editable((Document)value, index);
        } else if (value instanceof List) {
            value = editable((List<?>)value, index);
        }
        return value;
    }

    @Override
    public Object set( int index,
                       Object element ) {
        return doSetValue(index, element);
    }

    @Override
    public void add( int index,
                     Object element ) {
        doAddValue(index, element);
    }

    @Override
    public Object remove( int index ) {
        return doRemoveValue(index);
    }

    @Override
    public int indexOf( Object o ) {
        return indexOf(o);
    }

    @Override
    public int lastIndexOf( Object o ) {
        return array.lastIndexOf(o);
    }

    @Override
    public Iterable<Entry> getEntries() {
        return array.getEntries();
    }

    @Override
    public ListIterator<Object> listIterator() {
        return array.listIterator();
    }

    @Override
    public ListIterator<Object> listIterator( int index ) {
        return array.listIterator(index);
    }

    @Override
    public List<Object> subList( int fromIndex,
                                 int toIndex ) {
        return editableSublist(array.subList(fromIndex, toIndex));
    }

    @Override
    public EditableArray set( String name,
                              Object value ) {
        return setValue(name, value);
    }

    @Override
    public EditableArray setBoolean( int index,
                                     boolean value ) {
        return setValue(index, factory.createBoolean(value));
    }

    @Override
    public EditableArray setNumber( int index,
                                    int value ) {
        return setValue(index, factory.createInt(value));
    }

    @Override
    public EditableArray setNumber( int index,
                                    long value ) {
        return setValue(index, factory.createLong(value));
    }

    @Override
    public EditableArray setNumber( int index,
                                    float value ) {
        return setValue(index, factory.createDouble(value));
    }

    @Override
    public EditableArray setNumber( int index,
                                    double value ) {
        return setValue(index, factory.createDouble(value));
    }

    @Override
    public EditableArray setString( int index,
                                    String value ) {
        return setValue(index, factory.createString(value));
    }

    @Override
    public EditableArray setSymbol( int index,
                                    String value ) {
        return setValue(index, factory.createSymbol(value));
    }

    @Override
    public EditableDocument setDocument( int index ) {
        BasicDocument doc = new BasicDocument();
        setValue(index, doc);
        return editable(doc, index);
    }

    @Override
    public EditableDocument setDocument( int index,
                                         Document document ) {
        if (document instanceof DocumentEditor) document = ((DocumentEditor)document).unwrap();
        setValue(index, document);
        return editable(document, index);
    }

    @Override
    public EditableArray setArray( int index ) {
        List<?> array = new BasicArray();
        setValue(index, array);
        return editable(array, index);
    }

    @Override
    public EditableArray setArray( int index,
                                   Array array ) {
        setValue(index, array);
        return editable((List<?>)array, index);
    }

    @Override
    public EditableArray setDate( int index,
                                  Date value ) {
        setValue(index, value);
        return this;
    }

    @Override
    public EditableArray setDate( int index,
                                  String isoDate ) throws ParseException {
        setValue(index, factory.createDate(isoDate));
        return this;
    }

    @Override
    public EditableArray setTimestamp( int index,
                                       int timeInSeconds,
                                       int increment ) {
        return setValue(index, factory.createTimestamp(timeInSeconds, increment));
    }

    @Override
    public EditableArray setObjectId( int index,
                                      String hex ) {
        return setValue(index, factory.createObjectId(hex));
    }

    @Override
    public EditableArray setObjectId( int index,
                                      byte[] bytes ) {
        return setValue(index, factory.createObjectId(bytes));
    }

    @Override
    public EditableArray setObjectId( int index,
                                      int time,
                                      int machine,
                                      int process,
                                      int inc ) {
        return setValue(index, factory.createObjectId(time, machine, process, inc));
    }

    @Override
    public EditableArray setRegularExpression( int index,
                                               String pattern ) {
        return setValue(index, factory.createRegex(pattern, null));
    }

    @Override
    public EditableArray setRegularExpression( int index,
                                               String pattern,
                                               int flags ) {
        return setValue(index, factory.createRegex(pattern, flags));
    }

    @Override
    public EditableArray setNull( int index ) {
        return setValue(index, factory.createNull());
    }

    @Override
    public EditableArray setBinary( int index,
                                    byte type,
                                    byte[] data ) {
        return setValue(index, factory.createBinary(type, data));
    }

    @Override
    public EditableArray setUuid( int index,
                                  UUID uuid ) {
        return setValue(index, uuid);
    }

    @Override
    public EditableDocument setCode( int index,
                                     String code,
                                     boolean includeScope ) {
        if (includeScope) {
            BasicDocument scope = new BasicDocument();
            setValue(index, factory.createCode(code, scope));
            return editable(scope, index);
        }
        return setValue(index, factory.createCode(code));
    }

    @Override
    public EditableDocument setCode( int index,
                                     String code,
                                     Document scope ) {
        if (scope != null) {
            setValue(index, factory.createCode(code, scope));
            return editable(scope, index);
        }
        return setValue(index, factory.createCode(code));
    }

    @Override
    public EditableArray addBoolean( int index,
                                     boolean value ) {
        return addValue(index, factory.createBoolean(value));
    }

    @Override
    public EditableArray addNumber( int index,
                                    int value ) {
        return addValue(index, factory.createInt(value));
    }

    @Override
    public EditableArray addNumber( int index,
                                    long value ) {
        return addValue(index, factory.createLong(value));
    }

    @Override
    public EditableArray addNumber( int index,
                                    float value ) {
        return addValue(index, factory.createDouble(value));
    }

    @Override
    public EditableArray addNumber( int index,
                                    double value ) {
        return addValue(index, factory.createDouble(value));
    }

    @Override
    public EditableArray addString( int index,
                                    String value ) {
        return addValue(index, factory.createString(value));
    }

    @Override
    public EditableArray addSymbol( int index,
                                    String value ) {
        return addValue(index, factory.createSymbol(value));
    }

    @Override
    public EditableDocument addDocument( int index ) {
        BasicDocument doc = new BasicDocument();
        addValue(index, doc);
        return editable(doc, index);
    }

    @Override
    public EditableDocument addDocument( int index,
                                         Document document ) {
        if (document instanceof DocumentEditor) document = ((DocumentEditor)document).unwrap();
        addValue(index, document);
        return editable(document, index);
    }

    @Override
    public EditableArray addArray( int index ) {
        List<?> array = new BasicArray();
        addValue(index, array);
        return editable(array, index);
    }

    @Override
    public EditableArray addArray( int index,
                                   Array array ) {
        addValue(index, array);
        return editable((List<?>)array, index);
    }

    @Override
    public EditableArray addDate( int index,
                                  Date value ) {
        addValue(index, value);
        return this;
    }

    @Override
    public EditableArray addDate( int index,
                                  String isoDate ) throws ParseException {
        addValue(index, factory.createDate(isoDate));
        return this;
    }

    @Override
    public EditableArray addTimestamp( int index,
                                       int timeInSeconds,
                                       int increment ) {
        return addValue(index, factory.createTimestamp(timeInSeconds, increment));
    }

    @Override
    public EditableArray addObjectId( int index,
                                      String hex ) {
        return addValue(index, factory.createObjectId(hex));
    }

    @Override
    public EditableArray addObjectId( int index,
                                      byte[] bytes ) {
        return addValue(index, factory.createObjectId(bytes));
    }

    @Override
    public EditableArray addObjectId( int index,
                                      int time,
                                      int machine,
                                      int process,
                                      int inc ) {
        return addValue(index, factory.createObjectId(time, machine, process, inc));
    }

    @Override
    public EditableArray addRegularExpression( int index,
                                               String pattern ) {
        return addValue(index, factory.createRegex(pattern, null));
    }

    @Override
    public EditableArray addRegularExpression( int index,
                                               String pattern,
                                               int flags ) {
        return addValue(index, factory.createRegex(pattern, flags));
    }

    @Override
    public EditableArray addNull( int index ) {
        return addValue(index, factory.createNull());
    }

    @Override
    public EditableArray addBinary( int index,
                                    byte type,
                                    byte[] data ) {
        return addValue(index, factory.createBinary(type, data));
    }

    @Override
    public EditableArray addUuid( int index,
                                  UUID uuid ) {
        return addValue(index, uuid);
    }

    @Override
    public EditableDocument addCode( int index,
                                     String code,
                                     boolean includeScope ) {
        if (includeScope) {
            BasicDocument scope = new BasicDocument();
            addValue(index, factory.createCode(code, scope));
            return editable(scope, index);
        }
        return addValue(index, factory.createCode(code));
    }

    @Override
    public EditableDocument addCode( int index,
                                     String code,
                                     Document scope ) {
        if (scope != null) {
            addValue(index, factory.createCode(code, scope));
            return editable(scope, index);
        }
        return addValue(index, factory.createCode(code));
    }

    @Override
    public EditableArray addBoolean( boolean value ) {
        return addValue(factory.createBoolean(value));
    }

    @Override
    public EditableArray addNumber( int value ) {
        return addValue(factory.createInt(value));
    }

    @Override
    public EditableArray addNumber( long value ) {
        return addValue(factory.createLong(value));
    }

    @Override
    public EditableArray addNumber( float value ) {
        return addValue(factory.createDouble(value));
    }

    @Override
    public EditableArray addNumber( double value ) {
        return addValue(factory.createDouble(value));
    }

    @Override
    public EditableArray addString( String value ) {
        return addValue(factory.createString(value));
    }

    @Override
    public EditableArray addSymbol( String value ) {
        return addValue(factory.createSymbol(value));
    }

    @Override
    public EditableDocument addDocument() {
        BasicDocument doc = new BasicDocument();
        addValue(doc);
        return editable(doc, size());
    }

    @Override
    public EditableDocument addDocument( Document document ) {
        if (document instanceof DocumentEditor) document = ((DocumentEditor)document).unwrap();
        addValue(document);
        return editable(document, size());
    }

    @Override
    public EditableArray addArray() {
        List<?> array = new BasicArray();
        addValue(array);
        return editable(array, size());
    }

    @Override
    public EditableArray addArray( Array array ) {
        addValue(array);
        return editable((List<?>)array, size());
    }

    @Override
    public EditableArray addDate( Date value ) {
        return addValue(value);
    }

    @Override
    public EditableArray addDate( String isoDate ) throws ParseException {
        return addValue(factory.createDate(isoDate));
    }

    @Override
    public EditableArray addTimestamp( int timeInSeconds,
                                       int increment ) {
        return addValue(factory.createTimestamp(timeInSeconds, increment));
    }

    @Override
    public EditableArray addObjectId( String hex ) {
        return addValue(factory.createObjectId(hex));
    }

    @Override
    public EditableArray addObjectId( byte[] bytes ) {
        return addValue(factory.createObjectId(bytes));
    }

    @Override
    public EditableArray addObjectId( int time,
                                      int machine,
                                      int process,
                                      int inc ) {
        return addValue(factory.createObjectId(time, machine, process, inc));
    }

    @Override
    public EditableArray addRegularExpression( String pattern ) {
        return addValue(factory.createRegex(pattern, null));
    }

    @Override
    public EditableArray addRegularExpression( String pattern,
                                               int flags ) {
        return addValue(factory.createRegex(pattern, flags));
    }

    @Override
    public EditableArray addNull() {
        return addValue(factory.createNull());
    }

    @Override
    public EditableArray addBinary( byte type,
                                    byte[] data ) {
        return addValue(factory.createBinary(type, data));
    }

    @Override
    public EditableArray addUuid( UUID uuid ) {
        return addValue(uuid);
    }

    @Override
    public EditableDocument addCode( String code,
                                     boolean includeScope ) {
        if (includeScope) {
            BasicDocument scope = new BasicDocument();
            addValue(factory.createCode(code, scope));
            return editable(scope, size());
        }
        return addValue(factory.createCode(code));
    }

    @Override
    public EditableDocument addCode( String code,
                                     Document scope ) {
        if (scope != null) {
            addValue(factory.createCode(code, scope));
            return editable(scope, size());
        }
        return addValue(factory.createCode(code));
    }

    @Override
    public EditableArray addBooleanIfAbsent( boolean value ) {
        return addValueIfAbsent(factory.createBoolean(value));
    }

    @Override
    public EditableArray addNumberIfAbsent( int value ) {
        return addValueIfAbsent(factory.createInt(value));
    }

    @Override
    public EditableArray addNumberIfAbsent( long value ) {
        return addValueIfAbsent(factory.createLong(value));
    }

    @Override
    public EditableArray addNumberIfAbsent( float value ) {
        return addValueIfAbsent(factory.createDouble(value));
    }

    @Override
    public EditableArray addNumberIfAbsent( double value ) {
        return addValueIfAbsent(factory.createDouble(value));
    }

    @Override
    public EditableArray addStringIfAbsent( String value ) {
        return addValueIfAbsent(factory.createString(value));
    }

    @Override
    public EditableArray addSymbolIfAbsent( String value ) {
        return addValueIfAbsent(factory.createSymbol(value));
    }

    @Override
    public EditableDocument addDocumentIfAbsent( Document document ) {
        if (document instanceof DocumentEditor) document = ((DocumentEditor)document).unwrap();
        return doAddValueIfAbsent(document) ? editable(document, size()) : null;
    }

    @Override
    public EditableArray addArrayIfAbsent( Array array ) {
        return doAddValueIfAbsent(array) ? editable((List<?>)array, size()) : null;
    }

    @Override
    public EditableArray addDateIfAbsent( Date value ) {
        return addValueIfAbsent(value);
    }

    @Override
    public EditableArray addDateIfAbsent( String isoDate ) throws ParseException {
        return addValueIfAbsent(factory.createDate(isoDate));
    }

    @Override
    public EditableArray addTimestampIfAbsent( int timeInSeconds,
                                               int increment ) {
        return addValueIfAbsent(factory.createTimestamp(timeInSeconds, increment));
    }

    @Override
    public EditableArray addObjectIdIfAbsent( String hex ) {
        return addValueIfAbsent(factory.createObjectId(hex));
    }

    @Override
    public EditableArray addObjectIdIfAbsent( byte[] bytes ) {
        return addValueIfAbsent(factory.createObjectId(bytes));
    }

    @Override
    public EditableArray addObjectIdIfAbsent( int time,
                                              int machine,
                                              int process,
                                              int inc ) {
        return addValueIfAbsent(factory.createObjectId(time, machine, process, inc));
    }

    @Override
    public EditableArray addRegularExpressionIfAbsent( String pattern ) {
        return addValueIfAbsent(factory.createRegex(pattern, null));
    }

    @Override
    public EditableArray addRegularExpressionIfAbsent( String pattern,
                                                       int flags ) {
        return addValueIfAbsent(factory.createRegex(pattern, flags));
    }

    @Override
    public EditableArray addNullIfAbsent() {
        return addValueIfAbsent(factory.createNull());
    }

    @Override
    public EditableArray addBinaryIfAbsent( byte type,
                                            byte[] data ) {
        return addValueIfAbsent(factory.createBinary(type, data));
    }

    @Override
    public EditableArray addUuidIfAbsent( UUID uuid ) {
        return addValueIfAbsent(uuid);
    }

    @Override
    public EditableDocument addCodeIfAbsent( String code,
                                             Document scope ) {
        if (scope != null) {
            return doAddValueIfAbsent(factory.createCode(code, scope)) ? editable(scope, size()) : null;
        }
        return addValueIfAbsent(factory.createCode(code));
    }

    @Override
    public String toString() {
        return array.toString();
    }

}
