/*
* Copyright (c) 2009 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.tcf.impl;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.service.datalocation.Location;

import com.nokia.tcf.api.ITCAPIConnection;
import com.nokia.tcf.api.ITCConnection;
import com.nokia.tcf.api.ITCErrorListener;
import com.nokia.tcf.api.ITCMessage;
import com.nokia.tcf.api.ITCRealSerialConnection;
import com.nokia.tcf.api.ITCRealTCPConnection;
import com.nokia.tcf.api.ITCVirtualSerialConnection;
import com.nokia.tcf.api.TCFClassFactory;
import com.nokia.tcf.api.ITCMessageIds;
import com.nokia.tcf.api.ITCMessageInputStream;
import com.nokia.tcf.api.ITCMessageOptions;
import com.nokia.tcf.api.ITCVersion;
import com.nokia.tcf.Activator;
import com.nokia.tcf.api.TCErrorConstants;

public class TCAPIConnection implements ITCAPIConnection {

	static {
		Activator plugin = Activator.getDefault();
		IPath path = null;
		String dePath = null;
		if (plugin != null)
			path = plugin.getDebuggerPath();
		if (path != null)
			dePath = path.toOSString();
		if (dePath == null) {
			System.loadLibrary("TCFClient");
		} else {
			try{
				System.load(dePath + java.io.File.separator + "TCFClient.dll");
			} catch (UnsatisfiedLinkError e) {
				// if Carbide DLL is not found in DE, 
				// try to load one from the plugin itself
				System.loadLibrary("TCFClient");
			}
		}
	}
	private TCErrorListenerList<ITCErrorListener> errorListenerList;
	private ITCCookie cookie;		// this client's handle to native
	private ITCMessageIds messageIds; // this client's message ids
	private TCMessageInputStream inputStream; // this client's message input stream (not using message file)
	protected ITCMessageOptions messageOptions; // this client's message options
	private TCFMonitorThread monitorThread; // the client's native monitor
	public boolean stopTCFMonitorThread;	//  stream monitor start/stop flag
	protected IStatus statusOK;
	protected ITCConnection connection; // the client's connection

	public ITCConnection getConnection() {
		return this.connection;
	}
	public ITCMessageOptions getMessageOptions() {
		return this.messageOptions;
	}
	/**
	 * Only constructor - fields are created using the public methods
	 */
	public TCAPIConnection() {
		super();
		this.errorListenerList = new TCErrorListenerList<ITCErrorListener>();
		this.errorListenerList.clear();
		this.connection = null;
		IStatus status = new Status(Status.OK, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_NONE, "OK", null);
		statusOK = status;
		this.cookie = new TCCookie(-1, status, false, false);
		this.inputStream = null;
		this.messageIds = null;
		this.messageOptions = null;
		this.monitorThread = null;
		this.stopTCFMonitorThread = false;
	}

	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#addErrorListener(com.nokia.tcf.api.ITCErrorListener)
	 */
	public IStatus addErrorListener(ITCErrorListener inErrorListener) {
		IStatus status = statusOK;
		try {
			errorListenerList.add(inErrorListener);
		} catch (NullPointerException e) {
			int err = (int)TCErrorConstants.TCAPI_ERR_ERRLISTENER_NULL;
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, err,	TCErrorConstants.getErrorMessage(err), e);
		}
//		System.out.printf("addErrorListener status = %s\n", status.getMessage());
		return status;
	}

	private IStatus checkConnected() {
		IStatus status = statusOK;
		if (this.connection == null || this.cookie.isConnected() == false) {
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MEDIA_NOT_OPEN,
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MEDIA_NOT_OPEN), null);
		}
		return status;
	}
	protected IStatus checkDecodeFormat(String decodeFormat) {
		IStatus status = statusOK;
		return status;		
	}
	protected IStatus checkConnectionType(ITCConnection inConnection) {
		IStatus status = statusOK;
		int type = inConnection.getConnectionType();
		if (type == ITCConnection.MEDIA_VIRTUALSERIAL) {
			ITCVirtualSerialConnection c = (ITCVirtualSerialConnection)inConnection;
			String p = c.getComPort();
			if (p == null) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA, 
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA), null);
			}
		} else if (type == ITCConnection.MEDIA_REALTCP) {
			ITCRealTCPConnection c = (ITCRealTCPConnection)inConnection;
			String ip = c.getIpAddress();
			String p = c.getPort();
			if (ip == null || p == null) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA, 
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA), null);
			}
		} else if (type == ITCConnection.MEDIA_REALSERIAL) {
			ITCRealSerialConnection c = (ITCRealSerialConnection)inConnection;
			long err = checkRealSerialSettings(c);
			if (err != TCErrorConstants.TCAPI_ERR_NONE) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)err, TCErrorConstants.getErrorMessage(err), null);
			}
		} else {
			// Add other connection types here
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_UNKNOWN_MEDIA_TYPE,
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_UNKNOWN_MEDIA_TYPE), null);
		}
		
		return status;
	}
	private IStatus checkConnection(ITCConnection inConnection) {
		IStatus status = statusOK;
		if (this.cookie.isConnected()) {
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_ALREADY_CONNECTED, 
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_ALREADY_CONNECTED), null);
		}
		if (inConnection == null) {
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_CONNECTION_SPEC, 
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_CONNECTION_SPEC), null);
		}
		if (status.isOK()) {
			String decodeFormat = inConnection.getDecodeFormat();
			status = checkDecodeFormat(decodeFormat);
		}
		if (status.isOK()) {
			long retryI = inConnection.getRetryInterval();
			long retryT = inConnection.getRetryTimeout();
			if (retryI == 0 || retryT == 0 || retryI > retryT) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_RETRY_PERIODS, 
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_RETRY_PERIODS), null);
			}
		}
		
		if (status.isOK()) {
			status = checkConnectionType(inConnection);
		}
	
		return status;
	}
	private long checkRealSerialSettings(ITCRealSerialConnection c) {
		String[] setting = new String[6];
		setting[0] = c.getBaudRate();
		setting[1] = c.getComPort();
		setting[2] = c.getDataBits();
		setting[3] = c.getFlowControl();
		setting[4] = c.getParity();
		setting[5] = c.getStopBits();
		for (int i = 0; i < 6; i++) {
			if (setting[i] == null) {
				return TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA;
			}
		}
		if ((setting[2] != ITCRealSerialConnection.DATABITS_4) && (setting[2] != ITCRealSerialConnection.DATABITS_5) && (setting[2] != ITCRealSerialConnection.DATABITS_6) &&
				(setting[2] != ITCRealSerialConnection.DATABITS_7) && (setting[2] != ITCRealSerialConnection.DATABITS_8)) {
			return TCErrorConstants.TCAPI_ERR_COMM_INVALID_DATABITS;
		}
		if ((setting[3] != ITCRealSerialConnection.FLOWCONTROL_HW) && (setting[3] != ITCRealSerialConnection.FLOWCONTROL_NONE) && (setting[3] != ITCRealSerialConnection.FLOWCONTROL_SW)) {
			return TCErrorConstants.TCAPI_ERR_COMM_INVALID_FLOWCONTROL;
		}
		if ((setting[4] != ITCRealSerialConnection.PARITY_EVEN) && (setting[4] != ITCRealSerialConnection.PARITY_NONE) && (setting[4] != ITCRealSerialConnection.PARITY_ODD)) {
			return TCErrorConstants.TCAPI_ERR_COMM_INVALID_PARITY;
		}
		if ((setting[5] != ITCRealSerialConnection.STOPBITS_1) && (setting[5] != ITCRealSerialConnection.STOPBITS_1_5) && (setting[5] != ITCRealSerialConnection.STOPBITS_2)) {
			return TCErrorConstants.TCAPI_ERR_COMM_INVALID_STOPBITS;
		}
		
		return TCErrorConstants.TCAPI_ERR_NONE;
	}
	private IStatus checkMessage(ITCMessage inMessage) {
		IStatus status = statusOK;

		if (inMessage == null) {
			// inMessage cannot be null
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE,
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE), null);
		} else if (inMessage.size() == 0) {
			// bytes to send may be 0 if we're doing the header (header is the message)
			if (this.messageOptions.getMessageEncodeFormat() == ITCMessageOptions.ENCODE_NO_FORMAT) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE,
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE), null);
			}
		}
		if (status.isOK()) {
			// check options
			if (inMessage.isUseMyMessageId()) {
				if (this.messageOptions.getMessageEncodeFormat() == ITCMessageOptions.ENCODE_NO_FORMAT) {
					// use my id, but don't encode = error
					status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT,
							TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT), null);
				} else {
					// use my id, and encode = OK
				}
			} else {
				if (this.messageOptions.getMessageEncodeFormat() == ITCMessageOptions.ENCODE_NO_FORMAT) {
					// don't use my id, and don't encode = OK
				} else {
					// don't use my id, but encode = warning (we'll go ahead send this message raw)
					status = new Status(Status.WARNING, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT,
							TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT), null);
				}
			}
		}
		return status;
	}
	private IStatus checkMessageIds(ITCMessageIds inMessageIds) {
		IStatus status = statusOK;

		if (inMessageIds == null || inMessageIds.size() == 0) {
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_NO_MESSAGESIDS_REGISTERED,
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_NO_MESSAGESIDS_REGISTERED), null);
		}
		if (status.isOK()) {
			if (inMessageIds.size() > 256) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MESSAGEID_MAXIMUM,
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MESSAGEID_MAXIMUM), null);
			}
		}
		return status;
	}


	private IStatus checkMessageOptions(ITCMessageOptions inMessageOptions) {
		IStatus status = statusOK;

		if (inMessageOptions == null) {
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE_OPTIONS,
					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE_OPTIONS), null);
		}
//		if (status.isOK()) {
//			long option = inMessageOptions.getMessageDestination();
//			String file = inMessageOptions.getMessageFile().toOSString();
//			if (option == ITCMessageOptions.DESTINATION_CLIENTFILE) {
//				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_FEATURE_NOT_IMPLEMENTED,
//					TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_FEATURE_NOT_IMPLEMENTED), null);
//			}
//		}
		
		if (status.isOK()) {
			long option = inMessageOptions.getMessageEncodeFormat();
			switch ((int)option) {
			case (int)ITCMessageOptions.ENCODE_NO_FORMAT:
			case (int)ITCMessageOptions.ENCODE_FORMAT:
			case (int)ITCMessageOptions.ENCODE_TRK_FORMAT:
				break;
			default:
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_ENCODE_FORMAT,
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_ENCODE_FORMAT), null);
			}
		}
		if (status.isOK()) {
			long option = inMessageOptions.getUnWrapFormat();
			switch ((int)option) {
			case (int)ITCMessageOptions.UNWRAP_DELETE_HEADERS:
			case (int)ITCMessageOptions.UNWRAP_LEAVE_HEADERS:
				break;
			default:
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_MESSAGE_UNWRAP_OPTION,
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_MESSAGE_UNWRAP_OPTION), null);
			}
		}
		
		if (status.isOK()) {
			long bufferSize = inMessageOptions.getInputStreamSize();
			if (bufferSize <= 0) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_STREAM_BUFFER_SIZE,
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_STREAM_BUFFER_SIZE), null);
			}
		}
		
		return status;
	}

	protected IStatus checkConnectOptions(ITCConnection inConnection,
			ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
		
		IStatus status = statusOK;

		status = checkConnection(inConnection);
		
		if (status.isOK()) {
			status = checkMessageOptions(inMessageOptions);
		}
		if (status.isOK()) {
			status = checkMessageIds(inMessageIds);
		}
		return status;
	}
	protected IStatus finishConnect(int type, String[] settings, 
			ITCConnection inConnection, ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
		IStatus status = statusOK;
		// connect
		long[] clientId = new long[1];
		clientId[0] = -1;
		long[] options = new long[3];
		options[0] = inConnection.getRetryInterval();		// connection options
		options[1] = inConnection.getRetryTimeout();
		options[2] = 0;
		long[] moptions = new long[2];
		moptions[0] = inMessageOptions.getUnWrapFormat();
		moptions[1] = inMessageOptions.getOSTVersion();
		String filePath = null;
		if (inMessageOptions.getMessageDestination() == ITCMessageOptions.DESTINATION_CLIENTFILE) {
			filePath = inMessageOptions.getMessageFile().toOSString();
			try {
				ensureWritableFile(filePath);
			} catch (IOException e) {
				String msg = e.getMessage();
				long err = TCErrorConstants.TCAPI_ERR_CREATE_FILE;
				String tcErr = String.format("%s OSError: %s", TCErrorConstants.getErrorMessage(err), msg);
				status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, 
						(int)TCErrorConstants.TCAPI_ERR_CREATE_FILE, tcErr, e);
			}
		}
		
		try {
			long ret = nativeConnect(type, options, settings, moptions, filePath, clientId); 
			if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
				this.cookie.setClientId(clientId[0]);
				this.cookie.setConnected(true);
				this.connection = inConnection;
				this.messageOptions = inMessageOptions;
			} else {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
			}
		} catch (Exception e) {
			// exception is thrown ONLY when err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA from native
			// and the message is the OS error generated
			String msg = e.getMessage();
			long ret = TCErrorConstants.TCAPI_ERR_WHILE_CONFIGURING_MEDIA;
			String tcErr = String.format("%s OSError: %s", TCErrorConstants.getErrorMessage(ret), msg);
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, tcErr, null);
		}
		// send message ids to capture
		if (status.isOK()) {
			int number = (int)inMessageIds.size();
			byte[] ids = new byte[number];
			for (int i = 0; i < number; i++) {
				ids[i] = inMessageIds.getMessageIds().get(i);
			}
			long ret = nativeSetMessageIds(this.cookie.getClientId(), ids);
			if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
				this.messageIds = inMessageIds;
			} else {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
			}
		}
		// setup input stream
		if (status.isOK() && inMessageOptions.getMessageDestination() == ITCMessageOptions.DESTINATION_INPUTSTREAM) {
			inputStream = new TCMessageInputStream(this,
					inMessageOptions.getInputStreamSize(),
					cookie.getClientId());
			try {
				inputStream.open();
			} catch (IOException e) {
				// stream didn't open
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, e.getMessage(), e);
				e.printStackTrace();
			}
		}
		// create error monitor
		if (status.isOK()) {
			String monitorName = String.format("TCFMonitor%d", this.cookie.getClientId());
			monitorThread = new TCFMonitorThread(this, monitorName);
			stopTCFMonitorThread = false;
			monitorThread.start();
		}
		
		// start capture
		if (status.isOK()) {
			long ret = nativeStart(this.cookie.getClientId());
			if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
				this.cookie.setMessageProcessing(true);
			} else {
				// error in starting capture
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
			}
		}
		if (!status.isOK()) {
			// an error occurred along the way - unravel what we've done
			if (this.cookie.isMessageProcessing()) {
				long ret = nativeStop(this.cookie.getClientId());
				// ignore error
				this.cookie.setMessageProcessing(false);
			}
			if (this.monitorThread != null) {
				this.stopTCFMonitorThread = true;
				try {
					this.monitorThread.join();
				} catch (InterruptedException e) {
				}
				this.monitorThread = null;
			}
			if (this.inputStream != null && this.inputStream.isOpen()) {
				try {
					this.inputStream.close();
				} catch (IOException e) {
				}
				this.inputStream = null;
			}
			if (this.cookie.isConnected()) {
				long ret = nativeDisconnect(this.getClientId());
				this.cookie.setConnected(false);
				this.cookie.setClientId(-1);
			}
		}
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#connect(com.nokia.tcf.api.ITCConnection, com.nokia.tcf.api.ITCMessageOptions, com.nokia.tcf.api.ITCMessageIds)
	 */
	public IStatus connect(ITCConnection inConnection,
			ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
		
		IStatus status = checkConnectOptions(inConnection, inMessageOptions, inMessageIds);
		String[] settings = null;
		int type = 0;

		// do connect
		if (status.isOK()) {
			settings = null;
			type = inConnection.getConnectionType();
			switch(type) {
			case ITCConnection.MEDIA_REALTCP: {
				settings = new String[3];
				ITCRealTCPConnection t = (ITCRealTCPConnection)inConnection;
				settings[0] = t.getIpAddress();
				settings[1] = t.getPort();
				settings[2] = t.getDecodeFormat().toLowerCase();
				break;
			}
			case ITCConnection.MEDIA_VIRTUALSERIAL: {
				settings = new String[2];
				ITCVirtualSerialConnection s = (ITCVirtualSerialConnection)inConnection;
				settings[0] = s.getComPort();
				settings[1] = s.getDecodeFormat().toLowerCase();
				break;
			}
			case ITCConnection.MEDIA_REALSERIAL: {
				settings = new String[7];
				ITCRealSerialConnection s = (ITCRealSerialConnection)inConnection;
				settings[0] = s.getComPort();
				settings[1] = s.getBaudRate();
				settings[2] = s.getDataBits();
				settings[3] = s.getParity();
				settings[4] = s.getStopBits();
				settings[5] = s.getFlowControl();
				settings[6] = s.getDecodeFormat().toLowerCase();
				break;
			}
			case ITCConnection.MEDIA_USB: {
				settings = new String[1];
				break;
			}
			default:
				// Add other connection types here - error already checked in checkConnection()
				break;
			}
		}
		return finishConnect(type, settings, inConnection, inMessageOptions, inMessageIds);
	}
	private void ensureWritableFile(String filePath) throws IOException {
		// ensure file path points to a writable regular file
		IPath path = new Path(filePath);
		File file = path.toFile();
		if (!file.exists()) {
			file.createNewFile();
		}
		else { // file exists
			if (file.isDirectory()) {
				throw new IOException(MessageFormat.format("Path is a directory: {0}", filePath));
			}
			else if (!file.canWrite()) {
				throw new IOException(MessageFormat.format("File exists and is not writable: {0}", filePath));
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#connect(com.nokia.tcf.api.ITCMessageOptions, com.nokia.tcf.api.ITCMessageIds)
	 */
	public IStatus connect(ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
		// not currently implemented or tested
		long ret = TCErrorConstants.TCAPI_ERR_FEATURE_NOT_IMPLEMENTED;
		IStatus status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
		return status;
	}

	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#disconnect()
	 */
	public IStatus disconnect() {
		IStatus status = statusOK;
		
		IStatus connectStatus = checkConnected();
		// ignore error
		if (connectStatus.isOK()) {
			if (this.cookie.isMessageProcessing()) {
				long ret = nativeStop(this.cookie.getClientId());
				this.cookie.setMessageProcessing(false);
				if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
					status = new Status(IStatus.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
				}
			}
			if (this.monitorThread != null) {
				this.stopTCFMonitorThread = true;
				this.monitorThread.stop = true;
				try {
					this.monitorThread.join();
				} catch (InterruptedException e) {
				}
				this.monitorThread = null;
			}
			if (this.inputStream != null && this.inputStream.isOpen()) {
				try {
					this.inputStream.close();
				} catch (IOException e) {
				}
				this.inputStream = null;
			}
			if (this.cookie.isConnected()) {
				long ret = nativeDisconnect(this.cookie.getClientId());
				if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
					this.cookie.setConnected(false);
					this.cookie.setClientId(-1);
				} else {
					// error from nativeDisconnect
					status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
				}
			}
		}
		return status;
	}

	// private methods
	/**
	 * This is called from TCFMonitorThread to send errors to registered listeners
	 */
	public void fireErrorListeners(long errorCode, String errorString) {
		int s = this.errorListenerList.size();
//		System.out.printf("fireErrorListeners s = %d\n", s);
		for (int i = 0; i < s; i++) {
			ITCErrorListener e = (ITCErrorListener)this.errorListenerList.get(i);
			if (e != null) {
				int errorStatus = Status.ERROR;
				if (errorCode == TCErrorConstants.TCAPI_INFO_COMM_RECONNECTED)
					errorStatus = Status.INFO;
				IStatus status = new Status(errorStatus, Activator.PLUGIN_ID, (int)errorCode, errorString, null);
				e.errorOccurred(status);
			}
		}
	}

	public long getClientId() {
		return this.cookie.getClientId();
	}

	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#getConnections()
	 */
	public ITCConnection[] getConnections() {
		IStatus status = statusOK;
		ITCConnection[] connections = null;
		long numberConnections = 0;
		long[] number = new long[1];
		long ret = nativeGetNumberConnections(number);
		if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
			numberConnections = number[0];
		} else {
			// error processing from nativeGetNumberConnections
			status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
		}
		if (numberConnections > 0)
		{
			connections = new ITCConnection[(int)numberConnections];
			for (int inIndex = 0; inIndex < numberConnections; inIndex++)
			{
				int[] type = new int[1];
				ret = nativeGetTypeOfConnection(inIndex, type);
				switch ((int)type[0]) {
				case (int)ITCConnection.MEDIA_VIRTUALSERIAL: {
					ITCVirtualSerialConnection outConnection = (ITCVirtualSerialConnection)TCFClassFactory.createITCVirtualSerialConnection(null);
					int[] outType = new int[1];
					long[] outOptions = new long[3];
					String[] outSettings = new String[1];
					ret = nativeGetConnectionSettings(inIndex, outType, outOptions, outSettings);
					if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
						outConnection.setConnectionType(outType[0]);
						outConnection.setRetryInterval(outOptions[0]);
						outConnection.setRetryTimeout(outOptions[1]);
						outConnection.setDecodeFormat(convertDecodeFormat(outOptions[2]));
						outConnection.setComPort(outSettings[0]);
						
						connections[inIndex] = outConnection;
					} else {
						// error processing from nativeGetConnectionSettings
						status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
					}
					break;
				}
				case (int)ITCConnection.MEDIA_REALTCP: {
					ITCRealTCPConnection outConnection = (ITCRealTCPConnection)TCFClassFactory.createITCRealTCPConnection(null, null);
					int[] outType = new int[1];
					long[] outOptions = new long[3];
					String[] outSettings = new String[2];
					ret = nativeGetConnectionSettings(inIndex, outType, outOptions, outSettings);
					if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
						outConnection.setConnectionType(outType[0]);
						outConnection.setRetryInterval(outOptions[0]);
						outConnection.setRetryTimeout(outOptions[1]);
						outConnection.setDecodeFormat(convertDecodeFormat(outOptions[2]));
						outConnection.setIpAddress(outSettings[0]);
						outConnection.setPort(outSettings[1]);
						
						connections[inIndex] = outConnection;
					} else {
						// error processing from nativeGetConnectionSettings
						status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
					}
					break;
				}
				case (int)ITCConnection.MEDIA_REALSERIAL: {
					ITCRealSerialConnection outConnection = (ITCRealSerialConnection)TCFClassFactory.createITCRealSerialConnection(null);
					int[] outType = new int[1];
					long[] outOptions = new long[6];
					String[] outSettings = new String[6];
					ret = nativeGetConnectionSettings(inIndex, outType, outOptions, outSettings);
					if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
						outConnection.setConnectionType(outType[0]);
						outConnection.setRetryInterval(outOptions[0]);
						outConnection.setRetryTimeout(outOptions[1]);
						outConnection.setDecodeFormat(convertDecodeFormat(outOptions[2]));
						outConnection.setComPort(outSettings[0]);
						outConnection.setBaudRate(outSettings[1]);
						outConnection.setDataBits(outSettings[2]);
						outConnection.setParity(outSettings[3]);
						outConnection.setStopBits(outSettings[4]);
						outConnection.setFlowControl(outSettings[5]);
						
						connections[inIndex] = outConnection;
					} else {
						// error processing from nativeGetConnectionSettings
						status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
					}
					break;
				}
				case (int)ITCConnection.MEDIA_USB: {
					break;
				}
				default:
					// Add other connection types here
					break;
				}
			}
		}
		return connections;
	}

	protected String convertDecodeFormat(long decodeFormat) {
		if (decodeFormat == 1) {
			return "platsim";
		}
		if (decodeFormat == 2) {
			return "ost";
		}
		if (decodeFormat == 3) {
			return "rawtrk";
		}
		return "ost";
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#getInputStream()
	 */
	public ITCMessageInputStream getInputStream() {
		return this.inputStream;
	}

	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#getVersions()
	 */
	public ITCVersion[] getVersions() {
		IStatus status = statusOK;
		ITCVersion[] versions = null;
		status = checkConnected();
		if (status.isOK()) {
			// we're connected call native
			long numberVersions = nativeGetNumberVersionEntities(this.cookie.getClientId());
			if (numberVersions > 0) {
				versions = new TCVersion[(int)numberVersions];
				String[] versStrings = new String[(int)numberVersions];
				long numberGotten = nativeGetVersion(this.cookie.getClientId(), numberVersions, versStrings);
				for (int i = 0; i < numberGotten; i++) {
					versions[i] = new TCVersion(versStrings[i]);
				}
			}
		}
		return versions;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#removeErrorListener(com.nokia.tcf.api.ITCErrorListener)
	 */
	public IStatus removeErrorListener(ITCErrorListener inErrorListener) {
		IStatus status = statusOK;
//		System.out.printf("removeErrorListener\n");
		this.errorListenerList.remove(inErrorListener);
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#sendMessage(com.nokia.tcf.api.ITCMessage)
	 */
	public IStatus sendMessage(ITCMessage inMessage) {
		IStatus status = statusOK;
		status = checkConnected();
		if (status.isOK()) {
			// we are connected are we processing?
			if (this.cookie.isMessageProcessing()) {
				// we are running, check message
				status = checkMessage(inMessage);
				if (status.getSeverity() != Status.ERROR) {
					// Status.OK or Status.WARNING (still attempt to send on warning)
					// Encode if option is set

					long[] formattingOptions = new long[5];
					formattingOptions[0] = 0;
					formattingOptions[1] = messageOptions.getMessageEncodeFormat();
					formattingOptions[2] = messageOptions.getOSTVersion();
					formattingOptions[3] = inMessage.getMyMessageId();
					formattingOptions[4] = (inMessage.isUseMyMessageId() == true) ? 1 : 0;
					String[] settings = new String[1];
					settings[0] = connection.getDecodeFormat().toLowerCase();
					try {
						long ret = TCErrorConstants.TCAPI_ERR_NONE;
						if (inMessage == null) { // OK if we're just sending a header
							ret = nativeSendMessage(this.cookie.getClientId(), formattingOptions, settings, null);
						} else {
							ret = nativeSendMessage(this.cookie.getClientId(), formattingOptions, settings, inMessage.getMessage());
						}
						if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
							status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
						}
					} catch (Exception e) {
						// exception is thrown ONLY when err = TCAPI_ERR_COMM_ERROR from native
						// message is OS Error
						String msg = e.getMessage();
						long ret = TCErrorConstants.TCAPI_ERR_COMM_ERROR;
						String tcErr = String.format("%s OSError: %s", TCErrorConstants.getErrorMessage(ret), msg);
						status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, tcErr, null);
					}
				}
			} else {
				// we are stopped
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_ROUTING_STOPPED,
						TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_ROUTING_STOPPED), null);
			}
		}
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#setTCMessageIds(com.nokia.tcf.api.ITCMessageIds)
	 */
	public IStatus setTCMessageIds(ITCMessageIds inMessageIds) {
		IStatus status = statusOK;
		status = checkMessageIds(inMessageIds);
		if (status.isOK()) {
			// input is OK
			status = checkConnected();
			if (status.isOK()) {
				// connected
				if (this.cookie.isMessageProcessing()) {
					// must be stopped to set new IDs
					status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_ROUTING_IN_PROGRESS,
							TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_ROUTING_IN_PROGRESS), null);
				}
			}
		}
		if (status.isOK()) {
			// everything OK, so we can save our IDs and register them
			this.messageIds = inMessageIds;
			int size = (int)inMessageIds.size();
			byte[] messageids = new byte[size];
			for (int i = 0; i < size; i++) {
				messageids[0] = inMessageIds.getMessageIds().get(i);
			}
			long ret = nativeSetMessageIds(this.cookie.getClientId(), messageids);
			if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret,
						TCErrorConstants.getErrorMessage(ret), null);
			}
		}
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#start()
	 */
	public IStatus start() {
		IStatus status = statusOK;
		// check connected
		status = checkConnected();
		if (status.isOK()) {
			if (this.cookie.isMessageProcessing() == false) {
				// call native
				long ret = nativeStart(this.cookie.getClientId());
				if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
					this.cookie.setMessageProcessing(true);
				} else {
					status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
				}
			}
		}
		
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#stop()
	 */
	public IStatus stop() {
		IStatus status = statusOK;
		status = checkConnected();
		if (status.isOK()) {
			if (this.cookie.isMessageProcessing()) {
				long ret = nativeStop(this.cookie.getClientId());
				if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
					this.cookie.setMessageProcessing(false);
				} else {
					status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
				}
			}
		}
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#testConnection()
	 */
	public IStatus testConnection() {
		IStatus status = statusOK;
		status = checkConnected();
		if (status.isOK()) {
			long ret = nativeTestConnection(this.cookie.getClientId());
			if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)(ret), TCErrorConstants.getErrorMessage((int)ret), null);
			}
		}
		return status;
	}
	protected IStatus doTestConnection(int type, String[] settings, ITCConnection inConnection) {
		IStatus status = statusOK;
		// test connection
		long[] options = new long[3];
		options[0] = inConnection.getRetryInterval();		// connection options
		options[1] = inConnection.getRetryTimeout();
		options[2] = 0;
		long ret = nativeTestConnection(type, options, settings);
		if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
		}
		return status;
	}
	/* (non-Javadoc)
	 * @see com.nokia.tcf.api.ITCAPIConnection#testConnection(com.nokia.tcf.api.ITCConnection)
	 */
	public IStatus testConnection(ITCConnection inConnection) {
		IStatus status = statusOK;
		String[] settings = null;
		int type = inConnection.getConnectionType();
		switch(type) {
		case ITCConnection.MEDIA_REALSERIAL:
		{
			settings = new String[7];
			ITCRealSerialConnection s = (ITCRealSerialConnection)inConnection;
			settings[0] = s.getComPort();
			settings[1] = s.getBaudRate();
			settings[2] = s.getDataBits();
			settings[3] = s.getParity();
			settings[4] = s.getStopBits();
			settings[5] = s.getFlowControl();
			settings[6] = s.getDecodeFormat().toLowerCase();
		}
			break;
		case ITCConnection.MEDIA_REALTCP:
		{
			settings = new String[3];
			ITCRealTCPConnection s = (ITCRealTCPConnection)inConnection;
			settings[0] = s.getIpAddress();
			settings[1] = s.getPort();
			settings[2] = s.getDecodeFormat().toLowerCase();
		}	
			break;
		case ITCConnection.MEDIA_USB:
		{
			settings = new String[1];
		}
			break;
		case ITCConnection.MEDIA_VIRTUALSERIAL:
		{
			settings = new String[2];
			ITCVirtualSerialConnection s = (ITCVirtualSerialConnection)inConnection;
			settings[0] = s.getComPort();
			settings[1] = s.getDecodeFormat().toLowerCase();
		}
			break;
		default:
			long err = TCErrorConstants.TCAPI_ERR_MEDIA_NOT_SUPPORTED;
			status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)err, TCErrorConstants.getErrorMessage((int)err), null);
			break;
		}
		
		if (status.isOK()) {
			status = doTestConnection(type, settings, inConnection);
/*			// test connection
			long[] options = new long[3];
			options[0] = inConnection.getRetryInterval();		// connection options
			options[1] = inConnection.getRetryTimeout();
			options[2] = inConnection.getDecodeFormat();
			long ret = nativeTestConnection(type, options, settings);
			if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
				status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
			} */
		}
		return status;
	}
	public IStatus clearMessageFile() {
		IStatus status = statusOK;
		IStatus connStatus = checkConnected();
		if (connStatus.isOK()) {
			if (messageOptions.getMessageDestination() == ITCMessageOptions.DESTINATION_CLIENTFILE) {
				if (messageOptions.getMessageFile() != null) {
					long ret = nativeClearFile(cookie.getClientId());
					if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
						status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
					}
				}
			}
		}
		return status;
	}

	// natives
	// connect/disconnect
	private native long nativeConnect(int inType, long[] inOptions, String[] inSettings, long[] inMessageOptions, String inFilePath, long[] outClientId);
	private native long nativeDisconnect(long inClientId); 
	// connections
	protected native long nativeGetNumberConnections(long[] outNumber);
	protected native long nativeGetTypeOfConnection(long inIndex, int[] outType);
	protected native long nativeGetConnectionSettings(long inIndex, int[] outType, long[] outOptions, String[] outSettings);
	// port handling errors
	public native boolean nativePollError(long inClienId, int[] outErrorCode, boolean[] outHasOSErrorCode, long[] outOSErrorCode);
	// versions
	private native long nativeGetNumberVersionEntities(long inClientId);
	private native long nativeGetVersion(long inClientId, long inNumToGet, String[] outVersion);
	// input stream
	public native long nativePollInputStream(long inClientId, long[] outNumberTotalMessages);
	public native long nativePollInputStream2(long inClientId, long inNumberMessagesToPeek, long[] outNumberMessagesPeeked, long[] outNumberBytesPeeked);
	public native long nativeGetInputStreamMessageBytes(long inClientId, long inNumberMessagesToPeek, long[] outNumberBytesPerMessage);
	public native long nativeReadInputStream(long inClientId, long inNumberMessagesToRead, long[] outNumberMessagesRead, long[] outNumberBytesRead, long inNumberMaxBytes, byte[] outMessages);
	public native long nativeOpenInputStream(long inClientId, String inBaseFilePath, long inInputStreamSize, boolean inOverFlowToFile);
	public native long nativeCloseInputStream(long inClientId);
	// message file
	private native long nativeClearFile(long inClientId);
	// send message
	private native long nativeSendMessage(long inClientId, long[] inFormattingOptions, String[] inSettings, byte[] inMessage);
	// register message IDs
	private native long nativeSetMessageIds(long inClientId, byte[] inMessageIds);
	// start/stop processing
	private native long nativeStart(long inClientId);
	private native long nativeStop(long inClientId);
	// test connections
	private native long nativeTestConnection(int inType, long[] inOptions, String[] inSettings);
	private native long nativeTestConnection(long inClientId);
	// start/stop server - done from plugin activator start/stop methods
	public native long nativeStartServer();
	public native long nativeStopServer();
}
