/*

* Copyright (c) 2010 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.discovery.pccs.pccsnative;

import java.nio.IntBuffer;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.Map;

import org.eclipse.cdt.utils.WindowsRegistry;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import com.nokia.carbide.remoteconnections.RemoteConnectionsActivator;

import com.nokia.carbide.remoteconnections.discovery.pccs.Activator;

import com.nokia.carbide.remoteconnections.discovery.pccs.Messages;

import com.nokia.carbide.remoteconnections.discovery.pccs.pccsnative.IConnAPILibrary.IConnAPIDeviceCallback;

import com.sun.jna.Pointer;

import com.sun.jna.WString;

import com.sun.jna.ptr.IntByReference;

import com.sun.jna.ptr.ShortByReference;

public class PCCSConnection {

	private static final String NOT_KNOWN = "not known"; //$NON-NLS-1$ // used for all string structure elements that come back from PCCS as null

	private boolean DEBUG = false;

	public class DeviceNotificationCallback implements IConnAPIDeviceCallback {

		/* (non-Javadoc)

		 * @see com.nokia.carbide.remoteconnections.discovery.pccs.pccsnative.IConnAPILibrary.IConnAPIDeviceCallback#invoke(int, com.sun.jna.ptr.ShortByReference)

		 */

		public int invoke(final int dwStatus, final ShortByReference pstrSerialNumber) {

			// check for NULL, since I am seeing bogus events coming from PCCS before the real one

			//  and the serial number is not filled in. If the serial number is null,

			//  everything else will be null (according to the PCCS docs)

			//  TODO: bug in PCCS API: 

			if (DEBUG) System.out.printf("DeviceNotificationCallback %x %s\n", dwStatus, (pstrSerialNumber == null ? "serNum: null" : pstrSerialNumber.getPointer().getString(0, true))); //$NON-NLS-1$ //$NON-NLS-2$

			String serialNumber = NOT_KNOWN;

			if (pstrSerialNumber != null) {

				serialNumber = pstrSerialNumber.getPointer().getString(0, true);

			}

			DeviceEventListener.DeviceEvent eventType = DeviceEventListener.DeviceEvent.DEVICE_LIST_UPDATED;

			// decode dwStatus per PCCS docs

			switch(DMAPIDefinitions.GET_CONAPI_CB_STATUS(dwStatus)) {

			case DMAPIDefinitions.CONAPI_DEVICE_LIST_UPDATED:

				eventType = DeviceEventListener.DeviceEvent.DEVICE_LIST_UPDATED;

				break;

			case DMAPIDefinitions.CONAPI_DEVICE_ADDED:

				eventType = DeviceEventListener.DeviceEvent.DEVICE_ADDED;

				break;

			case DMAPIDefinitions.CONAPI_DEVICE_REMOVED:

				eventType = DeviceEventListener.DeviceEvent.DEVICE_REMOVED;

				break;

			case DMAPIDefinitions.CONAPI_DEVICE_UPDATED:

				switch(DMAPIDefinitions.GET_CONAPI_CB_INFO(dwStatus)) {

				case DMAPIDefinitions.CONAPI_CONNECTION_ADDED:

					eventType = DeviceEventListener.DeviceEvent.DEVICE_UPDATED_ADDEDCONNECTION;

					break;

				case DMAPIDefinitions.CONAPI_CONNECTION_REMOVED:

					eventType = DeviceEventListener.DeviceEvent.DEVICE_UPDATED_REMOVEDCONNECTION;

					break;

				case DMAPIDefinitions.CONAPI_DEVICE_RENAMED:

					eventType = DeviceEventListener.DeviceEvent.DEVICE_UPDATED_RENAMED;

					break;

				}

			}

			// fire events

			if (DEBUG) System.out.println("DeviceNotificationCallback: fire events");

			Iterator<DeviceEventListener> iter = listeners.iterator();

			while (iter.hasNext()) {

				iter.next().onDeviceEvent(eventType, serialNumber);

			}

			return PCCSErrors.CONA_OK;

		}

	}

	private static final Collection<DeviceEventListener> listeners = new LinkedList<DeviceEventListener>();

	private IConnAPILibrary library;

	private DeviceNotificationCallback pfnCallback = new DeviceNotificationCallback();

	public static final int PCCS_NOT_FOUND = 1;

	public static final int PCCS_WRONG_VERSION = 2;

	private static final int DMAPI_VERSION = DMAPIDefinitions.DMAPI_VERSION_34;

	private APIHANDLE dmHandle = APIHANDLE.INVALID_HANDLE_VALUE;

	private APIHANDLE mcHandle = APIHANDLE.INVALID_HANDLE_VALUE;

	private APIHANDLE upHandle = APIHANDLE.INVALID_HANDLE_VALUE;

	private Collection<String> noSwitchConnections = new ArrayList<String>();

	public PCCSConnection() {

	}

	public void open() throws CoreException {

		if (library == null) {

			try {

				library = IConnAPILibrary.INSTANCE;

			} catch (UnsatisfiedLinkError e) {

				String msg;

				if (Activator.isSymSEELayout()) {

					msg = Messages.ConnAPILibrary_PCCS_Not_Found_Error + Activator.getLoadErrorURL();

				} else {

					msg = Messages.ConnAPILibrary_PCSuite_Not_Found_Error + Activator.getLoadErrorURL();

				}

				throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, PCCSConnection.PCCS_NOT_FOUND, msg, e));

			} catch (NoClassDefFoundError e) {

				String msg;

				if (Activator.isSymSEELayout()) {

					msg = Messages.ConnAPILibrary_PCCS_Not_Found_Error + Activator.getLoadErrorURL();

				} else {

					msg = Messages.ConnAPILibrary_PCSuite_Not_Found_Error + Activator.getLoadErrorURL();

				}

				throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, PCCSConnection.PCCS_NOT_FOUND, msg, e));

			}

		}

		// this uses the MCAPI only to enable required media

		ensureMediaEnabled();

		// load DMAPI

		initDMAPI();

		dmHandle = loadDMAPI();

		if (!APIHANDLE.INVALID_HANDLE_VALUE.equals(dmHandle)) {

			startDMNotifications(dmHandle);

		}

	}

	private void initDMAPI() throws CoreException {

		int dwResult = library.DMAPI_Initialize(DMAPI_VERSION, null);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		terminateDMAPI();

    		String msg;

    		if (Activator.isSymSEELayout()) {

        		msg = String.format("PCCS DMAPI_Initialize API returned error on initialization %x", dwResult); //$NON-NLS-1$

        		if (dwResult == PCCSErrors.ECONA_UNSUPPORTED_API_VERSION) {

        			msg = Messages.PCCSConnection_PCCS_Version_Error + Activator.getLoadErrorURL();

        		}

    		} else {

    			msg = Messages.PCCSConnection_PCSuite_Version_Error + Activator.getLoadErrorURL();

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, PCCS_WRONG_VERSION, msg, null));

    	}

		if (DEBUG) System.out.println("initDMAPI"); //$NON-NLS-1$

	}

	private void startDMNotifications(APIHANDLE handle) throws CoreException {

    	// register a call back

    	int dwResult = library.CONARegisterNotifyCallback(handle, PCCSTypeDefinitions.API_REGISTER, pfnCallback);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		library.CONACloseDM(handle);

        	handle = APIHANDLE.INVALID_HANDLE_VALUE;

        	String msg = String.format(Messages.PCCSConnection_PCCS_CONARegisterNotifyCallback_Error, dwResult);

    		if (dwResult == PCCSErrors.ECONA_INVALID_POINTER) {

    			msg = Messages.PCCSConnection_PCCS_CONARegisterNotifyCallback_Pointer_Error;

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, dwResult, msg, null));

    	}

		if (DEBUG) System.out.println("startDMNotifications"); //$NON-NLS-1$

	}

	private void ensureMediaEnabled() throws CoreException {

		// open the MCAPI

		loadMCAPI();

		// get media list

		IntBuffer pdwCount = IntBuffer.allocate(1);

		CONAPI_MEDIA.ByReference ppMedia = new CONAPI_MEDIA.ByReference();

		int dwResult = library.CONAMMGetMedia(mcHandle, pdwCount, ppMedia);

		if (DEBUG)

			System.out.printf("CONAMMGetMedia dwResult = %x\tpdwCount = %d\n", dwResult, pdwCount.get(0)); //$NON-NLS-1$

		int count = pdwCount.get(0);

		Pointer pMedia = ppMedia.getPointer();

		Pointer nativePointer = pMedia.getPointer(0); // save this for freeing media

		int size = ppMedia.size();

		if (count > 0) {

			CONAPI_MEDIA media[] = new CONAPI_MEDIA[count];

			for (int i = 0; i < count; i++) {

				// get pointer from offset of native pointer

				Pointer sharedP = nativePointer.share(0 + i*size);

				media[i] = new CONAPI_MEDIA(sharedP);

				// and read the data from native memory

				media[i].read();

			}

			for (int i = 0; i < count; i++) {

				if (MCAPIDefinitions.CONAPI_GET_MEDIA_TYPE(media[i].dwMedia) == MCAPIDefinitions.CONAPI_MEDIA_USB) {

					if (MCAPIDefinitions.CONAPI_IS_MEDIA_UNACTIVE(media[i].dwState)) {

						media[i].dwState = MCAPIDefinitions.CONAPI_MEDIA_ACTIVE;

						dwResult = library.CONAMMSetMedia(mcHandle, media);

						if (DEBUG)

							System.out.printf("CONAMMSetMedia dwResult = %x\n", dwResult); //$NON-NLS-1$

					}

				}

			}

			dwResult = library.CONAMMFreeMediaStructures(count, nativePointer);

			if (DEBUG)

				System.out.printf("CONAMMFreeMediaStructures dwResult = %x\n", dwResult); //$NON-NLS-1$

		}

		// close MCAPI

		closeMCAPI();

	}

	/**

	 * Opens Device Management API (DMAPI) for use. Note: initDMAPI must be called prior to this.<br>

	 * initDMAPI need be called only once, but this can be called whenever we need a handle to

	 * the DMAPI.

	 * 

	 * @throws CoreException

	 */

	private APIHANDLE loadDMAPI() throws CoreException {

    	// open a DM handle

    	APIHANDLE handle = APIHANDLE.INVALID_HANDLE_VALUE;

    	LPAPIHANDLE pHandle = new LPAPIHANDLE();

    	int dwResult = library.CONAOpenDM(pHandle);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		String msg = String.format(Messages.PCCSConnection_PCCS_CONAOpenDM_Error, dwResult);

    		if (dwResult == PCCSErrors.ECONA_NOT_ENOUGH_MEMORY) {

    			msg = Messages.PCCSConnection_PCCS_Not_Enough_Memory_Error;

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, dwResult, msg, null));

    	} else {

    		handle = pHandle.getValue();

    	}

		if (DEBUG) System.out.printf("loadDMAPI handle=%s\n", handle.toString()); //$NON-NLS-1$

    	return handle;

	}

	private void loadMCAPI() throws CoreException {

		int dwResult = PCCSErrors.CONA_OK;

		dwResult = library.MCAPI_Initialize(MCAPIDefinitions.MCAPI_VERSION_32, null);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		library.MCAPI_Terminate(null);

    		String msg;

    		if (Activator.isSymSEELayout()) {

        		msg = String.format("PCCS MCAPI_Initialize API returned error on initialization %x", dwResult); //$NON-NLS-1$

        		if (dwResult == PCCSErrors.ECONA_UNSUPPORTED_API_VERSION) {

        			msg = Messages.PCCSConnection_PCCS_Version_Error + Activator.getLoadErrorURL();

        		}

    		} else {

    			msg = Messages.PCCSConnection_PCSuite_Version_Error + Activator.getLoadErrorURL();

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, PCCS_WRONG_VERSION, msg, null));

    	}

    	LPAPIHANDLE pHandle = new LPAPIHANDLE();

    	dwResult = library.CONAOpenMM(pHandle, 0);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		library.MCAPI_Terminate(null);

    		String msg = String.format("PCCS CONAOpenMM API returned error on initialization %x", dwResult); //$NON-NLS-1$

    		if (dwResult == PCCSErrors.ECONA_NOT_ENOUGH_MEMORY) {

    			msg = Messages.PCCSConnection_PCCS_Not_Enough_Memory_Error;

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, dwResult, msg, null));

    	} else {

    		mcHandle = pHandle.getValue();

    	}

		if (DEBUG) System.out.println("\n-----loadMCAPI"); //$NON-NLS-1$

	}

	private void loadUPAPI() throws CoreException {

		int dwResult = PCCSErrors.CONA_OK;

		dwResult = library.UPAPI_Initialize(UPAPIDefinitions.UPAPI_VERSION_10, null);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		library.UPAPI_Terminate(null);

    		String msg;

    		msg = String.format("PCCS UPAPI_Initialize API returned error on initialization %x", dwResult); //$NON-NLS-1$

    		if (DEBUG) System.out.println(msg);

    		if (Activator.isSymSEELayout()) {

        		if (dwResult == PCCSErrors.ECONA_UNSUPPORTED_API_VERSION) {

        			msg = Messages.PCCSConnection_PCCS_Version_Error + Activator.getLoadErrorURL();

        		}

    		} else {

    			msg = Messages.PCCSConnection_PCSuite_Version_Error + Activator.getLoadErrorURL();

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, PCCS_WRONG_VERSION, msg, null));

    	}

    	LPAPIHANDLE pHandle = new LPAPIHANDLE();

    	dwResult = library.UPAPI_OpenUSBPersonality(0, pHandle);

    	if (dwResult != PCCSErrors.CONA_OK) {

    		library.UPAPI_Terminate(null);

    		String msg = String.format("PCCS OpenUSBPersonality API returned error on initialization %x", dwResult); //$NON-NLS-1$

    		if (DEBUG) System.out.println(msg);

    		if (dwResult == PCCSErrors.ECONA_NOT_ENOUGH_MEMORY) {

    			msg = Messages.PCCSConnection_PCCS_Not_Enough_Memory_Error;

    		}

    		throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, dwResult, msg, null));

    	} else {

    		upHandle = pHandle.getValue();

    	}

		if (DEBUG) System.out.println("\n-----loadUPAPI"); //$NON-NLS-1$

	}

	public void close() throws CoreException {

		if (library == null)

			return;

		stopDMNotifications(dmHandle);

		// DMAPI should only one be open

		dmHandle = closeDMAPI(dmHandle);

		terminateDMAPI();

	}

	private void terminateDMAPI() {

    	// Terminate Device management API

    	/*int dwResult =*/ library.DMAPI_Terminate(null);

		if (DEBUG) System.out.println("terminateDMAPI"); //$NON-NLS-1$

	}

	private void stopDMNotifications(APIHANDLE handle) {

//		int dwResult = PCCSErrors.CONA_OK;

		if (!APIHANDLE.INVALID_HANDLE_VALUE.equals(handle)) {

			// unregister callback

			/*dwResult =*/ library.CONARegisterNotifyCallback(handle, PCCSTypeDefinitions.API_UNREGISTER, pfnCallback);

		}		

		if (DEBUG) System.out.println("stopDMNotifications"); //$NON-NLS-1$

	}

	/**

	 * Closes the DMAPI.

	 * @throws CoreException

	 */

	private APIHANDLE closeDMAPI(APIHANDLE handle) throws CoreException {

		int dwResult = PCCSErrors.CONA_OK;

		if (!APIHANDLE.INVALID_HANDLE_VALUE.equals(handle)) {

			// close DM connection

			dwResult = library.CONACloseDM(handle);

			if (DEBUG) System.out.printf("closeDMAPI ret=%x handle=%s\n", dwResult, handle.toString()); //$NON-NLS-1$

			handle = APIHANDLE.INVALID_HANDLE_VALUE;

		}

		return handle;

	}

	private void closeMCAPI() {

//		int dwResult = PCCSErrors.CONA_OK;

		if (!APIHANDLE.INVALID_HANDLE_VALUE.equals(mcHandle)) {

			// close DM connection

			/*dwResult =*/ library.CONACloseDM(mcHandle);

			mcHandle = APIHANDLE.INVALID_HANDLE_VALUE;

        	// Terminate Device management API

    		/*dwResult =*/ library.MCAPI_Terminate(null);

		}

		if (DEBUG) System.out.println("closeMCAPI----\n"); //$NON-NLS-1$

	}

	private void closeUPAPI() {

		int dwResult = PCCSErrors.CONA_OK;

		if (!APIHANDLE.INVALID_HANDLE_VALUE.equals(upHandle)) {

			// close DM connection

			dwResult = library.UPAPI_CloseUSBPersonality(upHandle);

			if (dwResult != PCCSErrors.CONA_OK) {

        		if (DEBUG) System.out.printf("UPAPI_CloseUSBPersonality dwResult = %x\n", dwResult); //$NON-NLS-1$

			}

			upHandle = APIHANDLE.INVALID_HANDLE_VALUE;

        	// Terminate Device management API

    		dwResult = library.UPAPI_Terminate(null);

			if (dwResult != PCCSErrors.CONA_OK) {

        		if (DEBUG) System.out.printf("UPAPI_Terminate dwResult = %x\n", dwResult); //$NON-NLS-1$

			}

		}

		if (DEBUG) System.out.println("closeUPAPI----\n"); //$NON-NLS-1$

	}

	/**

	 * All devices detected are gotten here - BT, USB, etc.

	 *  No checking of a valid connection is done here

	 *  

	 * @return DeviceInfo[] - null if no devices connected

	 */

	private DeviceInfo[] getCompleteDeviceList() {

		DeviceInfo[] deviceInfo = null;

		APIHANDLE handle = APIHANDLE.INVALID_HANDLE_VALUE;

		try {

			handle = loadDMAPI();

		} catch (CoreException e) {

			return deviceInfo;

		}

		IntByReference pdwCount = new IntByReference(0);

		int dwResult = library.CONAGetDeviceCount(handle, pdwCount);

		if (DEBUG) System.out.printf("CONAGetDeviceCount: %x number of devices: %d\n", dwResult, pdwCount.getValue()); //$NON-NLS-1$

		if (dwResult != PCCSErrors.CONA_OK) {

			try {

				closeDMAPI(handle);

			} catch (CoreException e) {

			}

			return deviceInfo;

		}

		int deviceCount = pdwCount.getValue();

		if (deviceCount > 0) {

			CONAPI_DEVICE[] pDevices = (CONAPI_DEVICE[])new CONAPI_DEVICE().toArray(deviceCount);

			dwResult = library.CONAGetDevices(handle, pdwCount, pDevices);

			if (DEBUG) System.out.printf("CONAGetDevices: %x number of devices: %d\n", dwResult, deviceCount); //$NON-NLS-1$

			if (dwResult != PCCSErrors.CONA_OK) {

				try {

					closeDMAPI(handle);

				} catch (CoreException e) {

				}

				return deviceInfo;

			}

			// Extract device information and connection info

			deviceInfo = new DeviceInfo[deviceCount];

			CONAPI_DEVICE[] devices = pDevices;

			for (int i = 0; i < deviceCount; i++) {

				deviceInfo[i] = new DeviceInfo();

				if (devices[i].pstrSerialNumber != null) {

					deviceInfo[i].serialNumber = devices[i].pstrSerialNumber.getPointer().getString(0, true);

				} else {

					// TODO: docs say if ser num == null --> device unsupported, but this is a bug in PCCS

					deviceInfo[i].serialNumber = NOT_KNOWN; //$NON-NLS-1$

				}

				if (devices[i].pstrFriendlyName != null) {

					deviceInfo[i].friendlyName = devices[i].pstrFriendlyName.getPointer().getString(0, true);

				} else {

					deviceInfo[i].friendlyName = NOT_KNOWN; //$NON-NLS-1$

				}

				if (devices[i].pstrModel != null) {

					deviceInfo[i].model = devices[i].pstrModel.getPointer().getString(0, true);

				} else {

					deviceInfo[i].model = NOT_KNOWN; //$NON-NLS-1$

				}

				if (devices[i].pstrManufacturer != null) {

					deviceInfo[i].mfr = devices[i].pstrManufacturer.getPointer().getString(0, true);

				} else {

					deviceInfo[i].mfr = NOT_KNOWN; //$NON-NLS-1$

				}

				int numConnections = deviceInfo[i].numberOfConnections = devices[i].dwNumberOfItems;

				CONAPI_CONNECTION_INFO[] conn = null;

				if (numConnections > 0)

					conn = (CONAPI_CONNECTION_INFO[])devices[i].pItems.toArray(numConnections);

				for (int j = 0; j < numConnections; j++) {

					DeviceConnectionInfo connInfo = new DeviceConnectionInfo();

					connInfo.deviceID = conn[j].dwDeviceID;

					switch(conn[j].dwMedia){

					case PCCSTypeDefinitions.API_MEDIA_BLUETOOTH:

						connInfo.media = "bluetooth"; //$NON-NLS-1$

						break;

					case PCCSTypeDefinitions.API_MEDIA_IRDA:

						connInfo.media = "irda"; //$NON-NLS-1$

						break;

					case PCCSTypeDefinitions.API_MEDIA_SERIAL:

						connInfo.media = "serial-ca42"; //$NON-NLS-1$

						break;

					default:

					case PCCSTypeDefinitions.API_MEDIA_USB:

						connInfo.media = "usb"; //$NON-NLS-1$

						break;

					}

					// fill-in friendly name with device name if the former was null

					if (conn[j].pstrDeviceName != null) {

						connInfo.deviceName = conn[j].pstrDeviceName.getPointer().getString(0,true);

						if (deviceInfo[i].friendlyName.equals(NOT_KNOWN)) { //$NON-NLS-1$

							deviceInfo[i].friendlyName = connInfo.deviceName;

						}

					} else {

						connInfo.deviceName = NOT_KNOWN; //$NON-NLS-1$

					}

					// if the address is not known, this is serious - we may weed out this connection later

					if (conn[j].pstrAddress != null) {

						connInfo.address = conn[j].pstrAddress.getPointer().getString(0, true);

					} else {

						connInfo.address = NOT_KNOWN; // $NON-NLS-1$

					}

					connInfo.state = conn[j].dwState;

					deviceInfo[i].connections.add(connInfo);

				}

			}