/*

 * Copyright (c) 2008-2009 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:  Definitions for the class Util

 *

 */

package com.nokia.s60tools.analyzetool.global;

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.net.URL;

import java.nio.channels.FileChannel;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.Iterator;

import org.eclipse.cdt.core.model.ICModelMarker;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.FileLocator;

import org.eclipse.core.runtime.IBundleGroup;

import org.eclipse.core.runtime.IBundleGroupProvider;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

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.core.runtime.jobs.Job;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.dialogs.ListDialog;

import org.osgi.framework.Bundle;

import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;

import com.nokia.carbide.cdt.builder.DefaultMMPViewConfiguration;

import com.nokia.carbide.cdt.builder.EpocEngineHelper;

import com.nokia.carbide.cdt.builder.builder.CarbideCPPBuilder;

import com.nokia.carbide.cdt.builder.builder.CarbideCommandLauncher;

import com.nokia.carbide.cdt.builder.project.ICarbideBuildConfiguration;

import com.nokia.carbide.cdt.builder.project.ICarbideProjectInfo;

import com.nokia.carbide.cpp.epoc.engine.EpocEnginePlugin;

import com.nokia.carbide.cpp.epoc.engine.MMPDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.EMMPStatement;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPData;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.AcceptedNodesViewFilter;

import com.nokia.s60tools.analyzetool.Activator;

import com.nokia.s60tools.analyzetool.builder.AnalyzeToolBuilder;

import com.nokia.s60tools.analyzetool.engine.MMPInfo;

import com.nokia.s60tools.analyzetool.engine.UseAtool;

import com.nokia.s60tools.analyzetool.global.Constants.COMMAND_LINE_ERROR_CODE;

/**

 * Provides commonly used functions.

 *

 * @author kihe

 *

 */

public class Util {

    /** Contains user selection in the confirmation dialog. */

    private static boolean ret;

    /** Contains user selection (integer) in the selection dialog. */

    private static int retValue;

    /** Contains user selection (String) in the selection dialog. */

    private static String userSelection = "";

    /** Contains StringBuffer size. */

    private static int bufferSize = 32;

    /**

     * Checks is module built.

     *

     * @param modules

     *            Project modules

     * @param oneModuleName

     *            Current module

     * @return True if module found and it is build

     */

    public static boolean chechModuleBuildState(

            final AbstractList<MMPInfo> modules, final String oneModuleName) {

        Iterator<MMPInfo> iterModules = modules.iterator();

        while (iterModules.hasNext()) {

            MMPInfo oneMMPInfo = iterModules.next();

            String target = oneMMPInfo.getTarget();

            if (target == null) {

                continue;

            } else if (oneMMPInfo.getTarget().equalsIgnoreCase(oneModuleName)) {

                return oneMMPInfo.isBuildSuccesfully();

            }

            // target not found try remove {}

            // for example process name is

            // "AToolMemoryLeakerDll2.dll{000a0000}[04463b81]"

            // but target name is AToolMemoryLeakerDll2.dll

            CharSequence brace = "{";

            if (oneModuleName.contains(brace)) {

                // parse braces

                String tmpTargetName = oneModuleName.substring(0, oneModuleName

                        .indexOf('{'));

                if (tmpTargetName != null

                        && oneMMPInfo.getTarget().equalsIgnoreCase(

                                tmpTargetName)) {

                    return oneMMPInfo.isBuildSuccesfully();

                }

            }

        }

        return false;

    }

    /**

     * Checks is AnalyzeTool libraries installed from the current SDK.

     *

     * @param cpi

     *            {@link ICarbideProjectInfo} reference

     * @return True if libraries are installed otherwise false.

     */

    public static boolean checkAtoolLibs(final ICarbideProjectInfo cpi) {

        // get active platform

        String platform = cpi.getDefaultConfiguration().getPlatformString();

        // get epoc root

        IPath epocRootPath = EpocEngineHelper.getEpocRootForProject(cpi.getProject());

        //check that epocroot path found

        if( epocRootPath == null ) {

            return false;

        }

        String epocroot = epocRootPath.toOSString();

        boolean found = true;

        StringBuffer fileBuffer = new StringBuffer(bufferSize);

        fileBuffer.append(Constants.CAN_NOT_FIND_LIBRARIES_MARKER);

        fileBuffer.append(": ");

        if ((Constants.BUILD_TARGET_WINSCW).equalsIgnoreCase(platform)) {

            for (int i = 0; i < Constants.atoolLibsSbs2.length; i++) {

                java.io.File file = new java.io.File(epocroot

                        + Constants.atoolLibsWinscw[i]);

                if (!file.exists()) {

                    found = false;

                    fileBuffer.append(epocroot);

                    fileBuffer.append(Constants.atoolLibsWinscw[i]);

                    fileBuffer.append(' ');

                }

            }

        } else if ((Constants.BUILD_TARGET_ARMV5).equalsIgnoreCase(platform)) {

            if (AnalyzeToolBuilder.isSBSBuildActivated(cpi)) {

                for (int i = 0; i < Constants.atoolLibsSbs2.length; i++) {

                    java.io.File file = new java.io.File(epocroot

                            + Constants.atoolLibsSbs2[i]);

                    if (!file.exists()) {

                        found = false;

                        fileBuffer.append(epocroot);

                        fileBuffer.append(Constants.atoolLibsSbs2[i]);

                        fileBuffer.append(' ');

                    }

                }

            } else {

                for (int i = 0; i < Constants.atoolLibs.length; i++) {

                    java.io.File file = new java.io.File(epocroot

                            + Constants.atoolLibs[i]);

                    if (!file.exists()) {

                        found = false;

                        fileBuffer.append(epocroot);

                        fileBuffer.append(Constants.atoolLibs[i]);

                        fileBuffer.append(' ');

                    }

                }

            }

        }

        if (!found) {

            createErrorMarker(cpi.getProject(), fileBuffer.toString());

        }

        return found;

    }

    /**

     * Copies stored memory leak analysis file to given folder.

     *

     * @param resultFile

     *            Existing results file

     * @param targetPath

     *            Where to save xml file

     * @return True if copy success otherwise False

     */

    public static boolean copyFileToFolder(final String resultFile,

            final String targetPath) {

        FileChannel inputChannel = null;

        FileChannel ouputChannel = null;

        FileInputStream inStream = null;

        FileOutputStream outStream = null;

        boolean returnValue = true;

        try {

            // get channel to existing file

            inStream = new FileInputStream(resultFile);

            inputChannel = inStream.getChannel();

            // get channel to new file

            outStream = new FileOutputStream(targetPath, false);

            ouputChannel = outStream.getChannel();

            // get existing file size

            final long size = inputChannel.size();

            // position inside the file

            long position = 0;

            // copy file contents if there are data to copy

            while (position < size) {

                position += ouputChannel.transferFrom(inputChannel, position,

                        size - position);

            }

            // close opened channels

            inputChannel.close();

            inStream.close();

            ouputChannel.close();

            outStream.close();

        } catch (FileNotFoundException fnfe) {

            returnValue = false;

        } catch (IOException ioe) {

            returnValue = false;

        } finally {

            try {

                if (inputChannel != null) {

                    inputChannel.close();

                    inputChannel = null;

                }

            } catch (IOException ioe) {

                returnValue = false;

            }

            try {

                if (inStream != null) {

                    inStream.close();

                    inStream = null;

                }

            } catch (IOException ioe) {

                returnValue = false;

            }

            try {

                if (ouputChannel != null) {

                    ouputChannel.close();

                    ouputChannel = null;

                }

            } catch (IOException ioe) {

                returnValue = false;

            }

            try {

                if (outStream != null) {

                    outStream.close();

                    outStream = null;

                }

            } catch (IOException ioe) {

                returnValue = false;

            }

        }

        return returnValue;

    }

    /**

     * Creates AnalyzeTool related error marker for the selected project.

     *

     * @param project

     *            Project reference

     * @param errorText

     *            Error information

     */

    public static void createErrorMarker(final IProject project,

            final String errorText) {

        try {

            // check project validity

            if (project == null || !project.isOpen()) {

                return;

            }

            // create marker for the project

            IMarker marker = project

                    .createMarker(ICModelMarker.C_MODEL_PROBLEM_MARKER);

            if (marker.exists()) {

                // set marker attributes

                marker.setAttribute(IMarker.SEVERITY, IMarker.PRIORITY_HIGH);

                marker.setAttribute(IMarker.TEXT, errorText);

                marker.setAttribute(IMarker.MESSAGE, errorText);

            }

        } catch (CoreException ce) {

            // #ifdef DEBUG

            ce.printStackTrace();

            // #endif

        }

    }

    /**

     * Deletes existing data file.

     *

     * @param project

     *            Project reference

     */

    public static void deleteDataFile(final IProject project) {

        String bldInfFolder = getBldInfFolder(project, false);

        String dataFileLocation = bldInfFolder + Constants.FILENAME;

        java.io.File tmpFile = new java.io.File(dataFileLocation);

        if (tmpFile.exists()) {

            tmpFile.delete();

        }

        String xmlFileLocation = bldInfFolder + Constants.FILENAME_CARBIDE;

        java.io.File tmpXMLFile = new java.io.File(xmlFileLocation);

        if (tmpXMLFile.exists()) {

            tmpXMLFile.delete();

        }

        tmpFile = null;

        tmpXMLFile = null;

    }

    /**

     * Open file save dialog.

     *

     * @param title

     *            Save dialog title

     * @param ext

     *            Used extension filters

     *

     * @param shell

     *            Used Shell reference

     *

     * @return User selected path

     */

    public static String fileSaveDialog(final String title, final String[] ext,

            final Shell shell) {

        FileDialog fileDialog = new FileDialog(shell, SWT.SAVE);

        fileDialog.setText(title);

        fileDialog.setFilterExtensions(ext);

        return fileDialog.open();

    }

    /**

     * Gets atool.exe installation folder which is specified on preferences

     * page.

     *

     * @return Atool.exe installation folder

     */

    public static String getAtoolInstallFolder() {

        // get preference store

        IPreferenceStore store = Activator.getPreferences();

        // create new string buffer

        StringBuffer atoolInstallFolder = new StringBuffer();

        boolean useInternal = store.getBoolean(Constants.USE_INTERNAL);

        // append atool.exe installation folder

        String folder = store.getString(Constants.ATOOL_FOLDER);

        if (useInternal) {

            atoolInstallFolder.append(getDefaultAtoolLocation());

        } else if (("").equals(folder)) {

            store.setValue(Constants.USE_INTERNAL, true);

            atoolInstallFolder.append(getDefaultAtoolLocation());

        } else if (folder.equals(Constants.DEFAULT_ATOOL_FOLDER)) {

            java.io.File file = new java.io.File(Constants.DEFAULT_ATOOL_FOLDER);

            if (file.exists()) {

                atoolInstallFolder.append(Constants.DEFAULT_ATOOL_FOLDER);

            } else {

                store.setValue(Constants.USE_INTERNAL, true);

                atoolInstallFolder.append(getDefaultAtoolLocation());

            }

        } else {

            atoolInstallFolder.append(folder);

        }

        // append atool.exe to installation path

        atoolInstallFolder.append("\\atool.exe");

        return atoolInstallFolder.toString();

    }

    /**

     * Returns atool.exe version number Executes atool.exe via Process class and

     * parses atool.exe output to get version number.

     *

     * @param path

     *            Atool.exe path

     * @return Atool.exe version number if found otherwise "Not available"

     */

    public static String getAtoolVersionNumber(final String path) {

        BufferedInputStream br = null;

        try {

            // used atool.exe location

            String usedPath = null;

            // if path not given => use default location

            if (path == null) {

                usedPath = getDefaultAtoolLocation() + "\\atool.exe";

            }

            else if( path.contains("atool.exe") ){

                usedPath = path;

            }

            // else use given location

            else {

                usedPath = path + "\\atool.exe";

            }

            // command

            String[] args = { "cmd", "/c", usedPath, "-v" };

            // execute command

            Process pr = Runtime.getRuntime().exec(args);

            // get atool.exe response to buffer

            br = new BufferedInputStream(pr

                    .getInputStream());

            // wait that all the input is captured

            pr.waitFor();

            // create new stringbuffer for the input

            StringBuffer bf = new StringBuffer("");

            int r = -1;

            // read atool.exe response to stringbufffer

            while ((r = br.read()) != -1) {

                bf.append((char) r);

            }

            // because atool.exe response is following format

            // Version: [version number]

            // Path: [location]

            // Modified: [date and time]

            // we only need to get first row of response

            String[] array = bf.toString().split("\r\n");

            // check array

            if (array != null && array.length > 0) {

                String version = "Version:";

                // get first array

                String versionStr = array[0];

                // if first row contains "version:"

                if (versionStr.contains(version)) {

                    // get atool.exe version number

                    String atoolVersionNbr = versionStr.substring(version

                            .length() + 1, versionStr.length());

                    if( atoolVersionNbr == null || ("").equals(atoolVersionNbr ) ) {

                        return Constants.PREFS_ATOOL_VER_NOT_FOUND;

                    }

                    return atoolVersionNbr;

                }

            }

            br.close();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            try {

                if( br != null ) {

                    br.close();

                    br = null;

                }

            }catch( IOException ioe ) {

                ioe.printStackTrace();

            }

        }

        return Constants.PREFS_ATOOL_VER_NOT_FOUND;

    }

    /**

     * Returns the version number of the AnalyzeTool host-side feature, or "Unknown" if it cannot be determined

     * @return feature version string

     */

    public static String getAToolFeatureVersionNumber(){

    	String version = Constants.UNKNOWN;

    	IBundleGroupProvider[] providers = Platform.getBundleGroupProviders();

		if (providers != null) {

			for (IBundleGroupProvider bundleGroupProvider : providers) {

				for (IBundleGroup feature : bundleGroupProvider.getBundleGroups()) {

					if (feature.getIdentifier().equals("com.nokia.carbide.extensions.analyzetool")){

						version = feature.getVersion();

						break;

					}

				}

			}

		}

    	return version;

    }

    /**

     * Gets project bld.inf folder path.