/*
 * Copyright (c) 2007 Mockito contributors
 * This program is made available under the terms of the MIT License.
 */
package org.mockito.internal.invocation;

import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

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

import org.assertj.core.api.Assertions;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.internal.verification.InOrderContextImpl;
import org.mockito.internal.verification.api.InOrderContext;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.Location;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;


public class InvocationsFinderTest extends TestBase {

    private LinkedList<Invocation> invocations = new LinkedList<Invocation>();
    private Invocation simpleMethodInvocation;
    private Invocation simpleMethodInvocationTwo;
    private Invocation differentMethodInvocation;


    private final InOrderContext context = new InOrderContextImpl();

    @Mock private IMethods mock;

    @Before
    public void setup() throws Exception {
        simpleMethodInvocation = new InvocationBuilder().mock(mock).simpleMethod().seq(1).toInvocation();
        simpleMethodInvocationTwo = new InvocationBuilder().mock(mock).simpleMethod().seq(2).toInvocation();
        differentMethodInvocation = new InvocationBuilder().mock(mock).differentMethod().seq(3).toInvocation();
        invocations.addAll(Arrays.asList(simpleMethodInvocation, simpleMethodInvocationTwo, differentMethodInvocation));

    }

    @Test
    public void shouldFindActualInvocations() throws Exception {
        List<Invocation> actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(simpleMethodInvocation));
        Assertions.assertThat(actual).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);

        actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(differentMethodInvocation));
        Assertions.assertThat(actual).containsSequence(differentMethodInvocation);
    }

    @Test
    public void shouldFindFirstUnverifiedInvocation() throws Exception {
        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverified(invocations));

        simpleMethodInvocationTwo.markVerified();
        simpleMethodInvocation.markVerified();

        assertSame(differentMethodInvocation, InvocationsFinder.findFirstUnverified(invocations));

        differentMethodInvocation.markVerified();
        assertNull(InvocationsFinder.findFirstUnverified(invocations));
    }

    @Test
    public void shouldFindFirstUnverifiedInOrder() throws Exception {
        //given
        InOrderContextImpl context = new InOrderContextImpl();
        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));

        //when
        context.markVerified(simpleMethodInvocationTwo);
        context.markVerified(simpleMethodInvocation);

        //then
        assertSame(differentMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));

        //when
        context.markVerified(differentMethodInvocation);

        //then
        assertNull(InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
    }

    @Test
    public void shouldFindFirstUnverifiedInOrderAndRespectSequenceNumber() throws Exception {
        //given
        InOrderContextImpl context = new InOrderContextImpl();
        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));

        //when
        //skipping verification of first invocation, then:
        context.markVerified(simpleMethodInvocationTwo);
        context.markVerified(differentMethodInvocation);

        //then
        assertSame(null, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
    }

    @Test
    public void shouldFindFirstUnverifiedInvocationOnMock() throws Exception {
        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverified(invocations, simpleMethodInvocation.getMock()));
        assertNull(InvocationsFinder.findFirstUnverified(invocations, "different mock"));
    }

    @Test
    public void shouldFindFirstSimilarInvocationByName() throws Exception {
        Invocation overloadedSimpleMethod = new InvocationBuilder().mock(mock).simpleMethod().arg("test").toInvocation();

        Invocation found = InvocationsFinder.findSimilarInvocation(invocations, new InvocationMatcher(overloadedSimpleMethod));
        assertSame(found, simpleMethodInvocation);
    }

    @Test
    public void shouldFindInvocationWithTheSameMethod() throws Exception {
        Invocation overloadedDifferentMethod = new InvocationBuilder().differentMethod().arg("test").toInvocation();

        invocations.add(overloadedDifferentMethod);

        Invocation found = InvocationsFinder.findSimilarInvocation(invocations, new InvocationMatcher(overloadedDifferentMethod));
        assertSame(found, overloadedDifferentMethod);
    }

    @Test
    public void shouldGetLastStackTrace() throws Exception {
        Location last = InvocationsFinder.getLastLocation(invocations);
        assertSame(differentMethodInvocation.getLocation(), last);

        assertNull(InvocationsFinder.getLastLocation(Collections.<Invocation>emptyList()));
    }

    @Test
    public void shouldFindAllMatchingUnverifiedChunks() throws Exception {
        List<Invocation> allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
        Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);

        context.markVerified(simpleMethodInvocation);
        allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
        Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocationTwo);

        context.markVerified(simpleMethodInvocationTwo);
        allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
        assertTrue(allMatching.isEmpty());
    }

    @Test
    public void shouldFindMatchingChunk() throws Exception {
        List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 2, context);
        Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
    }

    @Test
    public void shouldReturnAllChunksWhenModeIsAtLeastOnce() throws Exception {
        Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
        invocations.add(simpleMethodInvocationThree);

        List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
        Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree);
    }

    @Test
    public void shouldReturnAllChunksWhenWantedCountDoesntMatch() throws Exception {
        Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
        invocations.add(simpleMethodInvocationThree);

        List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
        Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree);
    }

    @Test
    public void shouldFindPreviousInOrder() throws Exception {
        Invocation previous = InvocationsFinder.findPreviousVerifiedInOrder(invocations, context);
        assertNull(previous);

        context.markVerified(simpleMethodInvocation);
        context.markVerified(simpleMethodInvocationTwo);

        previous = InvocationsFinder.findPreviousVerifiedInOrder(invocations, context);
        assertSame(simpleMethodInvocationTwo, previous);
    }

    @Test
    public void shouldFindAllStackTraces() {
        List<Location> all = InvocationsFinder.getAllLocations(invocations);
        Assertions.assertThat(all).contains(simpleMethodInvocation.getLocation(), simpleMethodInvocationTwo.getLocation(), differentMethodInvocation.getLocation());
    }

    @Test
    public void shouldNotFindLocationsForEmptyInvocationsList() {
        Assertions.assertThat(InvocationsFinder.getAllLocations(Collections.<Invocation>emptyList())).isEmpty();
    }
}
