/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.proxy2.stub;

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

import java.util.Arrays;
import java.util.Iterator;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.proxy2.ObjectProvider;
import org.apache.commons.proxy2.provider.BeanProvider;
import org.apache.commons.proxy2.provider.ObjectProviderUtils;
import org.junit.Test;

public class StubBuilderTest extends AbstractStubTestCase
{

    //----------------------------------------------------------------------------------------------------------------------
    // Other Methods
    //----------------------------------------------------------------------------------------------------------------------

    @Override
    protected StubInterface createProxy(Trainer<StubInterface> trainer)
    {
        return new StubBuilder<StubInterface>(proxyFactory, StubInterface.class).train(trainer).build();
    }

    @Test
    public void testWithConcreteTarget()
    {
        StubBuilder<StubInterface> builder = new StubBuilder<StubInterface>(proxyFactory, StubInterface.class,
                new SimpleStub());
        builder.train(new Trainer<StubInterface>()
        {
            @Override
            protected void train(StubInterface trainee)
            {
                when(trainee.one("Foo")).thenReturn("Bar");
            }
        });
        StubInterface stub = builder.build();
        assertEquals("Bar", stub.one("Foo"));
    }

    @Test
    public void testWithNoTargetAndNoInterceptors()
    {
        StubBuilder<StubInterface> builder = new StubBuilder<StubInterface>(proxyFactory, StubInterface.class);
        StubInterface stub = builder.build();
        assertNull(stub.one("Whatever"));
    }

    @Test
    public void testWithNoTargetWithInterceptor()
    {
        StubBuilder<StubInterface> builder = new StubBuilder<StubInterface>(proxyFactory, StubInterface.class);
        builder.train(new Trainer<StubInterface>()
        {
            @Override
            protected void train(StubInterface trainee)
            {
                when(trainee.one("Foo")).thenReturn("Bar");
            }
        });
        StubInterface stub = builder.build();
        assertEquals("Bar", stub.one("Foo"));
    }

    @Test
    public void testWithObjectProviderTarget()
    {
        StubBuilder<StubInterface> builder = new StubBuilder<StubInterface>(proxyFactory, StubInterface.class,
                new BeanProvider<StubInterface>(SimpleStub.class));
        builder.train(new Trainer<StubInterface>()
        {
            @Override
            protected void train(StubInterface trainee)
            {
                when(trainee.one("Foo")).thenReturn("Bar");
            }
        });
        StubInterface stub = builder.build();
        assertEquals("Bar", stub.one("Foo"));
    }

    @Test
    public void testAdditionalInterfaces()
    {
        StubBuilder<StubInterface> builder = new StubBuilder<StubInterface>(proxyFactory, StubInterface.class,
                ObjectProviderUtils.constant(new SimpleStub()));
        builder.train(new Trainer<Iterable<String>>()
        {

            @Override
            protected void train(Iterable<String> trainee)
            {
                when(trainee.iterator()).thenAnswer(new ObjectProvider<Iterator<String>>()
                {
                    private static final long serialVersionUID = 1L;

                    @Override
                    public Iterator<String> getObject()
                    {
                        return Arrays.asList("foo", "bar", "baz").iterator();
                    }
                });
            }
        });
        builder.addProxyTypes(Cloneable.class, Marker.class);
        StubInterface stub = builder.build();
        assertTrue(stub instanceof Iterable<?>);
        assertTrue(stub instanceof Cloneable);
        assertTrue(stub instanceof Marker);
    }

    //----------------------------------------------------------------------------------------------------------------------
    // Inner Classes
    //----------------------------------------------------------------------------------------------------------------------

    private static class SimpleStub implements StubInterface
    {
        @Override
        public String one(String value)
        {
            return value;
        }

        @Override
        public String three(String arg1, String arg2)
        {
            return arg1 + arg2;
        }

        @Override
        public String two(String value)
        {
            return StringUtils.repeat(value, 2);
        }

        @Override
        public byte[] byteArray()
        {
            return new byte[] { 1, 2, 3 };
        }

        @Override
        public char[] charArray()
        {
            return new char[] { '1', '2', '3' };
        }

        @Override
        public short[] shortArray()
        {
            return new short[] { 1, 2, 3 };
        }

        @Override
        public int[] intArray()
        {
            return new int[] { 1, 2, 3 };
        }

        @Override
        public long[] longArray()
        {
            return new long[] { 1, 2, 3 };
        }

        @Override
        public float[] floatArray()
        {
            return new float[] { 1.0f, 2.0f, 3.0f };
        }

        @Override
        public double[] doubleArray()
        {
            return new double[] { 1.0, 2.0, 3.0 };
        }

        @Override
        public boolean[] booleanArray()
        {
            return new boolean[] { true, false, true };
        }

        @Override
        public String[] stringArray()
        {
            return new String[] { "One", "Two", "Three" };
        }

        @Override
        public String arrayParameter(String... strings)
        {
            return StringUtils.join(strings, ", ");
        }

        @Override
        public void voidMethod(String arg)
        {

        }

        @Override
        public StubInterface stub()
        {
            return null;
        }

        @Override
        public StubInterface[] stubs()
        {
            return new StubInterface[0];
        }
    }

    public interface Marker
    {
    }
}