/*

  * #%L

  * AbstractDocument.java - mongodb-async-driver - Allanbank Consulting, Inc.

  * %%

  * Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.

  * %%

  * 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.

  * #L%

  */

 package com.allanbank.mongodb.bson.impl;

 import java.io.StringWriter;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.regex.Pattern;

 import java.util.regex.PatternSyntaxException;

 import com.allanbank.mongodb.bson.Document;

 import com.allanbank.mongodb.bson.Element;

 import com.allanbank.mongodb.bson.Visitor;

 import com.allanbank.mongodb.bson.element.JsonSerializationVisitor;

 import com.allanbank.mongodb.util.PatternUtils;

 /**

  * AbstractDocument provides a base class for all document implementations with

  * the common functionality.

  * 

  * @copyright 2013, Allanbank Consulting, Inc., All Rights Reserved

  */

 public abstract class AbstractDocument implements Document {

     /** The empty list of elements. */

     public static final List<Element> EMPTY_ELEMENTS = Collections.emptyList();

     /** The base type (interface) for all elements. */

     protected static final Class<Element> ELEMENT_TYPE = Element.class;

     /** The serialization id for the class. */

     private static final long serialVersionUID = -425294885378885212L;

     /**

      * Creates a new AbstractDocument.

      */

     public AbstractDocument() {

         super();

     }

     /**

      * Accepts the visitor and calls the {@link Visitor#visitDocument} method.

      * 

      * @see Element#accept(Visitor)

      */

     @Override

     public void accept(final Visitor visitor) {

         visitor.visit(getElements());

     }

     /**

      * {@inheritDoc}

      * <p>

      * Returns this document.

      * </p>

      */

     @Override

     public Document asDocument() {

         return this;

     }

     /**

      * Returns true if the document contains an element with the specified name.

      * 

      * @see Document#contains(String)

      */

     @Override

     public boolean contains(final String name) {

         return getElementMap().containsKey(name);

     }

     /**

      * Determines if the passed object is of this same type as this object and

      * if so that its fields are equal.

      * 

      * @param object

      *            The object to compare to.

      * 

      * @see java.lang.Object#equals(java.lang.Object)

      */

     @Override

     public boolean equals(final Object object) {

         boolean result = false;

         if (this == object) {

             result = true;

         }

         else if ((object != null) && (object instanceof Document)) {

             final Document other = (Document) object;

             result = getElements().equals(other.getElements());

         }

         return result;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Searches this sub-elements for matching elements on the path and are of

      * the right type.

      * </p>

      * 

      * @see Document#find

      */

     @Override

     public <E extends Element> List<E> find(final Class<E> clazz,

             final String... nameRegexs) {

         List<E> elements = Collections.emptyList();

         if (0 < nameRegexs.length) {

             final List<Element> docElements = getElements();

             final String nameRegex = nameRegexs[0];

             final String[] subNameRegexs = Arrays.copyOfRange(nameRegexs, 1,

                     nameRegexs.length);

             elements = new ArrayList<E>();

             try {

                 final Pattern pattern = PatternUtils.toPattern(nameRegex);

                 for (final Element element : docElements) {

                     if (pattern.matcher(element.getName()).matches()) {

                         elements.addAll(element.find(clazz, subNameRegexs));

                     }

                 }

             }

             catch (final PatternSyntaxException pse) {

                 // Assume a non-pattern?

                 for (final Element element : docElements) {

                     if (nameRegex.equals(element.getName())) {

                         elements.addAll(element.find(clazz, subNameRegexs));

                     }

                 }

             }

         }

         // End of the path but we are a document?

         return elements;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Searches this sub-elements for matching elements on the path.

      * </p>

      * 

      * @see Document#find

      */

     @Override

     public List<Element> find(final String... nameRegexs) {

         return find(ELEMENT_TYPE, nameRegexs);

     }

     /**

      * {@inheritDoc}

      * <p>

      * Searches this sub-elements for matching elements on the path and are of

      * the right type.

      * </p>

      * 

      * @see Document#findFirst

      */

     @Override

     public <E extends Element> E findFirst(final Class<E> clazz,

             final String... nameRegexs) {

         E element = null;

         if (0 < nameRegexs.length) {

             final List<Element> docElements = getElements();

             final String nameRegex = nameRegexs[0];

             final String[] subNameRegexs = Arrays.copyOfRange(nameRegexs, 1,

                     nameRegexs.length);

             try {

                 final Pattern pattern = PatternUtils.toPattern(nameRegex);

                 final Iterator<Element> iter = docElements.iterator();

                 while (iter.hasNext() && (element == null)) {

                     final Element docElement = iter.next();

                     if (pattern.matcher(docElement.getName()).matches()) {

                         element = docElement.findFirst(clazz, subNameRegexs);

                     }

                 }

             }

             catch (final PatternSyntaxException pse) {

                 // Assume a non-pattern?

                 final Iterator<Element> iter = docElements.iterator();

                 while (iter.hasNext() && (element == null)) {

                     final Element docElement = iter.next();

                     if (nameRegex.equals(docElement.getName())) {

                         element = docElement.findFirst(clazz, subNameRegexs);

                     }

                 }

             }

         }

         // End of the path but we are a document?

         return element;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Searches this sub-elements for matching elements on the path and are of

      * the right type.

      * </p>

      * 

      * @see Document#findFirst

      */

     @Override

     public Element findFirst(final String... nameRegexs) {

         return findFirst(ELEMENT_TYPE, nameRegexs);

     }

     /**

      * Returns the element with the specified name and type or null if no

      * element with that name and type exists.

      * 

      * @see Document#get(String)

      */

     @Override

     public <E extends Element> E get(final Class<E> clazz, final String name) {

         final Element element = get(name);

         if ((element != null) && clazz.isAssignableFrom(element.getClass())) {

             return clazz.cast(element);

         }

         return null;

     }

     /**

      * Returns the element with the specified name or null if no element with

      * that name exists.

      * 

      * @see Document#get(String)

      */

     @Override

     public Element get(final String name) {

         return getElementMap().get(name);

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public abstract List<Element> getElements();

     /**

      * Computes a reasonable hash code.

      * 

      * @return The hash code value.

      */

     @Override

     public int hashCode() {

         return getElements().hashCode();

     }

     /**

      * Returns an iterator over the documents elements.

      * 

      * @see Iterable#iterator()

      */

     @Override

     public Iterator<Element> iterator() {

         return getElements().iterator();

     }

     /**

      * String form of the object.

      * 

      * @return A human readable form of the object.

      * 

      * @see java.lang.Object#toString()

      */

     @Override

     public String toString() {

         final StringWriter writer = new StringWriter();

         final JsonSerializationVisitor visitor = new JsonSerializationVisitor(

                 writer, false);

         accept(visitor);

         return writer.toString();

     }

     /**

      * Returns the mapping from the names of elements to the element.

      * 

      * @return The mapping from the names of elements to the element.

      */

     protected abstract Map<String, Element> getElementMap();

 }