/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Portions Copyright 2007 Sun Microsystems, Inc.
 */

package org.opends.server.admin;



import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import org.opends.server.admin.std.meta.RootCfgDefn;



/**
 * A path which can be used to determine the location of a managed
 * object instance.
 */
public final class ManagedObjectPath {

  /**
   * Abstract path element.
   */
  private static abstract class Element {

    /**
     * Protected constructor.
     */
    protected Element() {
      // No implementation required.
    }



    /**
     * Get the relation definition associated with this element.
     *
     * @return Returns the relation definition associated with this
     *         element.
     */
    public abstract RelationDefinition<?, ?> getRelation();



    /**
     * Serialize this path element using the provided serialization
     * strategy.
     *
     * @param serializer
     *          The managed object path serialization strategy.
     */
    public abstract void serialize(
        ManagedObjectPathSerializer serializer);
  }



  /**
   * A path element representing an instantiable managed object.
   */
  private static final class InstantiableElement extends Element {

    // The instantiable relation.
    private final InstantiableRelationDefinition<?, ?> r;

    // The name of the managed object.
    private final String name;



    // Private constructor.
    private InstantiableElement(
        InstantiableRelationDefinition<?, ?> r, String name) {
      this.r = r;
      this.name = name;
    }



    /**
     * {@inheritDoc}
     */
    @Override
    public RelationDefinition<?, ?> getRelation() {
      return r;
    }



    /**
     * {@inheritDoc}
     */
    @Override
    public void serialize(ManagedObjectPathSerializer serializer) {
      serializer.appendManagedObjectPathElement(r, name);
    }

  }



  /**
   * A path element representing an optional managed object.
   */
  private static final class OptionalElement extends Element {

    // The optional relation.
    private final OptionalRelationDefinition<?, ?> r;



    // Private constructor.
    private OptionalElement(OptionalRelationDefinition<?, ?> r) {
      this.r = r;
    }



    /**
     * {@inheritDoc}
     */
    @Override
    public RelationDefinition<?, ?> getRelation() {
      return r;
    }



    /**
     * {@inheritDoc}
     */
    @Override
    public void serialize(ManagedObjectPathSerializer serializer) {
      serializer.appendManagedObjectPathElement(r);
    }
  }



  /**
   * A path element representing a singleton managed object.
   */
  private static final class SingletonElement extends Element {

    // The singleton relation.
    private final SingletonRelationDefinition<?, ?> r;



    // Private constructor.
    private SingletonElement(SingletonRelationDefinition<?, ?> r) {
      this.r = r;
    }



    /**
     * {@inheritDoc}
     */
    @Override
    public RelationDefinition<?, ?> getRelation() {
      return r;
    }



    /**
     * {@inheritDoc}
     */
    @Override
    public void serialize(ManagedObjectPathSerializer serializer) {
      serializer.appendManagedObjectPathElement(r);
    }
  }

  // Single instance of a root path.
  private static final ManagedObjectPath EMPTY_PATH = new ManagedObjectPath(
      new LinkedList<Element>());



  /**
   * Creates a new managed object path representing the configuration
   * root.
   *
   * @return Returns a new managed object path representing the
   *         configuration root.
   */
  public static ManagedObjectPath emptyPath() {
    return EMPTY_PATH;
  }


  /**
   * Returns a managed object path holding the value of the specified
   * string.
   *
   * @param s
   *          The string to be parsed.
   * @return Returns a managed object path holding the value of the
   *         specified string.
   * @throws IllegalArgumentException
   *           If the string could not be parsed.
   */
  public static ManagedObjectPath valueOf(String s)
      throws IllegalArgumentException {
    return null;
  }



  // The list of path elements in this path.
  private final List<Element> elements;



  // Private constructor.
  private ManagedObjectPath(LinkedList<Element> elements) {
    this.elements = Collections.unmodifiableList(elements);
  }



  /**
   * Creates a new child managed object path beneath the provided
   * parent path.
   *
   * @param r
   *          The instantiable relation referencing the child.
   * @param name
   *          The relative name of the child managed object.
   * @return Returns a new child managed object path beneath the
   *         provided parent path.
   */
  public ManagedObjectPath child(
      InstantiableRelationDefinition<?, ?> r, String name) {
    LinkedList<Element> celements = new LinkedList<Element>(elements);
    celements.add(new InstantiableElement(r, name));
    return new ManagedObjectPath(celements);
  }



  /**
   * Creates a new child managed object path beneath the provided
   * parent path.
   *
   * @param r
   *          The optional relation referencing the child.
   * @return Returns a new child managed object path beneath the
   *         provided parent path.
   */
  public ManagedObjectPath child(OptionalRelationDefinition<?, ?> r) {
    LinkedList<Element> celements = new LinkedList<Element>(elements);
    celements.add(new OptionalElement(r));
    return new ManagedObjectPath(celements);
  }



  /**
   * Creates a new child managed object path beneath the provided
   * parent path.
   *
   * @param r
   *          The singleton relation referencing the child.
   * @return Returns a new child managed object path beneath the
   *         provided parent path.
   */
  public ManagedObjectPath child(SingletonRelationDefinition<?, ?> r) {
    LinkedList<Element> celements = new LinkedList<Element>(elements);
    celements.add(new SingletonElement(r));
    return new ManagedObjectPath(celements);
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public boolean equals(Object obj) {
    if (obj == this) {
      return true;
    } else if (obj instanceof ManagedObjectPath) {
      ManagedObjectPath other = (ManagedObjectPath) obj;
      return toString().equals(other.toString());
    } else {
      return false;
    }
  }



  /**
   * Get the definition of the managed object referred to by this
   * path.
   * <p>
   * When the path is empty, the {@link RootCfgDefn}
   * is returned.
   *
   * @return Returns the definition of the managed object referred to
   *         by this path, or the {@link RootCfgDefn}
   *         if the path is empty.
   */
  public AbstractManagedObjectDefinition<?, ?> getManagedObjectDefinition() {
    if (elements.isEmpty()) {
      return RootCfgDefn.getInstance();
    } else {
      Element e = elements.get(elements.size() - 1);
      return e.getRelation().getChildDefinition();
    }
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public int hashCode() {
    return toString().hashCode();
  }



  /**
   * Determine whether or not this path contains any path elements.
   *
   * @return Returns <code>true</code> if this path does not contain
   *         any path elements.
   */
  public boolean isEmpty() {
    return elements.isEmpty();
  }



  /**
   * Creates a new parent managed object path the specified number of
   * path elements above this path.
   *
   * @param offset
   *          The number of path elements (0 - means no offset, 1
   *          means the parent, and 2 means the grand-parent).
   * @return Returns a new parent managed object path the specified
   *         number of path elements above this path.
   * @throws IllegalArgumentException
   *           If the offset is less than 0, or greater than the
   *           number of path elements in this path.
   */
  public ManagedObjectPath parent(int offset)
      throws IllegalArgumentException {
    if (offset < 0) {
      throw new IllegalArgumentException("Negative offset");
    }

    if (offset > elements.size()) {
      throw new IllegalArgumentException(
          "Offset is greater than the number of path elements");
    }

    // An offset of 0 leaves the path unchanged.
    if (offset == 0) {
      return this;
    }

    LinkedList<Element> celements = new LinkedList<Element>(elements
        .subList(0, elements.size() - offset));
    return new ManagedObjectPath(celements);
  }



  /**
   * Serialize this managed object path using the provided
   * serialization strategy.
   * <p>
   * The path elements will be passed to the serializer in big-endian
   * order: starting from the root element and proceeding down to the
   * leaf.
   *
   * @param serializer
   *          The managed object path serialization strategy.
   */
  public void serialize(ManagedObjectPathSerializer serializer) {
    for (Element element : elements) {
      element.serialize(serializer);
    }
  }



  /**
   * Get the number of path elements in this managed object path.
   *
   * @return Returns the number of path elements (0 - means no offset,
   *         1 means the parent, and 2 means the grand-parent).
   */
  public int size() {
    return elements.size();
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    toString(builder);
    return builder.toString();
  }



  /**
   * Appends a string representation of this managed object path to
   * the provided string builder.
   *
   * @param builder
   *          Append the string representation to this builder.
   * @see #toString()
   */
  public void toString(final StringBuilder builder) {
    // Use a simple serializer to create the contents.
    ManagedObjectPathSerializer serializer = new ManagedObjectPathSerializer() {

      public void appendManagedObjectPathElement(
          InstantiableRelationDefinition<?, ?> r, String name) {
        builder.append('/');
        builder.append(r.getName());
        builder.append('/');
        builder.append(name);
      }



      public void appendManagedObjectPathElement(
          OptionalRelationDefinition<?, ?> r) {
        builder.append('/');
        builder.append(r.getName());
      }



      public void appendManagedObjectPathElement(
          SingletonRelationDefinition<?, ?> r) {
        builder.append('/');
        builder.append(r.getName());
      }

    };

    serialize(serializer);
  }

}