/*

* 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 org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.jface.dialogs.MessageDialogWithToggle;

import org.eclipse.swt.widgets.Display;

import org.osgi.service.prefs.BackingStoreException;

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.nokia.cpp.internal.api.utils.ui.WorkbenchUtils;

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 String DONT_ASK_AGAIN_KEY = "DontAskAgain"; //$NON-NLS-1$

	/**

	 *

	 */

	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) {

				}

			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 APIHANDLE dmHandle = APIHANDLE.INVALID_HANDLE_VALUE;

	private APIHANDLE mcHandle = APIHANDLE.INVALID_HANDLE_VALUE;

	private APIHANDLE upHandle = APIHANDLE.INVALID_HANDLE_VALUE;

	private void storeDontAskAgain() {

		Activator.getDefault().getPreferenceStore().setValue(DONT_ASK_AGAIN_KEY, true);

		try {

			new InstanceScope().getNode(Activator.PLUGIN_ID).flush();

		} catch (BackingStoreException e) {

			Activator.logError(e);

		}

	}

	private boolean dontAskAgain() {

		return Activator.getDefault().getPreferenceStore().getBoolean(DONT_ASK_AGAIN_KEY);

	}

	public PCCSConnection() {

	}

	public void open() throws CoreException {

		if (library == null) {

		}

		// this uses the MCAPI only to enable required media

		ensureMediaEnabled();

		// load DMAPI

	}

    	if (dwResult != PCCSErrors.CONA_OK) {

    		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 (dwResult != PCCSErrors.CONA_OK) {

        	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));

    	}

	}

	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();

    	}

	}

	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;

		// DMAPI should only one be open

	}

	/**

	 * Closes the DMAPI.

	 * @throws CoreException

	 */

		int dwResult = PCCSErrors.CONA_OK;

			// close DM connection

		}

	}

	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);

		}

	}

	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;

		IntByReference pdwCount = new IntByReference(0);

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

			return deviceInfo;

		int deviceCount = pdwCount.getValue();

		if (deviceCount > 0) {

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

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

			if (dwResult != PCCSErrors.CONA_OK) {

				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$