/*
 * 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
 *
 *
 *      Copyright 2009 Sun Microsystems, Inc.
 */

package org.opends.server.backends.jeb.importLDIF;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.opends.server.backends.jeb.*;
import org.opends.server.config.ConfigException;
import org.opends.server.types.*;

import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.LockMode;


/**
 * The class represents a suffix. OpenDS backends can have multiple suffixes.
 */
public class Suffix
{
  private final RootContainer rootContainer;
  private final LDIFImportConfig config;
  private final List<DN> includeBranches = new ArrayList<DN>();
  private final List<DN> excludeBranches = new ArrayList<DN>();
  private final DN baseDN;
  private EntryContainer srcEntryContainer = null;
  private EntryContainer entryContainer;
  private boolean exclude = false;
  private final Object synchObject = new Object();
  private static final int PARENT_ID_MAP_SIZE = 4096;

  private ConcurrentHashMap<DN,DN> pendingMap =
                      new ConcurrentHashMap<DN, DN>() ;
  private HashMap<DN,EntryID> parentIDMap =
    new HashMap<DN,EntryID>(PARENT_ID_MAP_SIZE);

  private DN parentDN;
  private ArrayList<EntryID> IDs;

  private Suffix(EntryContainer entryContainer, LDIFImportConfig config,
                 RootContainer rootContainer) throws InitializationException,
          ConfigException
  {
    this.rootContainer = rootContainer;
    this.entryContainer = entryContainer;
    this.config = config;
    this.baseDN = entryContainer.getBaseDN();
    init();
  }

  /**
   * Creates a suffix instance using the specified parameters.
   *
   * @param entryContainer The entry container pertaining to the suffix.
   * @param config The import config instance.
   * @param rootContainer The root container.
   *
   * @return A suffix instance.
   * @throws InitializationException If the suffix cannot be initialized.
   * @throws ConfigException If an error occured reading the configuration.
   */
  public static Suffix
  createSuffixContext(EntryContainer entryContainer, LDIFImportConfig config,
        RootContainer rootContainer) throws InitializationException,
        ConfigException
  {
    return new Suffix(entryContainer, config, rootContainer);
  }

  /**
   * Returns the DN2ID instance pertaining to a suffix instance.
   *
   * @return A DN2ID instance that can be used to manipulate the DN2ID database.
   */
  public DN2ID getDN2ID()
  {
    return entryContainer.getDN2ID();
  }


    /**
   * Returns the ID2Entry instance pertaining to a suffix instance.
   *
   * @return A ID2Entry instance that can be used to manipulate the ID2Entry
     *       database.
   */
  public ID2Entry getID2Entry()
  {
    return entryContainer.getID2Entry();
  }


   /**
   * Returns the DN2URI instance pertaining to a suffix instance.
   *
   * @return A DN2URI instance that can be used to manipulate the DN2URI
    *        database.
   */
  public DN2URI getDN2URI()
  {
    return entryContainer.getDN2URI();
  }


    /**
   * Returns the entry container pertaining to a suffix instance.
   *
   * @return The entry container used to create a suffix instance.
   */
  public EntryContainer getEntryContainer()
  {
    return entryContainer;
  }


  private void init() throws InitializationException, ConfigException
  {
    if(!config.appendToExistingData() && !config.clearBackend()) {
      for(DN dn : config.getExcludeBranches()) {
        if(baseDN.equals(dn))
          exclude = true;
        if(baseDN.isAncestorOf(dn))
          excludeBranches.add(dn);
      }

      if(!config.getIncludeBranches().isEmpty()) {
        for(DN dn : config.getIncludeBranches()) {
          if(baseDN.isAncestorOf(dn))
            includeBranches.add(dn);
        }
        if(includeBranches.isEmpty())
          this.exclude = true;

        // Remove any overlapping include branches.
        Iterator<DN> includeBranchIterator = includeBranches.iterator();
        while(includeBranchIterator.hasNext()) {
          DN includeDN = includeBranchIterator.next();
          boolean keep = true;
          for(DN dn : includeBranches)  {
            if(!dn.equals(includeDN) && dn.isAncestorOf(includeDN)) {
              keep = false;
              break;
            }
          }
          if(!keep)
            includeBranchIterator.remove();
        }

        // Remove any exclude branches that are not are not under a include
        // branch since they will be migrated as part of the existing entries
        // outside of the include branches anyways.
        Iterator<DN> excludeBranchIterator = excludeBranches.iterator();
        while(excludeBranchIterator.hasNext()) {
          DN excludeDN = excludeBranchIterator.next();
          boolean keep = false;
          for(DN includeDN : includeBranches) {
            if(includeDN.isAncestorOf(excludeDN)) {
              keep = true;
              break;
            }
          }
          if(!keep)
            excludeBranchIterator.remove();
        }

        try {
          if(includeBranches.size() == 1 && excludeBranches.size() == 0 &&
              includeBranches.get(0).equals(baseDN)) {
            // This entire base DN is explicitly included in the import with
            // no exclude branches that we need to migrate. Just clear the entry
            // container.
            entryContainer.lock();
            entryContainer.clear();
            entryContainer.unlock();
          } else {
            // Create a temporary entry container
            srcEntryContainer = entryContainer;
            String tmpName = baseDN.toNormalizedString() +"_importTmp";
            entryContainer = rootContainer.openEntryContainer(baseDN, tmpName);
          }
        } catch (DatabaseException e) {
   //       Message msg = ERR_CONFIG_IMPORT_SUFFIX_ERROR.get(e.getMessage());
    //      throw new InitializationException(msg);
        }
      }
    }
  }


  /**
   * Return the Attribute Type - Index map used to map an attribute type to an
   * index instance.
   *
   * @return A suffixes Attribute Type - Index map.
   */
  public Map<AttributeType, AttributeIndex> getAttrIndexMap()
  {
    return entryContainer.getAttributeIndexMap();
  }


  /**
   * Check if the parent DN is in the pending map.
   *
   * @param parentDN The DN of the parent.
   * @return <CODE>True</CODE> if the parent is in the pending map.
   */
  private boolean isPending(DN parentDN)
  {
    boolean ret = false;
    if(pendingMap.containsKey(parentDN)) {
      ret = true;
    }
    return ret;
  }

  /**
   * Add specified DN to the pending map.
   *
   * @param dn The DN to add to the map.
   */
  public void addPending(DN dn)
  {
    pendingMap.putIfAbsent(dn, dn);
  }

  /**
   * Remove the specified DN from the pending map.
   *
   * @param dn The DN to remove from the map.
   */
  public void removePending(DN dn)
  {
    pendingMap.remove(dn);
  }


  /**
   * Return the entry ID related to the specified entry DN. First the instance's
   * cache of parent IDs is checked, if it isn't found then the DN2ID is
   * searched.
   *
   * @param parentDN The DN to get the id for.
   * @return The entry ID related to the parent DN, or null if the id wasn't
   *         found in the cache or dn2id database.
   *
   * @throws DatabaseException If an error occurred search the dn2id database.
   */
  public
  EntryID getParentID(DN parentDN) throws DatabaseException {
    EntryID parentID;
    synchronized(synchObject) {
      parentID = parentIDMap.get(parentDN);
      if (parentID != null) {
        return parentID;
      }
    }
    int i=0;
    //If the parent is in the pending map, another thread is working on the
    //parent entry; wait 500 ms until that thread is done with the parent.
    while(isPending(parentDN)) {
      try {
        Thread.sleep(50);
        if(i == 10) {
          System.out.println("Timed out waiting for: " + parentDN.toString());
          return null;
        }
        i++;
      } catch (Exception e) {
        System.out.println("Exception: " + parentDN.toString());
        return null;
      }
    }
    parentID = entryContainer.getDN2ID().get(null, parentDN, LockMode.DEFAULT);
    //If the parent is in dn2id, add it to the cache.
    if (parentID != null) {
      synchronized(synchObject) {
        if (parentIDMap.size() >= PARENT_ID_MAP_SIZE) {
          Iterator<DN> iterator = parentIDMap.keySet().iterator();
          iterator.next();
          iterator.remove();
        }
        parentIDMap.put(parentDN, parentID);
      }
    }  else {
      System.out.println("parent not found: " + parentDN.toString());
    }
    return parentID;
  }


  /**
   * Sets all of the indexes, vlvIndexes, id2children and id2subtree indexes to
   * trusted.
   *
   * @throws DatabaseException If an error occurred setting the indexes to
   *                           trusted.
   */
  public void setIndexesTrusted() throws DatabaseException
  {
    entryContainer.getID2Children().setTrusted(null,true);
    entryContainer.getID2Subtree().setTrusted(null, true);
    for(AttributeIndex attributeIndex :
        entryContainer.getAttributeIndexes()) {
      Index index;
      if((index = attributeIndex.getEqualityIndex()) != null) {
        index.setTrusted(null, true);
      }
      if((index=attributeIndex.getPresenceIndex()) != null) {
        index.setTrusted(null, true);
      }
      if((index=attributeIndex.getSubstringIndex()) != null) {
        index.setTrusted(null, true);
      }
      if((index=attributeIndex.getOrderingIndex()) != null) {
        index.setTrusted(null, true);
      }
      if((index=attributeIndex.getApproximateIndex()) != null) {
        index.setTrusted(null, true);
      }
    }
    for(VLVIndex vlvIdx : entryContainer.getVLVIndexes()) {
        vlvIdx.setTrusted(null, true);
    }
  }

  /**
   * Get the parent DN of the last entry added to a suffix.
   *
   * @return The parent DN of the last entry added.
   */
  public DN getParentDN()
  {
    return parentDN;
  }


  /**
   * Set the parent DN of the last entry added to a suffix.
   *
   * @param parentDN The parent DN to save.
   */
  public void setParentDN(DN parentDN)
  {
    this.parentDN = parentDN;
  }

  /**
   * Get the entry ID list of the last entry added to a suffix.
   *
   * @return Return the entry ID list of the last entry added to a suffix.
   */
  public ArrayList<EntryID> getIDs()
  {
    return IDs;
  }


  /**
   * Set the entry ID list of the last entry added to a suffix.
   *
   * @param IDs The entry ID list to save.
   */
  public void setIDs(ArrayList<EntryID> IDs)
  {
    this.IDs = IDs;
  }
}