/*
 * 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 2011 ForgeRock AS
 *      Portions copyright 2012 ForgeRock AS.
 */

package org.forgerock.opendj.ldif;

import static org.fest.assertions.Assertions.assertThat;
import static org.fest.assertions.Fail.fail;
import static org.forgerock.opendj.ldap.ErrorResultException.newErrorResult;
import static org.forgerock.opendj.ldap.responses.Responses.newResult;
import static org.forgerock.opendj.ldap.responses.Responses.newSearchResultEntry;
import static org.forgerock.opendj.ldap.responses.Responses.newSearchResultReference;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.isNull;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.util.NoSuchElementException;

import org.forgerock.opendj.ldap.Connection;
import org.forgerock.opendj.ldap.ErrorResultIOException;
import org.forgerock.opendj.ldap.FutureResult;
import org.forgerock.opendj.ldap.IntermediateResponseHandler;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.opendj.ldap.SearchResultHandler;
import org.forgerock.opendj.ldap.SearchResultReferenceIOException;
import org.forgerock.opendj.ldap.SearchScope;
import org.forgerock.opendj.ldap.requests.Requests;
import org.forgerock.opendj.ldap.requests.SearchRequest;
import org.forgerock.opendj.ldap.responses.Result;
import org.forgerock.opendj.ldap.responses.SearchResultEntry;
import org.forgerock.opendj.ldap.responses.SearchResultReference;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.testng.annotations.Test;

import com.forgerock.opendj.util.CompletedFutureResult;

/**
 * This class tests the ConnectionEntryReader functionality.
 */
@SuppressWarnings("javadoc")
public class ConnectionEntryReaderTestCase extends AbstractLDIFTestCase {

    private static final SearchResultEntry ENTRY1 = newSearchResultEntry("cn=entry1");
    private static final SearchResultEntry ENTRY2 = newSearchResultEntry("cn=entry2");
    private static final SearchResultEntry ENTRY3 = newSearchResultEntry("cn=entry3");
    private static final Result ERROR = newResult(ResultCode.BUSY);
    private static final SearchResultReference REF =
            newSearchResultReference("http://www.forgerock.com/");
    private static final SearchRequest SEARCH = Requests.newSearchRequest("",
            SearchScope.WHOLE_SUBTREE, "(objectClass=*)");
    private static final Result SUCCESS = newResult(ResultCode.SUCCESS);

    @Test
    public final void testHasNextWhenError() throws Exception {
        final ConnectionEntryReader reader = newReader(ERROR);
        try {
            reader.hasNext();
            fail();
        } catch (final ErrorResultIOException e) {
            assertThat(e.getCause().getResult()).isSameAs(ERROR);
        } finally {
            reader.close();
        }
    }

    @Test()
    public final void testReadEntry() throws Exception {
        final ConnectionEntryReader reader = newReader(ENTRY1, SUCCESS);
        try {
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.isEntry()).isTrue();
            assertThat(reader.isReference()).isFalse();
            assertThat(reader.readEntry()).isSameAs(ENTRY1);
            assertThat(reader.hasNext()).isFalse();
            assertThat(reader.readResult()).isSameAs(SUCCESS);
        } finally {
            reader.close();
        }
    }

    @Test
    public final void testReadEntryWhenError() throws Exception {
        final ConnectionEntryReader reader = newReader(ERROR);
        try {
            reader.readEntry();
            fail();
        } catch (final ErrorResultIOException e) {
            assertThat(e.getCause().getResult()).isSameAs(ERROR);
        } finally {
            reader.close();
        }
    }

    @Test(expectedExceptions = NoSuchElementException.class)
    public final void testReadEntryWhenNoMore() throws Exception {
        final ConnectionEntryReader reader = newReader(SUCCESS);
        try {
            assertThat(reader.hasNext()).isFalse();
            reader.readEntry();
        } finally {
            reader.close();
        }
    }

    @Test
    public final void testReadEntryWhenReference() throws Exception {
        final ConnectionEntryReader reader = newReader(REF, SUCCESS);
        try {
            assertThat(reader.hasNext()).isTrue();
            try {
                reader.readEntry();
                fail();
            } catch (final SearchResultReferenceIOException e) {
                assertThat(e.getReference()).isSameAs(REF);
            }
            assertThat(reader.hasNext()).isFalse();
            assertThat(reader.readResult()).isSameAs(SUCCESS);
        } finally {
            reader.close();
        }
    }

    @Test()
    public final void testReadMultipleResults() throws Exception {
        final ConnectionEntryReader reader = newReader(ENTRY1, ENTRY2, REF, ENTRY3, SUCCESS);
        try {
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.readEntry()).isSameAs(ENTRY1);
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.readEntry()).isSameAs(ENTRY2);
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.readReference()).isSameAs(REF);
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.readEntry()).isSameAs(ENTRY3);
            assertThat(reader.hasNext()).isFalse();
            assertThat(reader.readResult()).isSameAs(SUCCESS);
        } finally {
            reader.close();
        }
    }

    @Test()
    public final void testReadReference() throws Exception {
        final ConnectionEntryReader reader = newReader(REF, SUCCESS);
        try {
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.isEntry()).isFalse();
            assertThat(reader.isReference()).isTrue();
            assertThat(reader.readReference()).isSameAs(REF);
            assertThat(reader.hasNext()).isFalse();
            assertThat(reader.readResult()).isSameAs(SUCCESS);
        } finally {
            reader.close();
        }
    }

    @Test()
    public final void testReadReferenceWhenEntry() throws Exception {
        final ConnectionEntryReader reader = newReader(ENTRY1, SUCCESS);
        try {
            assertThat(reader.hasNext()).isTrue();
            assertThat(reader.readReference()).isNull();
            assertThat(reader.readEntry()).isSameAs(ENTRY1);
            assertThat(reader.hasNext()).isFalse();
            assertThat(reader.readResult()).isSameAs(SUCCESS);
        } finally {
            reader.close();
        }
    }

    @Test
    public final void testReadReferenceWhenError() throws Exception {
        final ConnectionEntryReader reader = newReader(ERROR);
        try {
            reader.readReference();
            fail();
        } catch (final ErrorResultIOException e) {
            assertThat(e.getCause().getResult()).isSameAs(ERROR);
        } finally {
            reader.close();
        }
    }

    @Test(expectedExceptions = NoSuchElementException.class)
    public final void testReadReferenceWhenNoMore() throws Exception {
        final ConnectionEntryReader reader = newReader(SUCCESS);
        try {
            assertThat(reader.hasNext()).isFalse();
            reader.readReference();
        } finally {
            reader.close();
        }
    }

    @Test
    public final void testReadResult() throws Exception {
        final ConnectionEntryReader reader = newReader(SUCCESS);
        try {
            assertThat(reader.readResult()).isSameAs(SUCCESS);
        } finally {
            reader.close();
        }
    }

    @Test
    public final void testReadResultWhenError() throws Exception {
        final ConnectionEntryReader reader = newReader(ERROR);
        try {
            reader.readResult();
            fail();
        } catch (final ErrorResultIOException e) {
            assertThat(e.getCause().getResult()).isSameAs(ERROR);
        } finally {
            reader.close();
        }
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public final void testReadResultWhenEntry() throws Exception {
        final ConnectionEntryReader reader = newReader(ENTRY1, SUCCESS);
        try {
            reader.readResult();
        } finally {
            reader.close();
        }
    }

    private ConnectionEntryReader newReader(final Object... responses) {
        final Connection connection = mock(Connection.class);
        // @formatter:off
        when(connection.searchAsync(same(SEARCH), (IntermediateResponseHandler) isNull(),
                any(SearchResultHandler.class))).thenAnswer(
                        new Answer<FutureResult<Result>>() {
                            @Override
                            public FutureResult<Result> answer(final InvocationOnMock invocation)
                                    throws Throwable {
                                // Execute handler and return future.
                                final SearchResultHandler handler =
                                        (SearchResultHandler) invocation.getArguments()[2];
                                if (handler != null) {
                                    for (int i = 0; i < responses.length; i++) {
                                        final Object response = responses[i];
                                        if (response instanceof SearchResultEntry) {
                                            handler.handleEntry((SearchResultEntry) response);
                                        } else if (response instanceof SearchResultReference) {
                                            handler.handleReference((SearchResultReference) response);
                                        } else if (((Result) response).isSuccess()) {
                                            handler.handleResult((Result) response);
                                        } else {
                                            handler.handleErrorResult(newErrorResult((Result) response));
                                        }
                                    }
                                }
                                final Result result = (Result) responses[responses.length - 1];
                                if (result.isSuccess()) {
                                    return new CompletedFutureResult<Result>(result);
                                } else {
                                    return new CompletedFutureResult<Result>(newErrorResult(result));
                                }
                            }
                        });
        // @formatter:on
        return new ConnectionEntryReader(connection, SEARCH);
    }

}