/*

  * #%L

  * RootDocument.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.IOException;

 import java.io.ObjectInputStream;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.concurrent.atomic.AtomicReference;

 import com.allanbank.mongodb.bson.Document;

 import com.allanbank.mongodb.bson.Element;

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

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

 /**

  * A root level document that can inject a _id value.

  * 

  * @api.no This class is <b>NOT</b> part of the drivers API. This class may be

  *         mutated in incompatible ways between any two releases of the driver.

  * @copyright 2011-2014, Allanbank Consulting, Inc., All Rights Reserved

  */

 public class RootDocument extends AbstractDocument {

     /** Serialization version for the class. */

     private static final long serialVersionUID = -2875918328146027036L;

     /**

      * Computes and returns the number of bytes that are used to encode the

      * document.

      * 

      * @param entries

      *            The entries in the document.

      * @return The size of the document when encoded in bytes.

      */

     private static long computeSize(final List<Element> entries) {

         long result = 5; // int length (4) + terminal null byte (1).

         if ((entries != null) && !entries.isEmpty()) {

             for (final Element element : entries) {

                 result += element.size();

             }

         }

         return result;

     }

     /** The elements of the document. */

     final AtomicReference<List<Element>> myElements;

     /**

      * Tracks if the _id field is known to exist in the document when

      * constructed.

      */

     final boolean myIdKnownPresent;

     /**

      * Constructed when a user tries to access the elements of the document by

      * name.

      */

     private final AtomicReference<Map<String, Element>> myElementMap;

     /** The size of the document when encoded as bytes. */

     private transient long mySize;

     /**

      * Constructs a new {@link RootDocument}.

      * 

      * @param elements

      *            The elements for the BSON document.

      */

     public RootDocument(final Element... elements) {

         this(Arrays.asList(elements), false);

     }

     /**

      * Constructs a new {@link RootDocument}.

      * 

      * @param elements

      *            The elements for the BSON document.

      */

     public RootDocument(final List<Element> elements) {

         this(elements, false);

     }

     /**

      * Constructs a new {@link RootDocument}.

      * 

      * @param elements

      *            The elements for the BSON document.

      * @param idPresent

      *            If true then there is an _id element in the list of elements.

      */

     public RootDocument(final List<Element> elements, final boolean idPresent) {

         this(elements, idPresent, computeSize(elements));

     }

     /**

      * Constructs a new {@link RootDocument}.

      * 

      * @param elements

      *            The elements for the BSON document.

      * @param idPresent

      *            If true then there is an _id element in the list of elements.

      * @param size

      *            The size of the document when encoded in bytes. If not known

      *            then use the {@link RootDocument#RootDocument(List, boolean)}

      *            constructor instead.

      */

     public RootDocument(final List<Element> elements, final boolean idPresent,

             final long size) {

         myElements = new AtomicReference<List<Element>>();

         myElementMap = new AtomicReference<Map<String, Element>>();

         if ((elements != null) && !elements.isEmpty()) {

             myElements.set(Collections.unmodifiableList(new ArrayList<Element>(

                     elements)));

         }

         else {

             myElements.set(EMPTY_ELEMENTS);

         }

         myIdKnownPresent = idPresent;

         mySize = size;

     }

     /**

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

      * 

      * @see Document#contains(String)

      */

     @Override

     public boolean contains(final String name) {

         return (myIdKnownPresent && "_id".equals(name)) || super.contains(name);

     }

     /**

      * Returns the elements in the document.

      * 

      * @return The elements in the document.

      */

     @Override

     public List<Element> getElements() {

         return myElements.get();

     }

     /**

      * Adds an {@link ObjectIdElement} to the head of the document.

      */

     public void injectId() {

         if (!contains("_id")) {

             final List<Element> old = myElements.get();

             final ObjectIdElement toAdd = new ObjectIdElement("_id",

                     new ObjectId());

             final List<Element> newElements = new ArrayList<Element>(

                     old.size() + 1);

             newElements.add(toAdd);

             newElements.addAll(old);

             if (myElements.compareAndSet(old, newElements)) {

                 myElementMap.set(null);

                 mySize += toAdd.size();

             }

         }

     }

     /**

      * Returns the size of the document when encoded as bytes.

      * 

      * @return The size of the document when encoded as bytes.

      */

     @Override

     public long size() {

         return mySize;

     }

     /**

      * Returns a map from the element names to the elements in the document.

      * Used for faster by-name access.

      * 

      * @return The element name to element mapping.

      */

     @Override

     protected Map<String, Element> getElementMap() {

         if (myElementMap.get() == null) {

             final List<Element> elements = myElements.get();

             final Map<String, Element> mapping = new HashMap<String, Element>(

                     elements.size() + elements.size());

             for (final Element element : elements) {

                 mapping.put(element.getName(), element);

             }

             // Swap the finished map into position.

             myElementMap.compareAndSet(null, mapping);

         }

         return myElementMap.get();

     }

     /**

      * Sets the transient state of this document.

      * 

      * @param in

      *            The input stream.

      * @throws ClassNotFoundException

      *             On a failure loading a class in this classed reachable tree.

      * @throws IOException

      *             On a failure reading from the stream.

      */

     private void readObject(final ObjectInputStream in)

             throws ClassNotFoundException, IOException {

         in.defaultReadObject();

         mySize = computeSize(getElements());

     }

 }