/*
 * 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 java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.sql.DataSource;

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;

public class SetterConfigurationTest extends AdapterTestCase {

	public void testOneSetter() {
		SetterConfiguration config = new SetterConfiguration(X5.class);
		config.initAllSetters();
		List<RequiredInterface> required = config.getRequiredInterfaces();
		assertEquals(1, required.size());
		assertEquals("setValue", 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());
	}

	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", required.get(0).getName());
		assertEquals("setXyz", 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());
	}

	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", required.get(0).getName());
		assertEquals("setValue", required.get(1).getName());
		assertEquals("setXyz", 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());
	}

	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", required.get(0).getName());
		assertEquals("setPort", 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());
	}

	public void testInvokeWrongType() {
		final SetterConfiguration config = new SetterConfiguration(X5.class).initAllSetters();
		List<RequiredInterface> required = config.getRequiredInterfaces();
		assertEquals(1, required.size());
		assertEquals("setValue", 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);
	}

	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());
	}

	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());
	}

	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", 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());
	}
	
	public void testAddByType() { 
		SetterConfiguration config = new SetterConfiguration(X6.class);
		config.clear().add(String.class);
		List<RequiredInterface> required = config.getRequiredInterfaces();
		Collections.sort(required, new RequiredInterfaceComparator());
		assertEquals(1, required.size());
		assertEquals("setHost", 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());
	}
	
	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());
	}

	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.add(DataSource.class);
			}
		}, IllegalArgumentException.class);
	}
	
	public void testAddByTypeNonUnique() { 
		final SetterConfiguration config = new SetterConfiguration(X11.class);
		config.clear();
		AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
			@Override
			public void run() throws Exception {
				config.add(String.class);
			}
		}, IllegalArgumentException.class);
	}

	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", 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());
	}

	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);
	}
	
	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());
		}
		
	}
}