package org.neo.swarm.core.aop.silc.comp;
   
   import java.io.ByteArrayOutputStream;
   import java.io.ObjectOutputStream;
   import java.io.Serializable;
   import java.lang.reflect.Method;
   
   import junit.framework.TestCase;
   
  import org.aopalliance.intercept.MethodInvocation;
  import org.neo.swarm.core.aop.AspectComponent;
  
  public class AspectedComponentTest extends TestCase {
  	private TestInterceptor a;
  	private TestInterceptor b;
  	private TestInterceptor c;
  
  	protected void setUp() throws Exception {
  		a = new TestInterceptor("A");
  		b = new TestInterceptor("B");
  		c = new TestInterceptor("C");
  	}
  
  	public void testSomethingAboutTheMixin() throws Throwable {
  		Comp target = new Comp();
  		AspectComponent mixin = new AspectComponentImpl("dummyKey", target.getClass().getInterfaces(), target, new JavaDynamicProxyFactory());
  		addInterceptors(mixin);
  
  		A1 proxy = (A1) mixin.getProxy();
  		proxy.doA1();
  		assertions();
  		assertTrue(target.invoked);
  	}
  
  	private void assertions() {
  		assertTrue(a.invoked);
  		assertTrue(b.invoked);
  		assertTrue(c.invoked);
  	}
  
  	public void testCanGetAllInterfaceMethods() {
  		CompB b = new CompB();
  		AspectComponent ac = new AspectComponentImpl("dummyKey", b.getClass().getInterfaces(), b, new JavaDynamicProxyFactory());
  		Method [] m = ac.getInterfaceMethods();
  		assertEquals(4, m.length);
  	}
  
  	public void testMultipleInterfaces() throws Throwable {
  		CompB b = new CompB();
  		AspectComponent mixin = new AspectComponentImpl("dummyKey", b.getClass().getInterfaces(), b, new JavaDynamicProxyFactory());
  		addInterceptors(mixin);
  		Object proxy = mixin.getProxy();
  
  		// casts are to prove that the proxy does indeed implement multiple interfaces
  		((A1) proxy).doA1();
  		assertions();
  		assertTrue(b.a1);
  		reset();
  
  
  		((A2) proxy).doA2();
  		assertions();
  		assertTrue(b.a2);
  		reset();
  
  		((B1) proxy).doB1();
  		assertions();
  		assertTrue(b.b1);
  		reset();
  
  		((B2) proxy).doB2();
  		assertions();
  		assertTrue(b.b2);
  
  	}
  
  	public void testOnlyImplementsSuppliedInterfaces() throws Throwable {
  		CompB b = new CompB();
  		AspectComponent mixin = new AspectComponentImpl("dummyKey", new Class[]{A1.class, A2.class, B1.class}, b, new JavaDynamicProxyFactory());
  		addInterceptors(mixin);
  		Object proxy = mixin.getProxy();
  
  		((A1) proxy).doA1();
  		assertions();
  		assertTrue(b.a1);
  		reset();
  
  		((A2) proxy).doA2();
  		assertions();
  		assertTrue(b.a2);
  		reset();
  
  		((B1) proxy).doB1();
  		assertions();
  		assertTrue(b.b1);
  		reset();
  
  		try {
  			((B2) proxy).doB2();
 			fail();
 		} catch (ClassCastException cce) {
 
 		}
 
 	}
 
 	public void testCanHaveInterceptorsAppliedToDifferentMethods() throws Exception {
 		CompC comp = new CompC();
 
 		AspectComponent mixin = new AspectComponentImpl("dummyKey", new Class[]{C1.class}, comp, new JavaDynamicProxyFactory());
 		// apply to all
 		mixin.addInterceptor(Perspective.DEFAULT, a);
 		// apply to only this method
 		mixin.addInterceptor(Perspective.DEFAULT, C1.class.getMethod("doC1", null), b);
 		mixin.addInterceptor(Perspective.DEFAULT, C1.class.getMethod("doC1Again", null), c);
 
 		C1 proxy = (C1) mixin.getProxy();
 
 		proxy.doC1();
 		assertTrue(a.invoked);
 		assertTrue(b.invoked);
 		assertFalse(c.invoked);
 		reset();
 
 		proxy.doC1Again();
 		assertTrue(a.invoked);
 		assertFalse(b.invoked);
 		assertTrue(c.invoked);
 	}
 
 	/***
 	 *
 	 * @throws Exception
 	 */
 	public void testComponentsAreSerializable() throws Exception  {
 		CompC comp = new CompC();
 		AspectComponent mixin = new AspectComponentImpl("dummyKey", new Class[]{C1.class}, comp, new JavaDynamicProxyFactory());
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		ObjectOutputStream os = new ObjectOutputStream(baos);
 		os.writeObject(mixin);
 	}
 
 	
 	public void testWeCanAssociateDifferentPerspectivesWithAComponent() throws Exception {
 		Comp target = new Comp();
 		TestInterceptor tInterceptor = new TestInterceptor("TestPerspective1");
 		AspectComponent mixin = new AspectComponentImpl("dummyKey", target.getClass().getInterfaces(), target, new JavaDynamicProxyFactory());
 		mixin.addInterceptor(Perspective.REMOTE, tInterceptor);
 		mixin.addInterceptor(Perspective.REMOTE, new TestInterceptor("Test Perspective2"));
 		mixin.addInterceptor(Perspective.DEFAULT,  new TestInterceptor("Default Perspective1"));
 		mixin.addInterceptor(Perspective.DEFAULT,  new TestInterceptor("Default Perspective2"));
 		A1  comp1 = (A1) mixin.getProxy();
 		A1 comp2 = (A1) mixin.getProxy(Perspective.REMOTE);
 		comp1.doA1();
 		comp2.doA1();
 		assertEquals(1, tInterceptor.count);
 	}
 	
 	private void reset() {
 		a.invoked = false;
 		b.invoked = false;
 		c.invoked = false;
 	}
 
 	private void addInterceptors(AspectComponent mixin) {
 		mixin.addInterceptor(Perspective.DEFAULT, a);
 		mixin.addInterceptor(Perspective.DEFAULT, b);
 		mixin.addInterceptor(Perspective.DEFAULT, c);
 	}
 
 	static class TestInterceptor implements MethodInterceptor {
 		private String name;
 
 		boolean invoked;
 		int count = 0;
 
 		public TestInterceptor(String name) {
 			this.name = name;
 		}
 
 		public Object invoke(MethodInvocation invocation) throws Throwable {
 			System.out.println("invoked interceptor: " + name);
 			invoked = true;
 			count++;
 			return invocation.proceed();
 		}
 	}
 	
 	static interface MyInterceptorClassification {
 	}
 	static class TestInterceptor2 implements MethodInterceptor, MyInterceptorClassification {
 		private String name;
 
 		boolean invoked;
 
 		public TestInterceptor2(String name) {
 			this.name = name;
 		}
 
 		public Object invoke(MethodInvocation invocation) throws Throwable {
 			invoked = true;
 			return invocation.proceed();
 		}
 	}
 	
 	interface A1 {
 		void doA1();
 	}
 
 	interface A2 {
 		void doA2();
 	}
 
 	interface B1 {
 		void doB1();
 	}
 
 	interface B2 {
 		void doB2();
 	}
 
 	static class Comp implements A1 {
 		boolean invoked;
 
 		public void doA1() {
 			invoked = true;
 			System.out.println("Comp was invoked");
 		}
 	}
 
 	static class CompB implements A1, A2, B1, B2 {
 		boolean a1;
 		boolean a2;
 		boolean b1;
 		boolean b2;
 		private boolean compB;
 
 		public void doA1() {
 			a1 = true;
 		}
 
 		public void doA2() {
 			a2 = true;
 		}
 
 		public void doB1() {
 			b1 = true;
 		}
 
 		public void doB2() {
 			b2 = true;
 		}
 
 		public void doCompB() {
 			compB = true;
 		}
 
 	}
 
 	interface C1 {
 		void doC1();
 
 		void doC1Again();
 
 	}
 
 	static class CompC implements C1, Serializable  {
 		public void doC1() {
 		}
 
 		public void doC1Again() {
 		}
 
 	}
 }