/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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.s60tools.appdep.ui.views.main;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.NoSuchElementException;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import com.nokia.s60tools.appdep.core.AppDepSettings;

import com.nokia.s60tools.appdep.core.ITargetPlatform;

import com.nokia.s60tools.appdep.core.data.CacheDataConstants;

import com.nokia.s60tools.appdep.core.data.ComponentLinkLeafNode;

import com.nokia.s60tools.appdep.core.data.ComponentNode;

import com.nokia.s60tools.appdep.core.data.ComponentParentNode;

import com.nokia.s60tools.appdep.core.model.ComponentPropertiesData;

import com.nokia.s60tools.appdep.core.model.ExportFunctionData;

import com.nokia.s60tools.appdep.core.model.ImportFunctionData;

import com.nokia.s60tools.appdep.exceptions.CacheFileDoesNotExistException;

import com.nokia.s60tools.appdep.exceptions.CacheIndexNotReadyException;

import com.nokia.s60tools.appdep.resources.Messages;

import com.nokia.s60tools.sdk.SdkInformation;

/**

 * Selection change listener for main view.

 */

public class MainViewSelectionChangedListener implements

		ISelectionChangedListener {

	//

	// Members

	//

	private final MainView view;

	private final ArrayList<ImportFunctionData> importFunctionsArrayList;

	private final ArrayList<ExportFunctionData> exportFunctionsArrayList;

	private boolean propertiesFoundSuccessfully;

	/**

	 * Default constructor.

	 * @param view Reference to main view

	 * @param importFunctionsArrayList Import function list to be updated on selection.

	 * @param exportFunctionsArrayList Export function list to be updated on selection.

	 */

	public MainViewSelectionChangedListener(MainView view, 

										    ArrayList<ImportFunctionData> importFunctionsArrayList,

										    ArrayList<ExportFunctionData> exportFunctionsArrayList){

		this.view = view;

		this.importFunctionsArrayList = importFunctionsArrayList;

		this.exportFunctionsArrayList = exportFunctionsArrayList;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)

	 */

	public void selectionChanged(SelectionChangedEvent event) {

		try {			

			Object obj = view.getComponentTreeSelectedElement();

			// By default component properties data reference

			// is set to null

			view.setSelectedComponentPropertiesData(null);

			if(obj == null){

				// We might get null-selections when

				// tree is expanded/collapsed.

				return;

			}

			else{

				// Storing the selection for further reference in case 

				// selection is lost because of the user decides

				// to use 'Go Into' functionality which loses the selection.

				view.setMostRecentlySelectedComponentNode(obj);

			}

			// The object is for sure an instance of ComponentNode

			ComponentNode node = (ComponentNode) obj;

			// Storing name of the selected component (that might be name of the concrete component replacing generic one).

			String selectedComponentName = node.getName();

			// Component node instance which is selected or selected leaf node refers to

			ComponentParentNode componentNodeInstance;

			// Storing original component name in here, if we are replacing a generic component

			String selectedComponentOriginalName;

			if(node instanceof ComponentParentNode){

				componentNodeInstance = (ComponentParentNode)node;

			}

			else{

				// We have leaf node 

				ComponentLinkLeafNode leafNode = (ComponentLinkLeafNode)node;

				// Getting referred component

				componentNodeInstance = leafNode.getReferredComponent();

			}

			// Storing name of the original component if needed

			if(componentNodeInstance.wasGenericComponent()){

				selectedComponentOriginalName = componentNodeInstance.getOriginalName();	

			}else{

				// No concrete component replacement done and therefore selected component is the original one.

				selectedComponentOriginalName = selectedComponentName;		

			}

			String parentComponentName = node.getParent().getName();

			AppDepSettings st = AppDepSettings.getActiveSettings();

			SdkInformation sdkInfo = st.getCurrentlyUsedSdk();

			//Updating tool bar text if the view is fully populated

			// i.e. dependency search is finished.

			if(!MainView.isDependencySearchOngoing()){

				String descr = null;

				if(sdkInfo != null){

					descr = 

							Messages.getString("MainViewSelectionChangedListener.SDK_Prefix") //$NON-NLS-1$

							+ sdkInfo.getSdkId()

							+ " - " //$NON-NLS-1$

							+  st.getCurrentlyUsedTargetPlatformsAsString()

							+ " " //$NON-NLS-1$

							+  st.getBuildType().getBuildTypeDescription()

							+ Messages.getString("MainViewSelectionChangedListener.Component_Prefix") //$NON-NLS-1$

							+ node.getFullName();

					view.updateDescription(descr);

				}

			}

			// Fetching property information for the selected component

			//For properties, cannot use selectedComponentName, because it may point to generic component

			propertiesFoundSuccessfully = updateComponentPropertyInformation(selectedComponentName, st.getCurrentlyAnalyzedComponentTargetPlatform());

			// Clearing old information for imported functions

			importFunctionsArrayList.clear();

			// and also for exported ones

			exportFunctionsArrayList.clear();

			// Is currently used SDK configured?

			if(sdkInfo != null){

				// Export functions array list can be populated

				// if component is not an EXE file, because there

				// might exist EXE and DLL files with the same name,

				// and the export function information is only available

				// for DLLs. If EXE files were passed further, it would

				// give the information for the DLL with the same name.

				if(! isExeFile(selectedComponentName)){

					// For exported functions using always concrete component if available

					updateExportFunctionsArray(selectedComponentName);

				}				

			}

			// Checking if root component has been selected

			ComponentParentNode pNode = null;

			if(obj instanceof ComponentParentNode){

				pNode = (ComponentParentNode) obj;

				if(pNode.isRootComponent()){

					// Disabling action that are not valid for root component

					view.disableSetAsNewRootAction();

					// The showing of parent import functions

					// is not applicable for the root component

					// Just refreshing view when old imported

					// functions information has been cleared.

					refreshMainView();

					return;

				}

			}

			else if(obj instanceof ComponentLinkLeafNode){

				ComponentLinkLeafNode linkNode = (ComponentLinkLeafNode) obj;

				pNode = linkNode.getReferredComponent();

			}

			// Also link node can refer to root component

			if(pNode.isMissing() || pNode.isRootComponent()){

				view.disableSetAsNewRootAction();							

				view.enableLocateComponentAction();

			}

			else{

				view.enableSetAsNewRootAction();

				view.disableLocateComponentAction();

			}

			// Import functions can be fetched selected node is not root component

			updateImportFunctionsArray(selectedComponentOriginalName, parentComponentName);

			// Checks if there are unresolved import function names and if those can be fetched from export function data

			checkForUnresolvedImportFunctionNames();

			// Finally asking from main view that content providers gets updated data for showing.

			refreshMainView();

		}

		catch (CacheIndexNotReadyException e) {

			//

			// This may happen when no SDK selection has been made and therefore

			// no cache indexes has been created.

			// There is only single node in tree view with help text available

			// for selection that for sure raises this exception.

			//

			// => can be ignored safely

			//

		}

		catch (Exception e) {

			e.printStackTrace();

		}

	}

	/**

	 * Checks if there are unresolved import function names and if those can be fetched from export function data.

	 * This method does not have any effects if there are no unresolved imported functions, and if there are no

	 * exported function data available.

	 * @precondition if there are unresolved imported function names, there has to be valid exported functions data 

	 *               available for successful operation.

	 * @postcondition names of unresolved imported function names in <code>importFunctionsArrayList</code> are replaced 

	 *                by function names got from <code>exportFunctionsArrayList</code>.

	 */

	private void checkForUnresolvedImportFunctionNames() {

		// In case there is no exported data available, there is no use to continue the checking

		if(exportFunctionsArrayList.size() == 0) return;

		// Otherwise checking imported functions array for unresolved function names

		for (int i = 0; i < importFunctionsArrayList.size(); i++) {

			ImportFunctionData importFunc = importFunctionsArrayList.get(i);

			if(importFunc.getFunctionName().endsWith(CacheDataConstants.FUNC_NAME_NOT_RESOLVED)){

				String funcName = getFuncNameFromExportedFunctions(importFunc.getFunctionOrdinalAsInt()); 

				if(funcName !=  null){

					importFunc.setFunctionName(funcName);

				}

			}

		}

	}

	/**

	 * Gets function name from exported function array list with given ordinal. 

	 * @param ordinal function ordinal to get name for.

	 * @return Function name or <code>null</code> if cannot be resolved.

	 */

	private String getFuncNameFromExportedFunctions(int ordinal) {

		// If we have valid ordinal that exists also in exported functions data...

		if(ordinal > 0 && ordinal <= exportFunctionsArrayList.size()){

			//...returning the function name for it

			return exportFunctionsArrayList.get(ordinal-1).getFunctionName();

		}

		//  Could not found match from exported function data 

		return null;

	}

	/**

	 * Checks is given file name has EXE extension, or not.

	 * @param fileNameStr File name to be checked for.

	 * @return Returns <code>true</code> if file has EXE extension, 

	 *         otherwise <code>false</code>.

	 */

	private boolean isExeFile(String fileNameStr) {

		int extIndex = fileNameStr.lastIndexOf("."); //$NON-NLS-1$

		if(extIndex != -1){

			String extStr = fileNameStr.substring(extIndex+1, fileNameStr.length());

			if(extStr.equalsIgnoreCase("EXE")){ //$NON-NLS-1$

				return true;

			}

		}

		return false;

	}

	/**

	 * Performs refresh and other operation needed to

	 * run after refresh. 

	 */

	private void refreshMainView() {

		view.refresh();

		if(propertiesFoundSuccessfully){

			// This resizes value column which enables the seeing

			// of all the capabilities defined for the component.

			view.performValueColumnPackToPropertiesTab();			

		}

	}

	/**

	 * Updates importFunctionsArrayList with information that was found

	 * for the selected component.

	 * @param selectedComponentName Name of the component that has been selected.

	 * @param parentComponentName Parent component of the selected component.

	 * @throws FileNotFoundException

	 * @throws IOException

	 * @throws CacheIndexNotReadyException

	 * @throws CacheFileDoesNotExistException 

	 */

	private void updateImportFunctionsArray(String selectedComponentName, String parentComponentName) throws FileNotFoundException, IOException, CacheIndexNotReadyException, CacheFileDoesNotExistException {

		importFunctionsArrayList.clear(); // Making sure that array is cleared

		try {

			// Non-root component => seeking for the parent imported functions

			importFunctionsArrayList.addAll(

											MainViewDataPopulator.getParentImportedFunctionsForComponent(

																	parentComponentName,

																	selectedComponentName)

											);												             												

		} catch (Exception e) {

			// Catching exceptions here, because throwing them upper level would prevent fetching of component properties.

			e.printStackTrace();

		}

	}

	/**

	 * Updates property information for the currently

	 * selected component.

	 * @param selectedComponentName Name of the component that has been selected.

	 * @param targetPlatform Target platform restriction, or <code>null</code> if target platform does not matter.

	 * @return Returns <code>true</code> of component properties was found successfully, 

	 *         otherwise returns <code>false</code>.

	 * @throws IOException

	 * @throws CacheIndexNotReadyException

	 */

	private boolean updateComponentPropertyInformation(String selectedComponentName, ITargetPlatform targetPlatform) throws IOException, CacheIndexNotReadyException {

		boolean propertiesFound = false;

		try {

			ComponentPropertiesData comPropData = MainViewDataPopulator

														.getComponentPropertyArrayForComponent(selectedComponentName, targetPlatform);

			propertiesFound = true;

			view.setSelectedComponentPropertiesData(comPropData);

		} catch (NoSuchElementException e1) {

			// This can be ignored because there may be components 

			// that does not exist in cache at all

		} catch (java.lang.NullPointerException e1) {

			// This can be ignored because we'll get this if

			// currently used SDK is not yet configured and we

			// select the root node that just advices the user

			// to double-click the root node.

		} catch (CacheFileDoesNotExistException e2) {

			// This might happen during dialog to view transitions

			// When cache file does not exist yet.

		} catch (Exception e3) {

			e3.printStackTrace();

		}

		return propertiesFound;

	}

	/**

	 * Updates exportFunctionsArrayList with information that was found

	 * for the selected component.

	 * @param selectedComponentName Name of the component that has been selected.

	 * @throws FileNotFoundException

	 * @throws IOException

	 * @throws CacheIndexNotReadyException

	 * @throws CacheFileDoesNotExistException 

	 */

	private void updateExportFunctionsArray(String selectedComponentName) throws FileNotFoundException, IOException, CacheIndexNotReadyException, CacheFileDoesNotExistException {

		try {

			exportFunctionsArrayList.clear(); // Making sure that earlier results are destroyed

			// Populating with new data

			exportFunctionsArrayList.addAll(MainViewDataPopulator.getExportedFunctionsForComponent(selectedComponentName));

		} catch (NoSuchElementException e) {

			// The selected component does necessary

			// have any data about exported functions.

			// Therefore we can ignore this exception

		} catch (Exception e) {

			e.printStackTrace();

		}

	}	

}