package org.wamblee.system.spring;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import junit.framework.TestCase;

import org.wamblee.io.ClassPathResource;
import org.wamblee.system.DefaultProvidedInterface;
import org.wamblee.system.DefaultRequiredInterface;
import org.wamblee.system.ProvidedInterface;
import org.wamblee.system.RequiredInterface;
import org.wamblee.system.SystemAssemblyException;

public class SpringComponentTest extends TestCase {

	private static final String HELLO_SERVICE_SPRING_XML = "test.org.wamblee.system.spring.xml";
	private static final String HELLO_SERVICE_SPRING_WITH_REQS_XML = "test.org.wamblee.system.springWithRequirements.xml";
	private static final String HELLO_SERVICE_SPRING_WITH_PROPERTIES_XML = "test.org.wamblee.system.springWithProperties.xml";
    private static final String PROPERTY_FILE = "test.org.wamblee.system.spring.properties";

	@Override
	protected void setUp() throws Exception {
		super.setUp();
	}

	public void testBlackboxSystem() {
		SpringComponent system = new SpringComponent("system",
				new String[] { HELLO_SERVICE_SPRING_XML },
				new HashMap<String, ProvidedInterface>(),
				new HashMap<RequiredInterface, String>());
		system.start("Hello");
		ProvidedInterface[] services = system.getRunningServices();
		assertEquals(0, services.length);
		
		system.stop();
	}

	public void testOneProvidedService() {
		Map<String, ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
		provided.put("helloService", new DefaultProvidedInterface(
				"hello", HelloService.class));

		SpringComponent system = new SpringComponent("system", 
				new String[] { HELLO_SERVICE_SPRING_XML }, provided,
				new HashMap<RequiredInterface, String>());
		system.start("Hello");
		ProvidedInterface[] services = system.getRunningServices();
		assertEquals(1, services.length);
		assertTrue(services[0].getImplementation() instanceof HelloService);
		assertEquals("Hello world!", ((HelloService)services[0].getImplementation())
				.say());
		system.stop();
	}
	
	public void testWithProperties() throws IOException {
		Map<String, ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
		provided.put("helloService", new DefaultProvidedInterface(
				"hello", HelloService.class));
		SpringComponent system = new SpringComponent("system", 
				new String[] { HELLO_SERVICE_SPRING_WITH_PROPERTIES_XML },
				provided,
				new HashMap<RequiredInterface, String>());
		Properties props = new Properties();
		props.load(new ClassPathResource(PROPERTY_FILE).getInputStream());
		system.addProperties(props);
		
		system.start("Hello");
		ProvidedInterface[] services = system.getRunningServices();
		assertEquals("Property Value", 
				((HelloService)services[0].getImplementation()).say());
	}

	public void testWithMissingRequirement() {
		try {
			SpringComponent system = new SpringComponent("system",
					new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML },
					new HashMap<String, ProvidedInterface>(),
					new HashMap<RequiredInterface, String>());
			system.start("Bla");
		} catch (SystemAssemblyException e) {
			//e.printStackTrace();
			return;
		}
		fail();
	}

	public void testWithRequirement() {
		Map<RequiredInterface, String> required = new HashMap<RequiredInterface, String>();
		required.put(new DefaultRequiredInterface("hello", HelloService.class),
				"helloService");
		SpringComponent system = new SpringComponent("system",
				new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML },
				new HashMap<String, ProvidedInterface>(), required);
		
		HelloService helloObject = new HelloService("ladida"); 
		ProvidedInterface helloService = new DefaultProvidedInterface("hello", HelloService.class);
		helloService.publish(helloObject);
		system.getRequiredServices()[0].setProvider(helloService);
		
		system.start("Bla");
		system.stop();
	}
	
	public void testWithRequirementAndProvidedService() {
		Map<RequiredInterface, String> required = new HashMap<RequiredInterface, String>();
		required.put(new DefaultRequiredInterface("hello", HelloService.class),
				"helloService");
		Map<String,ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
		provided.put("blaService", new DefaultProvidedInterface("bla",
				BlaService.class));

		SpringComponent system = new SpringComponent("system",
				new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML },
				provided, required);
		
		HelloService helloObject = new HelloService("ladida"); 
		ProvidedInterface helloService = 
			new DefaultProvidedInterface("hello", HelloService.class);
		helloService.publish(helloObject);
		system.getRequiredServices()[0].setProvider(helloService);
		system.start("Bla");
		ProvidedInterface started = system.getProvidedServices()[0];
		
	    assertNotNull(started.getImplementation());
	    assertTrue(started.getImplementation() instanceof BlaService);
		assertEquals("ladida", 
				((BlaService)started.getImplementation()).execute());
		system.stop();
	}

}