/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


package com.nokia.carbide.remoteconnections.tests;

import com.nokia.carbide.remoteconnections.RemoteConnectionsActivator;
import com.nokia.carbide.remoteconnections.interfaces.*;
import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus;
import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatusChangedListener;
import com.nokia.carbide.remoteconnections.internal.registry.Registry;
import com.nokia.carbide.remoteconnections.tests.extensions.*;

import java.util.Collection;
import java.util.Map;

import junit.framework.TestCase;

/**
 *
 */
public class ServiceTest extends TestCase {

	private IntervalConnection connection;
	private RandomCycleConnectedService connectedService;
	
	protected void setUp() throws Exception {
		super.setUp();
		TestFilter.isTest = true;
		Registry.instance().loadExtensions();
		IConnectionType ct = RemoteConnectionsActivator.getConnectionTypeProvider().getConnectionType(IntervalConnectionType.class.getName());
		IConnectionFactory cf = ct.getConnectionFactory();
		assertNotNull(cf);
		Map<String, String> settings = cf.getSettingsFromUI();
		IConnection c = cf.createConnection(settings);
		assertTrue(c instanceof IntervalConnection);
		connection = (IntervalConnection) c;
		connection.setIdentifier("Connection 1");
		RemoteConnectionsActivator.getConnectionsManager().addConnection(connection);
		Collection<IService> services = RemoteConnectionsActivator.getConnectionTypeProvider().getCompatibleServices(ct);
		assertNotNull(services);
		assertFalse(services.isEmpty());
		assertEquals(2, services.size());
		IService service = services.iterator().next();
		IConnectedService s = Registry.instance().createConnectedService(service, connection);
		assertTrue(s instanceof RandomCycleConnectedService);
		connectedService = (RandomCycleConnectedService) s;
	}

	protected void tearDown() throws Exception {
		super.tearDown();
		RemoteConnectionsActivator.getConnectionsManager().removeConnection(connection);
		connectedService.dispose();
		connection.dispose();
	}
	
	public void testCycleStates() throws Exception {
		boolean isOK = testCycleForInterval(connection.getInterval());
		assertFalse(isOK);
		isOK = testCycleForInterval(connection.getInterval());
		assertTrue(isOK);
		isOK = testCycleForInterval(connection.getInterval());
		assertFalse(isOK);
	}
	
	private boolean testCycleForInterval(int interval) throws Exception {
		final boolean isOK[] = { false };
		connectedService.addStatusChangedListener(new IStatusChangedListener() {
			public void statusChanged(IStatus status) {
				if (status.getEStatus().equals(IStatus.EStatus.UP)) {
					isOK[0] = true;
				}
			}
		});
		if (connectedService.getService().isTestable())
			connectedService.testStatus();
		Thread.sleep(interval);
		return isOK[0];
	}
	
	public void testMultTestStatusNoDeadlock() {
		for (int i = 0; i < 1000; i++) {
			connectedService.testStatus();
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public void testGetStatusEquals() {
		connectedService.addStatusChangedListener(new IStatusChangedListener() {
			public void statusChanged(IStatus status) {
				assertEquals(connectedService.getStatus(), status);
				assertFalse(new RandomCycleConnectedService.TestStatus(status.getConnectedService(), 
						IStatus.EStatus.UNKNOWN).equals(status));
			}
		});
		connectedService.testStatus();
	}
}