/*
 * Copyright 2008 the original author or authors.
 *
 * Licensed 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.wamblee.system.adapters;

import org.wamblee.system.core.DefaultProvidedInterface;
import org.wamblee.system.core.ProvidedInterface;
import org.wamblee.system.core.RequiredInterface;
import org.wamblee.system.core.RequiredInterfaceComparator;

import org.wamblee.test.AssertionUtils;

import java.lang.reflect.Method;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.sql.DataSource;


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
  */
public class SetterConfigurationTest extends AdapterTestCase {
    /**
     * DOCUMENT ME!
     */
    public void testOneSetter() {
        SetterConfiguration config = new SetterConfiguration(X5.class);
        config.initAllSetters();

        List<RequiredInterface> required = config.getRequiredInterfaces();
        assertEquals(1, required.size());
        assertEquals("setValue.0", required.get(0).getName());

        ProvidedInterface provided = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided);
        scope.publishInterface(provided, "hello");

        X5 obj = new X5();
        assertNull(obj.getValue());
        config.inject(scope, obj);
        assertEquals("hello", obj.getValue());
    }

    /**
     * DOCUMENT ME!
     */
    public void testPrivateSetter() {
        SetterConfiguration config = new SetterConfiguration(X5.class);
        config.setNonPublic(true);
        config.initAllSetters();

        List<RequiredInterface> required = new ArrayList<RequiredInterface>(config
                .getRequiredInterfaces());
        Collections.sort(required,
            new Comparator<RequiredInterface>() {
                @Override
                public int compare(RequiredInterface aO1, RequiredInterface aO2) {
                    return aO1.getName().compareTo(aO2.getName());
                }
            });
        assertEquals(2, required.size());
        assertEquals("setValue.0", required.get(0).getName());
        assertEquals("setXyz.0", required.get(1).getName());

        ProvidedInterface providedString = new DefaultProvidedInterface("janse",
                String.class);
        assertTrue(required.get(0).implementedBy(providedString));
        required.get(0).setProvider(providedString);
        scope.publishInterface(providedString, "hello");

        ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
                Integer.class);
        assertTrue(required.get(1).implementedBy(providedInt));
        required.get(1).setProvider(providedInt);
        scope.publishInterface(providedInt, 100);

        X5 obj = new X5();
        assertNull(obj.getValue());
        assertNull(obj.getXyz());
        config.inject(scope, obj);
        assertEquals("hello", obj.getValue());
        assertEquals(100, obj.getXyz().intValue());
    }

    /**
     * DOCUMENT ME!
     */
    public void testInheritance() {
        SetterConfiguration config = new SetterConfiguration(X9.class);
        config.setNonPublic(true);
        config.initAllSetters();

        List<RequiredInterface> required = new ArrayList<RequiredInterface>(config
                .getRequiredInterfaces());
        Collections.sort(required,
            new Comparator<RequiredInterface>() {
                @Override
                public int compare(RequiredInterface aO1, RequiredInterface aO2) {
                    return aO1.getName().compareTo(aO2.getName());
                }
            });
        assertEquals(3, required.size());
        assertEquals("setFlag.0", required.get(0).getName());
        assertEquals("setValue.0", required.get(1).getName());
        assertEquals("setXyz.0", required.get(2).getName());

        ProvidedInterface providedBoolean = new DefaultProvidedInterface("janse",
                Boolean.class);
        assertTrue(required.get(0).implementedBy(providedBoolean));
        required.get(0).setProvider(providedBoolean);
        scope.publishInterface(providedBoolean, true);

        ProvidedInterface providedString = new DefaultProvidedInterface("janse",
                String.class);
        assertTrue(required.get(1).implementedBy(providedString));
        required.get(1).setProvider(providedString);
        scope.publishInterface(providedString, "hello");

        ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
                Integer.class);
        assertTrue(required.get(2).implementedBy(providedInt));
        required.get(2).setProvider(providedInt);
        scope.publishInterface(providedInt, 100);

        X9 obj = new X9();
        assertNull(obj.getValue());
        assertNull(obj.getXyz());
        assertFalse(obj.isFlag());
        config.inject(scope, obj);
        assertEquals("hello", obj.getValue());
        assertEquals(100, obj.getXyz().intValue());
        assertTrue(obj.isFlag());
    }

    /**
     * DOCUMENT ME!
     */
    public void testMultipleSetters() {
        SetterConfiguration     config   = new SetterConfiguration(X6.class)
            .initAllSetters();
        List<RequiredInterface> required = config.getRequiredInterfaces();
        Collections.sort(required, new RequiredInterfaceComparator());
        assertEquals(2, required.size());
        assertEquals("setHost.0", required.get(0).getName());
        assertEquals("setPort.0", required.get(1).getName());

        ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided0);
        scope.publishInterface(provided0, "hello");

        ProvidedInterface provided1 = new DefaultProvidedInterface("port",
                Integer.class);
        required.get(1).setProvider(provided1);
        scope.publishInterface(provided1, 10);

        X6 obj = new X6();
        assertNull(obj.getHost());
        assertNull(obj.getPort());

        config.inject(scope, obj);
        assertEquals("hello", obj.getHost());
        assertEquals(10, obj.getPort().intValue());
    }

    /**
     * DOCUMENT ME!
     */
    public void testInvokeWrongType() {
        final SetterConfiguration config   = new SetterConfiguration(X5.class)
            .initAllSetters();
        List<RequiredInterface>   required = config.getRequiredInterfaces();
        assertEquals(1, required.size());
        assertEquals("setValue.0", required.get(0).getName());

        ProvidedInterface provided = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided);
        scope.publishInterface(provided, "hello");

        final X6 obj = new X6();
        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                @Override
                public void run() throws Exception {
                    config.inject(scope, obj);
                }
            }, IllegalArgumentException.class);
    }

    /**
     * DOCUMENT ME!
     */
    public void testSetExplicitValue() {
        SetterConfiguration config = new SetterConfiguration(X5.class)
            .initAllSetters();
        config.values("setValue").setValue(0, "bladibla");

        List<RequiredInterface> required = config.getRequiredInterfaces();
        assertEquals(0, required.size());

        X5 obj = new X5();
        assertNull(obj.getValue());
        config.inject(scope, obj);
        assertEquals("bladibla", obj.getValue());
    }

    /**
     * DOCUMENT ME!
     */
    public void testClear() {
        SetterConfiguration config = new SetterConfiguration(X6.class);
        config.clear();

        List<RequiredInterface> required = config.getRequiredInterfaces();
        Collections.sort(required, new RequiredInterfaceComparator());
        assertEquals(0, required.size());

        X6 obj = new X6();
        assertNull(obj.getHost());
        assertNull(obj.getPort());

        config.inject(scope, obj);

        assertNull(obj.getHost());
        assertNull(obj.getPort());
    }

    /**
     * DOCUMENT ME!
     */
    public void testAddByName() {
        SetterConfiguration config = new SetterConfiguration(X6.class);
        config.clear().add("setHost");

        List<RequiredInterface> required = config.getRequiredInterfaces();
        Collections.sort(required, new RequiredInterfaceComparator());
        assertEquals(1, required.size());
        assertEquals("setHost.0", required.get(0).getName());

        ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided0);
        scope.publishInterface(provided0, "hello");

        X6 obj = new X6();
        assertNull(obj.getHost());
        assertNull(obj.getPort());

        config.inject(scope, obj);
        assertEquals("hello", obj.getHost());
        assertNull(obj.getPort());
    }

    /**
     * DOCUMENT ME!
     */
    public void testAddByType() {
        SetterConfiguration config = new SetterConfiguration(X6.class);
        config.clear().addSetter(String.class);

        List<RequiredInterface> required = config.getRequiredInterfaces();
        Collections.sort(required, new RequiredInterfaceComparator());
        assertEquals(1, required.size());
        assertEquals("setHost.0", required.get(0).getName());

        ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided0);
        scope.publishInterface(provided0, "hello");

        X6 obj = new X6();
        assertNull(obj.getHost());
        assertNull(obj.getPort());

        config.inject(scope, obj);
        assertEquals("hello", obj.getHost());
        assertNull(obj.getPort());
    }

    /**
     * DOCUMENT ME!
     */
    public void testAddPrivate() {
        X5                        obj    = new X5();
        final SetterConfiguration config = new SetterConfiguration(X5.class);
        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                @Override
                public void run() throws Exception {
                    config.add("xyz");
                }
            }, IllegalArgumentException.class);

        config.setNonPublic(true);
        config.clear();
        config.add("setXyz");
        assertEquals(1, config.getRequiredInterfaces().size());
    }

    /**
     * DOCUMENT ME!
     */
    public void testAddNonExisting() {
        final SetterConfiguration config = new SetterConfiguration(X6.class);
        config.clear();

        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                @Override
                public void run() throws Exception {
                    config.add("bladibla");
                }
            }, IllegalArgumentException.class);
        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                @Override
                public void run() throws Exception {
                    config.addSetter(DataSource.class);
                }
            }, IllegalArgumentException.class);
    }

    /**
     * DOCUMENT ME!
     */
    public void testAddByTypeNonUnique() {
        final SetterConfiguration config = new SetterConfiguration(X11.class);
        config.clear();
        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                @Override
                public void run() throws Exception {
                    config.addSetter(String.class);
                }
            }, IllegalArgumentException.class);
    }

    /**
     * DOCUMENT ME!
     */
    public void testRemove() {
        SetterConfiguration config = new SetterConfiguration(X6.class)
            .initAllSetters();
        config.remove("setPort");

        List<RequiredInterface> required = config.getRequiredInterfaces();
        Collections.sort(required, new RequiredInterfaceComparator());
        assertEquals(1, required.size());
        assertEquals("setHost.0", required.get(0).getName());

        ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided0);
        scope.publishInterface(provided0, "hello");

        X6 obj = new X6();
        assertNull(obj.getHost());
        assertNull(obj.getPort());

        config.inject(scope, obj);
        assertEquals("hello", obj.getHost());
        assertNull(obj.getPort());
    }

    /**
     * DOCUMENT ME!
     *
     * @throws NoSuchMethodException DOCUMENT ME!
     */
    public void testRemoveByMethodObject() throws NoSuchMethodException {
        SetterConfiguration config = new SetterConfiguration(X6.class)
            .initAllSetters();
        config.remove(X6.class.getMethod("setPort", Integer.class));

        List<RequiredInterface> required = config.getRequiredInterfaces();
        Collections.sort(required, new RequiredInterfaceComparator());
        assertEquals(1, required.size());
        assertEquals("setHost.0", required.get(0).getName());

        ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                String.class);
        required.get(0).setProvider(provided0);
        scope.publishInterface(provided0, "hello");

        X6 obj = new X6();
        assertNull(obj.getHost());
        assertNull(obj.getPort());

        config.inject(scope, obj);
        assertEquals("hello", obj.getHost());
        assertNull(obj.getPort());
    }

    /**
     * DOCUMENT ME!
     */
    public void testRemoveNonExisting() {
        final SetterConfiguration config = new SetterConfiguration(X6.class);

        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                @Override
                public void run() throws Exception {
                    config.remove("bladibla");
                }
            }, IllegalArgumentException.class);
    }

    /**
     * DOCUMENT ME!
     */
    public void testOverridingSetters() {
        SetterConfiguration config = new SetterConfiguration(X10.class)
            .initAllSetters();
        assertEquals(2, config.getRequiredInterfaces().size());

        List<Method> methods = config.getSetters();
        assertEquals(2, methods.size());

        for (Method method : methods) {
            assertEquals(X10.class, method.getDeclaringClass());
        }
    }
}