/*
 * Copyright 2007 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;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;

import org.wamblee.system.Component.Status;
import org.wamblee.test.AssertionUtils;
import org.wamblee.test.EventTracker;

import junit.framework.TestCase;

public class ContainerTest extends TestCase {

	private EventTracker<String> _tracker;

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		_tracker = new EventTracker<String>();
	}

	private static class MyMultiple implements Serializable, Runnable {
		@Override
		public void run() {
			// Empty
		}
	}

	public void testFilterProvided() {
		RequiredInterface req1 = new DefaultRequiredInterface("name",
				Runnable.class);
		RequiredInterface req2 = new DefaultRequiredInterface("name",
				Serializable.class);
		ProvidedInterface prov1 = new DefaultProvidedInterface("name",
				Runnable.class);
		ProvidedInterface prov2 = new DefaultProvidedInterface("name",
				Serializable.class);
		ProvidedInterface prov3 = new DefaultProvidedInterface("name",
				MyMultiple.class);

		AssertionUtils.assertEquals(new RequiredInterface[] { req1 },
				Container.filterRequiredServices(prov1, Arrays
						.asList(new RequiredInterface[] { req1 })));
		AssertionUtils.assertEquals(new RequiredInterface[] { req1 },
				Container.filterRequiredServices(prov1, Arrays
						.asList(new RequiredInterface[] { req1, req2 })));
		AssertionUtils.assertEquals(new RequiredInterface[] { req1, req2 },
				Container.filterRequiredServices(prov3, Arrays
						.asList(new RequiredInterface[] { req1, req2 })));

		AssertionUtils.assertEquals(new ProvidedInterface[] { prov1 },
				Container.filterProvidedServices(req1, Arrays
						.asList(new ProvidedInterface[] { prov1 })));
		AssertionUtils.assertEquals(new ProvidedInterface[] { prov1 },
				Container.filterProvidedServices(req1, Arrays
						.asList(new ProvidedInterface[] { prov1, prov2 })));
		AssertionUtils.assertEquals(new ProvidedInterface[] { prov1, prov3 },
				Container.filterProvidedServices(req1, Arrays
						.asList(new ProvidedInterface[] { prov1, prov3 })));
	}

	public void testEnvironmentApplication() {
		Component environment = new Environment(_tracker);
		Component application = new Application(_tracker);
		Container container = new Container("root", new Component[] {
				environment, application }, new ProvidedInterface[0],
				new RequiredInterface[0]);
				
		container.start();
		AssertionUtils.assertEquals(new String[] { "start.environment",
				"start.application" }, _tracker.getEvents(
				Thread.currentThread()).toArray(new String[0]));
		ProvidedInterface[] envServices = environment.getRunningServices();
		assertEquals(2, envServices.length);
		ProvidedInterface[] appServices = environment.getRunningServices();
		assertEquals(2, appServices.length);
		
	}

	public void testApplicationEnvironment() {
		try {
			Component environment = new Environment();
			Component application = new Application();
			Container container = new Container(
					"root",
					new Component[] {
					application, environment }, 
					new ProvidedInterface[0], new RequiredInterface[0]);
			container.start();
		} catch (SystemAssemblyException e) {
			// e.printStackTrace();
			return;
		}
		fail();
	}

	public void testComposite() {
		Component environment = new Environment(_tracker);
		Component application = new Application(_tracker);
		assertEquals(0, _tracker.getEventCount());
		assertEquals(Status.NOT_STARTED, environment.getStatus());
		assertEquals(Status.NOT_STARTED, application.getStatus());
		
		Container system = new Container("all", new Component[] { environment,
				application }, new ProvidedInterface[0],
				new RequiredInterface[0]);
		assertEquals(Status.NOT_STARTED, system.getStatus());
		system.start();
		RequiredInterface[] required = system.getRequiredServices();
		assertEquals(0, required.length);
		ProvidedInterface[] provided = system.getProvidedServices();
		assertEquals(0, provided.length);
		assertEquals(Status.RUNNING, environment.getStatus());
		assertEquals(Status.RUNNING, application.getStatus());
		assertEquals(Status.RUNNING, system.getStatus());
		
		AssertionUtils.assertEquals(
				new String[] { "start.environment", "start.application" }, 
				_tracker.getEvents(Thread.currentThread()).toArray(new String[0]));
        _tracker.clear();
		
		system.stop();
		assertEquals(Status.STOPPED, environment.getStatus());
		assertEquals(Status.STOPPED, application.getStatus());
		assertEquals(Status.STOPPED, system.getStatus());
		
		AssertionUtils.assertEquals(
				new String[] { "stop.application", "stop.environment" }, 
				_tracker.getEvents(Thread.currentThread()).toArray(new String[0]));
      
		
	}

	public void testCompositeWithWrongProvidedInfo() {
		try {
			Component environment = new Environment();
			Component application = new Application();
			Container system = new Container("all", new Component[] {
					environment, application },
					new ProvidedInterface[] { new DefaultProvidedInterface(
							"string", String.class) },
					new DefaultRequiredInterface[0]);
		} catch (SystemAssemblyException e) {
			return;
		}
		fail();
	}

	public void testCompositeRequiredInterfaceNotProvided() {
		try {
			Component environment = new Environment();
			Component application = new Application();
			Container system = new Container("all", new Component[] {
					environment, application }, new ProvidedInterface[0],
					new RequiredInterface[] { new DefaultRequiredInterface(
							"string", String.class) });
			system.start();
		} catch (SystemAssemblyException e) {
			return;
		}
		fail();
	}

	public void testCompositeWithSuperfluousRequiredInfo() {
		Component environment = new Environment();
		Component application = new Application();
		Container system = new Container("all", new Component[] { environment,
				application }, new ProvidedInterface[0],
				new RequiredInterface[] { new DefaultRequiredInterface(
						"string", String.class) });
		system.getRequiredServices()[0]
				.setProvider(new DefaultProvidedInterface("hallo", String.class));
		system.start();
		RequiredInterface[] required = system.getRequiredServices();
		assertEquals(1, required.length);
		ProvidedInterface[] provided = system.getProvidedServices();
		assertEquals(0, provided.length);
	}

	public void testCompositeWithExternalDependencesNotProvided() {
		try {
			Component environment = new Environment();
			Component application = new Application();
			Container system = new Container("all",
					new Component[] { application }, new ProvidedInterface[0],
					application.getRequiredServices());
			system.start();
		} catch (SystemAssemblyException e) {
			return;
		}
		fail();

	}

	public void testCompositeWithExternalDependencesProvided() {

		Component environment = new Environment();
		Component application = new Application();
		Container system = new Container("all",
				new Component[] { application }, new ProvidedInterface[0],
				application.getRequiredServices());
		environment.start();
		system.getRequiredServices()[0].setProvider(environment
				.getProvidedServices()[0]);
		system.getRequiredServices()[1].setProvider(environment
				.getProvidedServices()[1]);

		system.start();
		RequiredInterface[] required = system.getRequiredServices();
		assertEquals(2, required.length);
		ProvidedInterface[] provided = system.getProvidedServices();
		assertEquals(0, provided.length);

	}

	public void testAmbiguousInterfaces() {
		try {
			Component environment1 = new Environment();
			Component environment2 = new Environment();
			Component application = new Application();
			Container container = new Container("root", new Component[] {
					environment1, environment2, application },
					new ProvidedInterface[0], new RequiredInterface[0]);
			container.start();

		} catch (SystemAssemblyException e) {
			return;
		}
		fail();
	}

	public void testIncompleteRequirements() {
		try {
			Component application = new Application();
			Container system = new Container("all",
					new Component[] { application }, new ProvidedInterface[0],
					new RequiredInterface[0]);
			system.start();
		} catch (SystemAssemblyException e) {
			return;
		}
		fail();
	}

}