/*
 * 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.helium.environment;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.tools.ant.Project;

import com.nokia.helium.environment.ant.types.ExecutableInfo;

/**
 * Represents the environment of the computer in terms of executables, etc. Typically scans for
 * executables that have been run during the build.
 */
public class Environment {
    private static final String[] WINDOWS_EXE_EXTENSIONS = { ".exe", ".bat", ".cmd" };
    private static final String STDERR_OUTPUT = "stderr";
    private static final String[] DEFAULT_EXECUTABLES = { "java", "ant" };

    private Project project;
    /** List of known executables. */
    private List<Executable> executables = new ArrayList<Executable>();
    /** List of meta information about executables. */
    private Map<String, ExecutableInfo> defs = new HashMap<String, ExecutableInfo>();

    public Environment(Project project) {
        this.project = project;
    }

    public void setExecutableDefs(List<ExecutableInfo> executableDefs) {
        for (Iterator<ExecutableInfo> iterator = executableDefs.iterator(); iterator.hasNext();) {
            ExecutableInfo execDef = (ExecutableInfo) iterator.next();
            defs.put(execDef.getName(), execDef);
        }
    }

    public List<Executable> getExecutables() {
        return executables;
    }

    public void scan(List<String> execCalls) throws IOException {
        addDefaultExecutables();
        parseExecLog(execCalls);
        addExecsWithInfo();
        populateExecutables(executables);
    }

    /**
     * Adds default executables to the list that must have been run because Ant is running.
     */
    private void addDefaultExecutables() {

        for (int i = 0; i < DEFAULT_EXECUTABLES.length; i++) {
            Executable exe = new Executable(DEFAULT_EXECUTABLES[i]);
            exe.setExecuted(true);
            executables.add(exe);
        }
    }

    /**
     * Parses a log of calls to executables in CSV format.
     * 
     * @param execLog
     * @throws IOException
     */
    private void parseExecLog(List<String> execCalls) throws IOException {
        for (Iterator<String> iterator = execCalls.iterator(); iterator.hasNext();) {
            String execCall = (String) iterator.next();

            File execFile = new File(execCall);
            String name = execFile.getName();
            String path = null;
            // See if the full path is available in the exec call
            if (execFile.getParentFile() != null) {
                path = execFile.getCanonicalPath();
            }
            Executable runExec = new Executable(name);
            runExec.setPath(path);
            runExec.setExecuted(true);
            if (!executables.contains(runExec)) {
                executables.add(runExec);
            }
        }
    }

    /**
     * Adds executables to the list based on the meta-information given in the configuration.
     */
    private void addExecsWithInfo() {
        for (Iterator<String> iterator = defs.keySet().iterator(); iterator.hasNext();) {
            String execName = (String) iterator.next();
            Executable exec = new Executable(execName);
            if (!executables.contains(exec)) {
                executables.add(exec);
            }
        }
    }

    private void populateExecutables(List<Executable> executables) throws IOException {
        for (Iterator<Executable> iterator = executables.iterator(); iterator.hasNext();) {
            Executable exec = (Executable) iterator.next();
            project.log("Checking executable: " + exec.toString(), Project.MSG_INFO);
            File executableFile = findExecutableFile(exec);

            if (executableFile != null) {
                if (!findVersion(exec)) {
                    calculateAdditionalVersioningInfo(exec);
                }
            }
            else {
                project.log("Cannot find path for executable: " + exec.toString(), Project.MSG_DEBUG);
            }
        }
    }

    /**
     * Finds an executable file based on the executable definition.
     * 
     * @param exec An executable definition.
     * @return The executable file.
     * @throws IOException
     */
    private File findExecutableFile(final Executable exec) throws IOException {
        File executableFile = null;

        // See if the executable has a full path
        String path = exec.getPath();
        if (path != null) {
            File file = new File(path);
            executableFile = file;
            exec.setPath(executableFile.getCanonicalPath());
        }
        // Or search the PATH
        else {
            String[] pathDirs = getPaths();
            // Filter object to match executable filenames
            FileFilter filter = new FileFilter() {
                public boolean accept(File file) {
                    if (isFileExecutable(file)) {
                        // Find the first file in the directory that has the same start of the name
                        String exeNameNoExt = exec.getNameNoExt();

                        String name = file.getName();
                        if (name.contains(".")) {
                            name = name.substring(0, name.indexOf("."));
                        }

                        if (name.equals(exeNameNoExt) || name.startsWith(exeNameNoExt + ".")) {
                            return true;
                        }
                    }
                    return false;
                }
            };
            for (int i = 0; i < pathDirs.length; i++) {
                File pathDir = new File(pathDirs[i]);
                File[] executableFiles = pathDir.listFiles(filter);
                if (executableFiles != null && executableFiles.length > 0) {
                    executableFile = executableFiles[0];
                    exec.setPath(executableFile.getCanonicalPath());
                }
            }
        }
        return executableFile;
    }

    private boolean isFileExecutable(File file) {
        if (file.canExecute()) {
            String os = System.getProperty("os.name").toLowerCase();
            if (os.contains("windows") || os.contains("win32")) {
                for (int i = 0; i < WINDOWS_EXE_EXTENSIONS.length; i++) {
                    if (file.getName().endsWith(WINDOWS_EXE_EXTENSIONS[i])) {
                        return true;
                    }
                }
            }
            else {
                return true;
            }
        }
        return false;
    }

    private String[] getPaths() {
        String pathEnvVar = System.getenv("Path");
        String[] pathDirs = null;
        if (pathEnvVar == null) {
            pathEnvVar = System.getenv("PATH");
        }
        if (pathEnvVar != null) {
            pathDirs = pathEnvVar.split(File.pathSeparator);
        }
        else {
            pathDirs = new String[0];
        }
        return pathDirs;
    }

    private boolean findVersion(Executable exec) throws IOException {
        // Get the executable additional data for this execution
        ExecutableInfo def = defs.get(exec.getNameNoExt());
        if (def != null && def.getVersionArgs() != null) {
            String path = exec.getPath();
            if (path == null) {
                path = "";
            }
            String[] versionArgs = def.getVersionArgs().split(" ");
            String[] commands = new String[versionArgs.length + 1];
            commands[0] = path;
            for (int i = 0; i < versionArgs.length; i++) {
                commands[i + 1] = versionArgs[i].trim();
            }
            Process commandProcess = Runtime.getRuntime().exec(commands);

            String output = def.getOutput();
            StringBuilder text = new StringBuilder();
            int dataRead = 0;
            char[] chars = new char[1000];
            if (output == null || !output.equals(STDERR_OUTPUT)) {
                InputStream in = commandProcess.getInputStream();
                InputStreamReader textIn = new InputStreamReader(in);
                while (dataRead != -1) {
                    dataRead = textIn.read(chars, 0, chars.length);
                    if (dataRead != -1) {
                        text.append(chars, 0, dataRead);
                    }
                }
            }
            InputStream err = commandProcess.getErrorStream();
            InputStreamReader textErr = new InputStreamReader(err);
            dataRead = 0;
            while (dataRead != -1) {
                dataRead = textErr.read(chars, 0, chars.length);
                if (dataRead != -1) {
                    text.append(chars, 0, dataRead);
                }
            }
            String versionText = text.toString();
            if (def.getVersionRegex() != null) {
                Pattern versionPattern = Pattern.compile(def.getVersionRegex());
                Matcher versionMatch = versionPattern.matcher(versionText);
                if (versionMatch.find()) {
                    String version = versionMatch.group(1);
                    exec.setVersion(version);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Calculate extra versioning info for the executable file. Used if cannot find a version value.
     * 
     * @param exec The executable.
     * @throws IOException If file cannot be read.
     */
    private void calculateAdditionalVersioningInfo(Executable exec) throws IOException {
        calculateHash(exec);
        File file = new File(exec.getPath());
        exec.setLastModified(file.lastModified());
        exec.setLength(file.length());
    }
    
    /**
     * Calculate a hash value for the executable file.
     * 
     * @param exec The executable.
     * @throws IOException If file cannot be read.
     */
    private void calculateHash(Executable exec) throws IOException {
        FileInputStream in = new FileInputStream(exec.getPath());
        byte[] bytes = new byte[1000];
        ByteArrayOutputStream fileBytes = new ByteArrayOutputStream();
        int bytesRead = 0;
        bytesRead = in.read(bytes);
        while (bytesRead != -1) {
            fileBytes.write(bytes, 0, bytesRead);
            bytesRead = in.read(bytes);
        }
        MessageDigest digest;
        String hash = "";
        try {
            digest = MessageDigest.getInstance("MD5");
            digest.update(fileBytes.toByteArray());
            byte[] hashBytes = digest.digest();
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < hashBytes.length; i++) {
                builder.append(Byte.toString(hashBytes[i]));
            }
            hash = new String(builder.toString());
            exec.setHash(hash);

        }
        catch (NoSuchAlgorithmException e) {
            // Not expected to occur
            e.printStackTrace();
        }
    }
}