/*
 * 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 legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * 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 legal-notices/CDDLv1_0.txt.
 * 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-2010 Sun Microsystems, Inc.
 *      Portions copyright 2011-2012 ForgeRock AS
 */

package org.forgerock.opendj.examples;

import static org.forgerock.opendj.ldap.ErrorResultException.newErrorResult;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.NavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import javax.net.ssl.SSLContext;

import org.forgerock.opendj.ldap.CancelledResultException;
import org.forgerock.opendj.ldap.Connections;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.Entry;
import org.forgerock.opendj.ldap.ErrorResultException;
import org.forgerock.opendj.ldap.Filter;
import org.forgerock.opendj.ldap.IntermediateResponseHandler;
import org.forgerock.opendj.ldap.KeyManagers;
import org.forgerock.opendj.ldap.LDAPClientContext;
import org.forgerock.opendj.ldap.LDAPListener;
import org.forgerock.opendj.ldap.LDAPListenerOptions;
import org.forgerock.opendj.ldap.LinkedHashMapEntry;
import org.forgerock.opendj.ldap.Matcher;
import org.forgerock.opendj.ldap.Modification;
import org.forgerock.opendj.ldap.ModificationType;
import org.forgerock.opendj.ldap.RequestContext;
import org.forgerock.opendj.ldap.RequestHandler;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.opendj.ldap.ResultHandler;
import org.forgerock.opendj.ldap.SSLContextBuilder;
import org.forgerock.opendj.ldap.SearchResultHandler;
import org.forgerock.opendj.ldap.SearchScope;
import org.forgerock.opendj.ldap.ServerConnection;
import org.forgerock.opendj.ldap.ServerConnectionFactory;
import org.forgerock.opendj.ldap.TrustManagers;
import org.forgerock.opendj.ldap.requests.AddRequest;
import org.forgerock.opendj.ldap.requests.BindRequest;
import org.forgerock.opendj.ldap.requests.CompareRequest;
import org.forgerock.opendj.ldap.requests.DeleteRequest;
import org.forgerock.opendj.ldap.requests.ExtendedRequest;
import org.forgerock.opendj.ldap.requests.ModifyDNRequest;
import org.forgerock.opendj.ldap.requests.ModifyRequest;
import org.forgerock.opendj.ldap.requests.SearchRequest;
import org.forgerock.opendj.ldap.responses.BindResult;
import org.forgerock.opendj.ldap.responses.CompareResult;
import org.forgerock.opendj.ldap.responses.ExtendedResult;
import org.forgerock.opendj.ldap.responses.Responses;
import org.forgerock.opendj.ldap.responses.Result;
import org.forgerock.opendj.ldif.LDIFEntryReader;

/**
 * An LDAP directory server which exposes data contained in an LDIF file. This
 * is implementation is very simple and is only intended as an example:
 * <ul>
 * <li>It does not support SSL connections
 * <li>It does not support StartTLS
 * <li>It does not support Abandon or Cancel requests
 * <li>Very basic authentication and authorization support.
 * </ul>
 * This example takes the following command line parameters:
 *
 * <pre>
 *  &lt;listenAddress> &lt;listenPort> [&lt;ldifFile>]
 * </pre>
 */
public final class Server {
    private static final class MemoryBackend implements RequestHandler<RequestContext> {
        private final ConcurrentSkipListMap<DN, Entry> entries;
        private final ReentrantReadWriteLock entryLock = new ReentrantReadWriteLock();

        private MemoryBackend(final ConcurrentSkipListMap<DN, Entry> entries) {
            this.entries = entries;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleAdd(final RequestContext requestContext, final AddRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super Result> resultHandler) {
            // TODO: controls.
            entryLock.writeLock().lock();
            try {
                DN dn = request.getName();
                if (entries.containsKey(dn)) {
                    resultHandler.handleErrorResult(ErrorResultException.newErrorResult(
                            ResultCode.ENTRY_ALREADY_EXISTS, "The entry " + dn.toString()
                                    + " already exists"));
                }

                DN parent = dn.parent();
                if (!entries.containsKey(parent)) {
                    resultHandler.handleErrorResult(ErrorResultException.newErrorResult(
                            ResultCode.NO_SUCH_OBJECT, "The parent entry " + parent.toString()
                                    + " does not exist"));
                } else {
                    entries.put(dn, request);
                    resultHandler.handleResult(Responses.newResult(ResultCode.SUCCESS));
                }
            } finally {
                entryLock.writeLock().unlock();
            }
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleBind(final RequestContext requestContext, final int version,
                final BindRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super BindResult> resultHandler) {
            if (request.getAuthenticationType() != ((byte) 0x80)) {
                // TODO: SASL authentication not implemented.
                resultHandler.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR,
                        "non-SIMPLE authentication not supported: "
                                + request.getAuthenticationType()));
            } else {
                // TODO: always succeed.
                resultHandler.handleResult(Responses.newBindResult(ResultCode.SUCCESS));
            }
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleCompare(final RequestContext requestContext,
                final CompareRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super CompareResult> resultHandler) {
            // TODO:
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleDelete(final RequestContext requestContext, final DeleteRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super Result> resultHandler) {
            // TODO: controls.
            entryLock.writeLock().lock();
            try {
                // TODO: check for children.
                DN dn = request.getName();
                if (!entries.containsKey(dn)) {
                    resultHandler.handleErrorResult(ErrorResultException.newErrorResult(
                            ResultCode.NO_SUCH_OBJECT, "The entry " + dn.toString()
                                    + " does not exist"));
                } else {
                    entries.remove(dn);
                    resultHandler.handleResult(Responses.newResult(ResultCode.SUCCESS));
                }
            } finally {
                entryLock.writeLock().unlock();
            }
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public <R extends ExtendedResult> void handleExtendedRequest(
                final RequestContext requestContext, final ExtendedRequest<R> request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super R> resultHandler) {
            // TODO: not implemented.
            resultHandler.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR,
                    "Extended request operation not supported"));
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleModify(final RequestContext requestContext, final ModifyRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super Result> resultHandler) {
            // TODO: controls.
            // TODO: read lock is not really enough since concurrent updates may
            // still occur to the same entry.
            entryLock.readLock().lock();
            try {
                DN dn = request.getName();
                Entry entry = entries.get(dn);
                if (entry == null) {
                    resultHandler.handleErrorResult(ErrorResultException.newErrorResult(
                            ResultCode.NO_SUCH_OBJECT, "The entry " + dn.toString()
                                    + " does not exist"));
                }

                Entry newEntry = new LinkedHashMapEntry(entry);
                for (Modification mod : request.getModifications()) {
                    ModificationType modType = mod.getModificationType();
                    if (modType.equals(ModificationType.ADD)) {
                        // TODO: Reject empty attribute and duplicate values.
                        newEntry.addAttribute(mod.getAttribute(), null);
                    } else if (modType.equals(ModificationType.DELETE)) {
                        // TODO: Reject missing values.
                        newEntry.removeAttribute(mod.getAttribute(), null);
                    } else if (modType.equals(ModificationType.REPLACE)) {
                        newEntry.replaceAttribute(mod.getAttribute());
                    } else {
                        resultHandler.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR,
                                "Modify request contains an unsupported modification type"));
                        return;
                    }
                }

                entries.put(dn, newEntry);
                resultHandler.handleResult(Responses.newResult(ResultCode.SUCCESS));
            } finally {
                entryLock.readLock().unlock();
            }
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleModifyDN(final RequestContext requestContext,
                final ModifyDNRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final ResultHandler<? super Result> resultHandler) {
            // TODO: not implemented.
            resultHandler.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR,
                    "ModifyDN request operation not supported"));
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void handleSearch(final RequestContext requestContext, final SearchRequest request,
                final IntermediateResponseHandler intermediateResponseHandler,
                final SearchResultHandler resultHandler) {
            // TODO: controls, limits, etc.
            entryLock.readLock().lock();
            try {
                DN dn = request.getName();
                Entry baseEntry = entries.get(dn);
                if (baseEntry == null) {
                    resultHandler.handleErrorResult(ErrorResultException.newErrorResult(
                            ResultCode.NO_SUCH_OBJECT, "The entry " + dn.toString()
                                    + " does not exist"));
                    return;
                }

                SearchScope scope = request.getScope();
                Filter filter = request.getFilter();
                Matcher matcher = filter.matcher();

                if (scope.equals(SearchScope.BASE_OBJECT)) {
                    if (matcher.matches(baseEntry).toBoolean()) {
                        sendEntry(request, resultHandler, baseEntry);
                    }
                } else if (scope.equals(SearchScope.SINGLE_LEVEL)) {
                    NavigableMap<DN, Entry> subtree = entries.tailMap(dn, false);
                    for (Entry entry : subtree.values()) {
                        // Check for cancellation.
                        requestContext.checkIfCancelled(false);

                        DN childDN = entry.getName();
                        if (childDN.isChildOf(dn)) {
                            if (!matcher.matches(entry).toBoolean()) {
                                continue;
                            }

                            if (!sendEntry(request, resultHandler, entry)) {
                                // Caller has asked to stop sending results.
                                break;
                            }
                        } else if (!childDN.isSubordinateOrEqualTo(dn)) {
                            // The remaining entries will be out of scope.
                            break;
                        }
                    }
                } else if (scope.equals(SearchScope.WHOLE_SUBTREE)) {
                    NavigableMap<DN, Entry> subtree = entries.tailMap(dn);
                    for (Entry entry : subtree.values()) {
                        // Check for cancellation.
                        requestContext.checkIfCancelled(false);

                        DN childDN = entry.getName();
                        if (childDN.isSubordinateOrEqualTo(dn)) {
                            if (!matcher.matches(entry).toBoolean()) {
                                continue;
                            }

                            if (!sendEntry(request, resultHandler, entry)) {
                                // Caller has asked to stop sending results.
                                break;
                            }
                        } else {
                            // The remaining entries will be out of scope.
                            break;
                        }
                    }
                } else {
                    resultHandler.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR,
                            "Search request contains an unsupported search scope"));
                    return;
                }

                resultHandler.handleResult(Responses.newResult(ResultCode.SUCCESS));
            } catch (CancelledResultException e) {
                resultHandler.handleErrorResult(e);
            } finally {
                entryLock.readLock().unlock();
            }
        }

        private boolean sendEntry(SearchRequest request, SearchResultHandler resultHandler,
                Entry entry) {
            // TODO: check filter, strip attributes.
            return resultHandler.handleEntry(Responses.newSearchResultEntry(entry));
        }
    }

    /**
     * Main method.
     *
     * @param args
     *            The command line arguments: listen address, listen port,
     *            ldifFile
     */
    public static void main(final String[] args) {
        if (args.length != 3 && args.length != 6) {
            System.err.println("Usage: listenAddress listenPort ldifFile "
                    + "[keyStoreFile keyStorePassword certNickname]");
            System.exit(1);
        }

        // Parse command line arguments.
        final String localAddress = args[0];
        final int localPort = Integer.parseInt(args[1]);
        final String ldifFileName = args[2];
        final String keyStoreFileName = (args.length == 6) ? args[3] : null;
        final String keyStorePassword = (args.length == 6) ? args[4] : null;
        final String certNickname = (args.length == 6) ? args[5] : null;

        // Create the memory backend.
        final ConcurrentSkipListMap<DN, Entry> entries = readEntriesFromLDIF(ldifFileName);
        final MemoryBackend backend = new MemoryBackend(entries);

        // Create a server connection adapter.
        final ServerConnectionFactory<LDAPClientContext, Integer> connectionHandler =
                Connections.newServerConnectionFactory(backend);

        // Create listener.
        LDAPListener listener = null;
        try {
            final LDAPListenerOptions options = new LDAPListenerOptions().setBacklog(4096);

            if (keyStoreFileName != null) {
                // Configure SSL/TLS and enable it when connections are
                // accepted.
                final SSLContext sslContext =
                        new SSLContextBuilder().setKeyManager(
                                KeyManagers.useSingleCertificate(certNickname, KeyManagers
                                        .useKeyStoreFile(keyStoreFileName, keyStorePassword
                                                .toCharArray(), null))).setTrustManager(
                                TrustManagers.trustAll()).getSSLContext();

                ServerConnectionFactory<LDAPClientContext, Integer> sslWrapper =
                        new ServerConnectionFactory<LDAPClientContext, Integer>() {

                            public ServerConnection<Integer> handleAccept(
                                    LDAPClientContext clientContext) throws ErrorResultException {
                                clientContext.enableTLS(sslContext, null, null, false, false);
                                return connectionHandler.handleAccept(clientContext);
                            }
                        };

                listener = new LDAPListener(localAddress, localPort, sslWrapper, options);
            } else {
                // No SSL.
                listener = new LDAPListener(localAddress, localPort, connectionHandler, options);
            }
            System.out.println("Press any key to stop the server...");
            System.in.read();
        } catch (final Exception e) {
            System.out.println("Error listening on " + localAddress + ":" + localPort);
            e.printStackTrace();
        } finally {
            if (listener != null) {
                listener.close();
            }
        }
    }

    /**
     * Reads the entries from the named LDIF file.
     *
     * @param ldifFileName
     *            The name of the LDIF file.
     * @return The entries.
     */
    private static ConcurrentSkipListMap<DN, Entry> readEntriesFromLDIF(final String ldifFileName) {
        final ConcurrentSkipListMap<DN, Entry> entries;
        // Read the LDIF.
        InputStream ldif;
        try {
            ldif = new FileInputStream(ldifFileName);
        } catch (final FileNotFoundException e) {
            System.err.println(e.getMessage());
            System.exit(ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue());
            return null; // Satisfy compiler.
        }

        entries = new ConcurrentSkipListMap<DN, Entry>();
        final LDIFEntryReader reader = new LDIFEntryReader(ldif);
        try {
            while (reader.hasNext()) {
                Entry entry = reader.readEntry();
                entries.put(entry.getName(), entry);
            }
        } catch (final IOException e) {
            System.err.println(e.getMessage());
            System.exit(ResultCode.CLIENT_SIDE_LOCAL_ERROR.intValue());
            return null; // Satisfy compiler.
        } finally {
            try {
                reader.close();
            } catch (final IOException ignored) {
                // Ignore.
            }
        }

        // Quickly sanity check that every entry (except root entries) have a
        // parent.
        boolean isValid = true;
        for (DN dn : entries.keySet()) {
            if (dn.size() > 1) {
                DN parent = dn.parent();
                if (!entries.containsKey(parent)) {
                    System.err
                            .println("The entry \"" + dn.toString() + "\" does not have a parent");
                    isValid = false;
                }
            }
        }
        if (!isValid) {
            System.exit(1);
        }
        return entries;
    }

    private Server() {
        // Not used.
    }
}