/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.motorolamobility.preflighting.core.internal.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipInputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.eclipse.core.runtime.Path;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.motorolamobility.preflighting.core.exception.PreflightingToolException;
import com.motorolamobility.preflighting.core.i18n.PreflightingCoreNLS;
import com.motorolamobility.preflighting.core.logging.PreflightingLogger;

public final class AaptUtils
{

    private static final String ANDROID_SMALL_SCREENS = "android:smallScreens";

    public static final String APP_VALIDATOR_TEMP_DIR = "MotodevAppValidator";

    private static final String JAVA_TEMP_DIR_PROPERTY = "java.io.tmpdir";

    private static final String TEMP_DIR_PATH = System.getProperty(JAVA_TEMP_DIR_PROPERTY);

    // Temp folder used for APK extracting
    public static final File tmpAppValidatorFolder =
            new File(TEMP_DIR_PATH, APP_VALIDATOR_TEMP_DIR);

    private static final String CLASSES_DEX = "classes.dex"; //$NON-NLS-1$

    private static final String RESOURCES_ARSC = "resources.arsc"; //$NON-NLS-1$

    private static final String XML_FILE = "xml"; //$NON-NLS-1$

    private static final String ELEMENT_NODE = "E:"; //$NON-NLS-1$

    private static final String ATTRIBUTE_NODE = "A:"; //$NON-NLS-1$

    private static final String NAMESPACE_XMLNS = "N:"; //$NON-NLS-1$

    private static HashMap<String, HashMap<String, String>> resourceValues =
            new HashMap<String, HashMap<String, String>>();

    private static Map<String, String> navigationMap;

    private static Map<String, String> nightMap;

    private static Map<String, String> keyboardMap;

    private static Map<String, String> touchMap;

    private static Map<String, String> densityMap;

    private static Map<String, String> sizeMap;

    private static Map<String, String> orientationMap;

    private static Map<String, String> longMap;

    private static Map<String, String> navHiddenMap;

    private static Map<String, String> keyHiddenMap;

    private static Map<String, String> typeMap;

    public static final String APK_EXTENSION = ".apk";

    public static final String ZIP_EXTENSION = ".zip";

    private static Map<Pattern, Map<String, String>> localizationAttributesMap2 =
            new HashMap<Pattern, Map<String, String>>();

    private static Map<Pattern, String> localizationAttributesMap1 = new HashMap<Pattern, String>();

    private static Pattern[] patternArray = new Pattern[18];

    static
    {
        // Initialize specific maps
        navigationMap = new HashMap<String, String>();
        navigationMap.put("1", "nonav");
        navigationMap.put("2", "dpad");
        navigationMap.put("3", "trackball");
        navigationMap.put("4", "wheel");

        nightMap = new HashMap<String, String>();
        nightMap.put("16", "notnight");
        nightMap.put("32", "night");

        keyboardMap = new HashMap<String, String>();
        keyboardMap.put("1", "nokeys");
        keyboardMap.put("2", "qwerty");
        keyboardMap.put("3", "12key");

        touchMap = new HashMap<String, String>();
        touchMap.put("1", "notouch");
        touchMap.put("2", "stylus");
        touchMap.put("3", "finger");

        densityMap = new HashMap<String, String>();
        densityMap.put("no", "nodpi");
        densityMap.put("120", "ldpi");
        densityMap.put("160", "mdpi");
        densityMap.put("240", "hdpi");

        sizeMap = new HashMap<String, String>();
        sizeMap.put("1", "small");
        sizeMap.put("2", "normal");
        sizeMap.put("3", "large");

        orientationMap = new HashMap<String, String>();
        orientationMap.put("1", "port");
        orientationMap.put("2", "land");
        orientationMap.put("3", "square");

        longMap = new HashMap<String, String>();
        longMap.put("16", "notlong");
        longMap.put("32", "long");

        navHiddenMap = new HashMap<String, String>();
        navHiddenMap.put("8", "navhidden");
        navHiddenMap.put("4", "navexposed");

        keyHiddenMap = new HashMap<String, String>();
        keyHiddenMap.put("1", "keyexposed");
        keyHiddenMap.put("2", "keyhidden");

        typeMap = new HashMap<String, String>();
        typeMap.put("3", "car");

        // initialize localization folder attributes
        // the order of patternArray elements are extremely important, do not
        // modify it
        localizationAttributesMap1.put(patternArray[0] = Pattern.compile("mcc=[0-9]+"), "mcc");
        localizationAttributesMap1.put(patternArray[1] = Pattern.compile("mnc=[0-9]+"), "mnc");
        localizationAttributesMap1.put(patternArray[2] = Pattern.compile("lang=[a-z]+"), "");
        localizationAttributesMap1.put(patternArray[3] = Pattern.compile("cnt=[A-Z]+"), "r");
        localizationAttributesMap2.put(patternArray[4] = Pattern.compile("sz=[0-9]"), sizeMap);
        localizationAttributesMap2.put(patternArray[5] = Pattern.compile("lng=[0-9]+"), longMap);
        localizationAttributesMap2.put(patternArray[6] = Pattern.compile("orient=[0-9]"),
                orientationMap);
        localizationAttributesMap2.put(patternArray[7] = Pattern.compile("type=[0-9]"), typeMap);
        localizationAttributesMap2.put(patternArray[8] = Pattern.compile("night=[0-9]+"), nightMap);
        localizationAttributesMap2.put(patternArray[9] = Pattern.compile("density=[0-9]+"),
                densityMap);
        localizationAttributesMap2.put(patternArray[10] = Pattern.compile("touch=[0-9]"), touchMap);
        localizationAttributesMap2.put(patternArray[11] = Pattern.compile("keyhid=[0-9]"),
                keyHiddenMap);
        localizationAttributesMap2
                .put(patternArray[12] = Pattern.compile("kbd=[0-9]"), keyboardMap);
        localizationAttributesMap2.put(patternArray[13] = Pattern.compile("navhid=[0-9]"),
                navHiddenMap);
        localizationAttributesMap2.put(patternArray[14] = Pattern.compile("nav=[0-9]"),
                navigationMap);
        localizationAttributesMap1.put(patternArray[15] = Pattern.compile("\\sw=[0-9]+"), "");
        localizationAttributesMap1.put(patternArray[16] = Pattern.compile("\\sh=[0-9]+"), "x");
        localizationAttributesMap1.put(patternArray[17] = Pattern.compile("sdk=[0-9]+"), "v");

    }

    /** 
     * Cleans resources maps among executions for applications
     */
    public static void cleanApplicationResourceValues()
    {
        resourceValues.clear();
    }

    public static void extractFilesFromAPK(File apkFile, String sdkPath, File tmpProjectFile)
            throws PreflightingToolException
    {
        if ((tmpProjectFile != null) && tmpProjectFile.exists() && tmpProjectFile.canWrite())
        {
            ZipInputStream apkInputStream = null;
            FileOutputStream apkOutputStream = null;
            try
            {
                // create the buffer and the the zip stream
                byte[] buf = new byte[1024];
                apkInputStream = new ZipInputStream(new FileInputStream(apkFile.getAbsolutePath()));

                ZipEntry apkZipEntry = null;
                try
                {
                    apkZipEntry = apkInputStream.getNextEntry();
                }
                catch (Exception e)
                {
                    PreflightingLogger.error(ApkUtils.class,
                            "It was not possible to read the android package.", e); //$NON-NLS-1$
                }

                if (apkZipEntry == null)
                {
                    throw new IOException("Invalid APK file.");
                }

                String folders = null;
                File fileToCreate = null;

                // create res folder
                fileToCreate = new File(tmpProjectFile, "res");
                if (!fileToCreate.exists())
                {
                    fileToCreate.mkdirs();
                }

                // create the resources file
                Map<File, Document> languageMap =
                        retrieveLocalizationStringsMapFromAPK(sdkPath, apkFile.getAbsolutePath(),
                                "ProjectResourcesValues.xml");
                createLocalizationFilesFromMap(languageMap, fileToCreate);

                // iterates through each entry to be extracted of the android
                // package
                while (apkZipEntry != null)
                {
                    try
                    {
                        String apkEntryName = apkZipEntry.getName();

                        if (apkEntryName.indexOf(Path.SEPARATOR) != -1)
                        {
                            // creates the directory structure
                            folders =
                                    apkEntryName.substring(0,
                                            apkEntryName.lastIndexOf(Path.SEPARATOR));
                            fileToCreate = new File(tmpProjectFile, folders);
                            if (!fileToCreate.exists())
                            {
                                fileToCreate.mkdirs();
                            }
                        }

                        if (apkEntryName.endsWith(XML_FILE))
                        {
                            // Gets XML from the parser
                            fileToCreate = new File(tmpProjectFile, apkEntryName);

                            createXMLFile(sdkPath, apkFile.getAbsolutePath(), apkEntryName,
                                    fileToCreate);
                        }
                        // filter files which is desired to create
                        else if (!apkEntryName.endsWith(RESOURCES_ARSC)
                                && !apkEntryName.endsWith(CLASSES_DEX))
                        {
                            // write the file
                            try
                            {
                                apkOutputStream =
                                        new FileOutputStream(tmpProjectFile.getAbsolutePath()
                                                + Path.SEPARATOR + apkEntryName);

                                int length = 0;
                                while ((length = apkInputStream.read(buf, 0, 1024)) > -1)
                                {
                                    apkOutputStream.write(buf, 0, length);
                                }
                            }
                            finally
                            {
                                if (apkOutputStream != null)
                                {
                                    try
                                    {
                                        apkOutputStream.close();
                                    }
                                    catch (IOException e)
                                    {
                                        //Do Nothing.
                                    }
                                }
                            }
                        }
                    }
                    catch (ZipException zipException)
                    {
                        // throw exception because the apk is probably corrupt
                        PreflightingLogger
                                .error(ApkUtils.class,
                                        "It was not possible to read the android package; it is probably corrupt.", zipException); //$NON-NLS-1$
                        throw new PreflightingToolException(
                                PreflightingCoreNLS.ApkUtils_ImpossibleExtractAndroidPackageMessage,
                                zipException);
                    }
                    catch (IOException ioException)
                    {
                        // log the error but do not thrown an exception because
                        // it will be attempted to create all files
                        PreflightingLogger.error(ApkUtils.class,
                                "It was not possible to extract the android package.", ioException); //$NON-NLS-1$
                    }
                    finally
                    {
                        apkInputStream.closeEntry();
                        apkZipEntry = apkInputStream.getNextEntry();
                    }
                }
            }
            catch (IOException ioException)
            {
                PreflightingLogger.error(ApkUtils.class,
                        "It was not possible to read the android package.", ioException); //$NON-NLS-1$
                throw new PreflightingToolException(
                        PreflightingCoreNLS.ApkUtils_ImpossibleExtractAndroidPackageMessage,
                        ioException);
            }
            finally
            {
                try
                {
                    if (apkInputStream != null)
                    {
                        apkInputStream.close();
                    }
                    if (apkOutputStream != null)
                    {
                        apkOutputStream.close();
                    }
                }
                catch (IOException ioException)
                {
                    // Do Nothing.
                }
            }

        }
        else
        {
            PreflightingLogger.error(ApkUtils.class,
                    "It was not possible to read the android package."); //$NON-NLS-1$
            throw new PreflightingToolException(
                    PreflightingCoreNLS.ApkUtils_ImpossibleExtractAndroidPackageMessage);
        }
    }

    /**
     * Given an APK file, all folders and DOMs for creating the directory
     * structure with the localization files are returned in a {@link Map}. <br>
     * The {@link Map} returned holds the following info: [{@link File},
     * {@link Document}] in which the {@link File} represents the folder path in
     * which the {@link Document} is to be created.
     * 
     * @param aaptPath
     *            AAP tool path.
     * @param apkPath
     *            APK file which the strings of translation are retrieved.
     * @param xmlFileName
     *            XML file name generated by the AAP tool.
     * 
     * @return The {@link Map} structure holding the {@link File}s and
     *         {@link Document}s necessary to create the directory tree for
     *         translation.
     * 
     * @throws PreflightingToolException
     *             Exception thrown in case anything goes wrong extracting data.
     */
    public static Map<File, Document> retrieveLocalizationStringsMapFromAPK(String aaptPath,
            String apkPath, String xmlFileName) throws PreflightingToolException
    {
        BufferedReader bReader = null;
        InputStreamReader reader = null;
        Map<File, Document> map = new HashMap<File, Document>();
        try
        {
            Process aapt =
                    runAAPTCommandForExtractingResourcesAndValues(aaptPath, apkPath, xmlFileName);

            // read output and store it in a buffer
            reader = new InputStreamReader(aapt.getInputStream());
            bReader = new BufferedReader(reader);

            // patterns used to retrieve lines for language, key and values of
            // string translations
            Pattern languagePattern = Pattern.compile("config\\s[0-9]+");
            Pattern stringKeyPattern =
                    Pattern.compile("[\\s]{2,}resource.+:string/[a-zA-Z0-9\\._$]+:");
            Pattern stringArrayKeyPattern =
                    Pattern.compile("[\\s]{2,}resource.+:array/[a-zA-Z0-9\\._$]+:");
            Pattern stringArrayCountPattern = Pattern.compile("Count=[0-9]+");
            Pattern stringValuePattern = Pattern.compile("\".*\"");

            Matcher matcher = null;
            Document document = null;
            Element resourceElement = null;
            Element stringElement = null;
            File languageDirectory = null;

            int stringArraySize = 0;

            String folderName = null;
            String stringArraySizeText = null;
            String key = null;
            String value = null;
            String[] arrayValue = null;

            String infoLine = "";
            while ((infoLine = bReader.readLine()) != null)
            {
                // try to match with language
                matcher = languagePattern.matcher(infoLine);
                if (matcher.find())
                {
                    // in case there are a document and file, add it to the map
                    if ((document != null) && (languageDirectory != null)
                            && (resourceElement != null)
                            && (resourceElement.getChildNodes() != null)
                            && (resourceElement.getChildNodes().getLength() > 0))
                    {
                        map.put(languageDirectory, document);
                        // reset them
                        languageDirectory = null;
                        document = null;
                    }

                    // get the folder name based on the language
                    folderName = createResourcesSubfolders(infoLine, "values");
                    languageDirectory = new File(folderName);

                    // try to find an existent directory
                    document = findDocumentByLanguageDirectory(map, languageDirectory);

                    // the DOM was not found - initialize variables
                    if (document == null)
                    {
                        document = createNewDocument();
                        resourceElement = document.createElement("resources");
                        document.appendChild(resourceElement);
                    }
                    // the DOM was found - get the resources element (root
                    // element)
                    else
                    {
                        resourceElement = document.getDocumentElement();
                    }
                }

                // try to match with single string keys
                matcher = stringKeyPattern.matcher(infoLine);
                if (matcher.find())
                {
                    key = matcher.group();
                    key = key.split(":string/")[1].split(":")[0];

                    infoLine = "";
                    do
                    {
                        // go the the next line in order to read the value
                        infoLine += bReader.readLine();
                    }
                    // do not delete the bReader.ready() statement because this avoids infinitive loops in case the regular expression fails
                    while (!infoLine.matches(".*\".*\".*") && bReader.ready());
                    matcher = stringValuePattern.matcher(infoLine);
                    if (matcher.find())
                    {
                        value = matcher.group();
                        value = value.substring(1, value.length() - 1);

                        // create element to be appended to the resource element
                        appendNewElementToNode("string", "name", key, value, resourceElement,
                                document);
                    }
                }

                // try to match with array string keys
                matcher = stringArrayKeyPattern.matcher(infoLine);
                if (matcher.find())
                {
                    key = matcher.group();
                    key = key.split(":array/")[1].split(":")[0];
                    // go the the next line in order to get the number of
                    // elements in the array
                    infoLine = bReader.readLine();
                    matcher = stringArrayCountPattern.matcher(infoLine);
                    if (matcher.find())
                    {
                        stringArraySizeText = matcher.group();
                        stringArraySize = Integer.parseInt(stringArraySizeText.split("=")[1]);
                        // get each string of the array
                        arrayValue = new String[stringArraySize];
                        for (int arrayStringIndex = 0; arrayStringIndex < stringArraySize; arrayStringIndex++)
                        {
                            try
                            {
                                // go the the next line in order to read the
                                // value
                                infoLine = bReader.readLine();
                                matcher = stringValuePattern.matcher(infoLine);
                                matcher.find();
                                value = matcher.group();
                                value = value.substring(1, value.length() - 1);
                            }
                            catch (Exception e)
                            {
                                // TODO fix this (for now, just keep going, but
                                // this value may be necessary in the future)
                                value = "(reference)";
                            }
                            arrayValue[arrayStringIndex] = value;
                        }

                        // append array-string element
                        stringElement =
                                appendNewElementToNode("string-array", "name", key, null,
                                        resourceElement, document);

                        // create and append the array of strings
                        for (int arrayStringIndex = 0; arrayStringIndex < stringArraySize; arrayStringIndex++)
                        {
                            value = arrayValue[arrayStringIndex];
                            appendNewElementToNode("item", null, null, value, stringElement,
                                    document);
                        }
                    }
                }
            }
            // in case there are a document and file, add it to the map
            if ((document != null) && (languageDirectory != null) && (resourceElement != null)
                    && (resourceElement.getChildNodes() != null)
                    && (resourceElement.getChildNodes().getLength() > 0))
            {
                map.put(languageDirectory, document);
                // reset them
                languageDirectory = null;
                document = null;
            }
        }
        catch (IOException ioException)
        {
            PreflightingLogger.error(ApkUtils.class, ioException.getMessage());
            throw new PreflightingToolException(ioException.getMessage(), ioException);
        }
        finally
        {
            // close resources
            if (reader != null)
            {
                try
                {
                    reader.close();
                }
                catch (IOException e)
                {
                    //Do Nothing.
                }
            }
            if (bReader != null)
            {
                try
                {
                    bReader.close();
                }
                catch (IOException e)
                {
                    //Do Nothing.
                }
            }
        }

        return map;
    }

    /**
     * Execute the AAPT command: aapt d --values resources [ApkFile].apk >
     * [XMLFileName].xml.
     * 
     * @param aaptPath
     *            AAPT path.
     * @param apkPath
     *            Target APK File path.
     * @param xmlFileName
     *            XML file name which will be generated.
     * 
     * @return The {@link Process} created the the execution of the AAPT
     *         command.
     * 
     * @throws IOException
     *             Exception thrown in case the command execution fails.
     */
    private static Process runAAPTCommandForExtractingResourcesAndValues(String aaptPath,
            String apkPath, String xmlFileName) throws IOException
    {
        // execute command: aapt.exe d --values resources <name>.apk <name>.xml
        String[] aaptCommand = new String[]
        {
                aaptPath, "d", "--values", "resources", apkPath, xmlFileName //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                };

        return Runtime.getRuntime().exec(aaptCommand);
    }

    /**
     * Put data from {@link Map}, created in method
     * {@link #retrieveLocalizationStringsMapFromAPK(String, String, String)}
     * into the /res directory using the given parameter {@link File}.
     * 
     * @param map
     *            {@link Map} which data will be extracted.
     * @param resFile
     *            {@link File} structure which will hold the tree model holding
     *            directories and translation files.
     * @throws PreflightingToolException
     */
    private static void createLocalizationFilesFromMap(Map<File, Document> map, File resFile)
            throws PreflightingToolException
    {
        Set<File> fileSet = map.keySet();
        File stringFolder = null;

        // iterate through all directories
        for (File key : fileSet)
        {
            // create temporary directories
            stringFolder = new File(resFile, key.getPath());
            if (!stringFolder.exists())
            {
                stringFolder.mkdirs();
            }
            // create XML file           
            createXmlFromDom(map.get(key), new File(resFile.getAbsolutePath() + Path.SEPARATOR
                    + key.getPath() + File.separator + "strings.xml"));
        }
    }

    /**
     * Create a XML File based on an AAPT output from a APK embedded file.
     * 
     * @param aaptPath
     *            AAPT path.
     * @param apkPath
     *            APK path.
     * @param xmlFileName
     *            the XML file name which is embedded in the APT and is to be
     *            created as an XML file.
     * @param fileToCreate
     *            XML file to be created.
     * 
     * @throws PreflightingToolException
     *             Exception thrown when there are problems creating the XML
     *             file. The exception message describe in details the problem.
     */
    public static void createXMLFile(String aaptPath, String apkPath, String xmlFileName,
            File fileToCreate) throws PreflightingToolException
    {
        // command for AAPT tool which gets the XML-to-be file to be worked on
        String[] aaptCommand = new String[]
        {
                aaptPath, "dump", "xmltree", apkPath, xmlFileName //$NON-NLS-1$ //$NON-NLS-2$
                };

        // execute AAPT command
        Process aapt = null;
        try
        {
            aapt = Runtime.getRuntime().exec(aaptCommand);
        }
        catch (IOException ioException)
        {
            PreflightingLogger.error(ApkUtils.class, "Problems executing AAPT command.", //$NON-NLS-1$
                    ioException);
            throw new PreflightingToolException(
                    PreflightingCoreNLS.ApkUtils_AaptExecutionProblemMessage, ioException);
        }

        Map<String, String> namespaceMap = new HashMap<String, String>();
        Map<Integer, LineElement> map =
                readToMap(aapt, aaptPath, apkPath, fileToCreate.getAbsolutePath(), namespaceMap);

        if (!map.isEmpty())
        {
            Integer outerRow = map.keySet().size();
            Integer innerRow;
            while (outerRow > 0)
            {
                LineElement childElement = map.get(outerRow);
                innerRow = outerRow - 1;
                while (innerRow > 0)
                {
                    LineElement parentElement = map.get(innerRow);
                    if (parentElement.getDepth() < childElement.getDepth())
                    {
                        parentElement.addChildLine(outerRow);
                        break;
                    }
                    innerRow--;
                }
                outerRow--;
            }

            // create new DOM
            Document document = createNewDocument();
            // populate it
            addNodes(document, map, map.get(1), null);
            // add schema
            for (String namespace : namespaceMap.keySet())
            {
                document.getDocumentElement().setAttribute("xmlns:" + namespace,
                        namespaceMap.get(namespace));
            }

            // create XML file
            createXmlFromDom(document, fileToCreate);
        }
    }

    /**
     * generate folder names according to configurations
     * 
     * @param lineRead
     *            line read from aapt output
     * @param folderPrefix
     *            The first name of all folders.
     * @return the directory name
     * @throws PreflightingToolException
     *             Exception thrown when the entered line has a bad format.
     */
    private static String createResourcesSubfolders(String lineRead, String folderPrefix)
            throws PreflightingToolException
    {
        Pattern configPattern = Pattern.compile("config\\s[0-9]");

        Matcher matcher = null;
        StringBuffer strBuf = new StringBuffer(lineRead);
        // try to match with type
        matcher = configPattern.matcher(strBuf);
        if (matcher.find())
        {
            for (int i = 0; i < 18; i++)
            {
                matcher = patternArray[i].matcher(strBuf);
                if (matcher.find())
                {
                    String result = matcher.group();
                    String value = result.split("=")[1];
                    // special treatment
                    if (localizationAttributesMap2.containsKey(patternArray[i]))
                    {
                        String nameSegment =
                                localizationAttributesMap2.get(patternArray[i]).get(value);
                        if (nameSegment != null)
                        {
                            folderPrefix += "-" + nameSegment;
                        }
                    }
                    else
                    {
                        String nameSegment =
                                localizationAttributesMap1.get(patternArray[i]) + value;
                        // treat the specific case of height, whose value is
                        // preceded by x egg. 1024x864
                        if (i != 16)
                        {
                            folderPrefix += "-" + nameSegment;
                        }
                        else
                        {
                            folderPrefix += nameSegment;
                        }
                    }
                }
            }
        }
        else
        {
            PreflightingLogger.error("The entered line has a bad format.");
            throw new PreflightingToolException("The entered line has a bad format.");
        }

        return folderPrefix;
    }

    /**
     * Create a XML file from a {@link Document}.
     * 
     * @param document
     *            Document to be turned into a XML File.
     * @param xmlFile
     *            XML file which will receive the {@link Document} stream.
     * 
     * @throws PreflightingToolException
     *             Exception thrown when there are problems creating the XML
     *             file.
     */
    private static void createXmlFromDom(Document document, File xmlFile)
            throws PreflightingToolException
    {

        StreamResult result = null;
        DOMSource source = null;
        Transformer transformer = null;
        FileOutputStream fo = null;
        StringWriter sw = null;

        try
        {
            // get factory
            TransformerFactory transformerFactory = TransformerFactory.newInstance();

            // get transformer and configure it
            transformer = transformerFactory.newTransformer();
            transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8"); //$NON-NLS-1$
            transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no"); //$NON-NLS-1$
            transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
            // create the XML file
            source = new DOMSource(document);
            sw = new StringWriter();
            result = new StreamResult(sw);
            transformer.transform(source, result);
            fo = new FileOutputStream(xmlFile);
            fo.write(sw.toString().getBytes("utf-8"));

        }
        catch (Exception ex)
        {
            //log error, but try to continue validation without the XML file with problem 
            PreflightingLogger.error(ApkUtils.class, "Problems creating the XML file.", ex); //$NON-NLS-1$            
        }
        finally
        {
            try
            {
                // Close streams and stuff
                if (fo != null)
                {
                    fo.close();
                }

                if (result.getWriter() != null)
                {
                    result.getWriter().close();
                }

                if (sw != null)
                {
                    sw.close();
                }

            }
            catch (IOException e)
            {
                // do nothing
            }
        }
    }

    /**
     * Create a new {@link Document}.
     * 
     * @return A newly-created {@link Document} object.
     * 
     * @throws PreflightingToolException
     *             Exception thrown when there are problems creating a new
     *             {@link Document}.
     */
    private static Document createNewDocument() throws PreflightingToolException
    {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder = null;
        try
        {
            documentBuilder = documentBuilderFactory.newDocumentBuilder();
        }
        catch (ParserConfigurationException pcException)
        {
            PreflightingLogger
                    .error(ApkUtils.class, "Problems creating DOM isntance.", pcException); //$NON-NLS-1$
            throw new PreflightingToolException(
                    PreflightingCoreNLS.ApkUtils_DomInstanceProblemMessage, pcException);
        }
        // create DOM
        Document document = documentBuilder.newDocument();
        return document;
    }

    /**
     * Create a Map holding the AAPT XML output info.
     * 
     * @param aaptProccess
     *            AAPT execution process - its data will be processed here
     * @param aaptPath
     *            APPT path
     * @param apkPath
     *            APK path
     * @param xmlFileName
     *            XML file name
     * 
     * @return The Map holding APPT XML output info.
     * 
     * @throws PreflightingToolException
     *             Exception thrown in case there are problems reading the APPT
     *             XML output info from the process.
     */
    public static Map<Integer, LineElement> readToMap(Process aaptProccess, String aaptPath,
            String apkPath, String xmlFileName, Map<String, String> namespaceMap)
            throws PreflightingToolException
    {
        InputStreamReader reader = new InputStreamReader(aaptProccess.getInputStream());
        BufferedReader bReader = new BufferedReader(reader);

        // list for the map
        List<LineElement> lineList = new ArrayList<LineElement>();
        LineElement lineElement;

        String infoLine;
        try
        {
            while ((infoLine = bReader.readLine()) != null)
            {
                if (infoLine.length() > 0)
                {
                    lineElement = new LineElement();
                    if (infoLine.contains(ELEMENT_NODE) || infoLine.contains(ELEMENT_NODE))
                    {
                        lineElement.setType(LineElement.LineType.ELEMENT);
                        lineElement.setDepth(infoLine.split(ELEMENT_NODE)[0].length());
                        lineElement.setName(getElementLineName(infoLine));
                        lineList.add(lineElement);
                    }
                    else if (infoLine.contains(ATTRIBUTE_NODE))
                    {
                        lineElement.setType(LineElement.LineType.ATTRIBUTE);
                        lineElement.setDepth(infoLine.split(ATTRIBUTE_NODE)[0].length());
                        lineElement.setName(getElementLineName(infoLine));
                        lineElement.setValue(getElementLineValue(aaptPath, apkPath, xmlFileName,
                                infoLine));
                        lineList.add(lineElement);
                    }
                    else if (infoLine.contains(NAMESPACE_XMLNS))
                    {
                        String namespace = infoLine.split(NAMESPACE_XMLNS)[1].trim();
                        if (namespace.indexOf("=") != -1)
                        {
                            String id = namespace.substring(0, namespace.indexOf("="));
                            String url = namespace.substring(namespace.indexOf("=") + 1);
                            namespaceMap.put(id, url);
                        }
                    }
                }
            }
        }
        catch (IOException ioException)
        {
            PreflightingLogger.error(ApkUtils.class,
                    "Problems reading AAPT command execution result.", ioException); //$NON-NLS-1$
            throw new PreflightingToolException(
                    PreflightingCoreNLS.ApkUtils_AaptResultReadProblemMessage, ioException);
        }
        finally
        {
            // close resources
            try
            {
                if (bReader != null)
                {
                    bReader.close();
                }
                if (reader != null)
                {
                    reader.close();
                }
            }
            catch (IOException ioException)
            {
                PreflightingLogger.error(ApkUtils.class,
                        "Problems reading AAPT command execution result.", ioException); //$NON-NLS-1$
                throw new PreflightingToolException(
                        PreflightingCoreNLS.ApkUtils_AaptResultReadProblemMessage, ioException);
            }
        }

        Map<Integer, LineElement> map = new HashMap<Integer, LineElement>();
        Integer counter = 0;
        for (LineElement elem : lineList)
        {
            ++counter;
            map.put(counter, elem);
        }
        return map;

    }

    /**
     * Get the Element Line?s Name from a text line. It could either be an
     * Element or an Attribute.
     * 
     * @param lineText
     *            Text Line where the Name will be retrieved.
     * 
     * @return Returns the Name.
     */
    private static String getElementLineName(String lineText)
    {
        Matcher matcher = null;
        Pattern pattern = null;
        String matchText = null;
        String name = null;

        // try to match the element pattern
        pattern = Pattern.compile("(E: .+ ){1}"); //$NON-NLS-1$
        matcher = pattern.matcher(lineText);
        // in case there is a match, populate the Line Element object
        if (matcher.find())
        {
            matchText = matcher.group();
            name = matchText.split(ELEMENT_NODE)[1].trim();
        }
        else
        {
            // try to match the attribute pattern
            pattern = Pattern.compile("(A:){1}"); //$NON-NLS-1$
            matcher = pattern.matcher(lineText);
            if (matcher.find())
            {
                // since there is an element pattern, get its name
                pattern = Pattern.compile("^ *A:\\s*[\\w:\\w]*"); //$NON-NLS-1$
                matcher = pattern.matcher(lineText);
                if (matcher.find())
                {
                    matchText = matcher.group();
                    // get the name
                    name = matchText.split(ATTRIBUTE_NODE)[1];
                    // adjust it
                    name = name.trim();
                }
            }
        }

        return name;
    }

    /**
     * Try to find the {@link Document} associated with a certain language
     * directory path. In case nothing is found, null is returned.
     * 
     * @param map
     *            {@link Map} in which the search will be made.
     * @param languageDirectory
     *            Directory holding the path to be compared, in order to find
     *            the {@link Document} in the given {@link Map}. This Object is
     *            updated with a reference to the object in the {@link Map}.
     * 
     * @return {@link Document} element associated, in case a match is
     *         successful.
     */
    private static Document findDocumentByLanguageDirectory(Map<File, Document> map,
            File languageDirectory)
    {
        Document document = null;
        Set<File> languageFolders = map.keySet();
        if (languageFolders != null)
        {
            for (File languageFolder : languageFolders)
            {
                if (languageFolder.getPath().equals(languageDirectory.getPath()))
                {
                    document = map.get(languageFolder);
                    languageDirectory = languageFolder;
                    break;
                }
            }
        }
        return document;
    }

    /**
     * Given a certain parent {@link Element} and {@link Document}, append a
     * child {@link Element} with Tag Name (which cannot be null), Node
     * Attribute Name, Node Attribute Value (which both are null at the same
     * time or none is null at all), Node Value (which can be null).
     * 
     * @param nodeTagName
     *            Node Tag Name.
     * @param nodeAttributeName
     *            Node Attribute Name.
     * @param nodeAttributeValue
     *            Node Attribute Value.
     * @param nodeValue
     *            Node Value.
     * @param elementToBeApppendedTo
     *            Parent {@link Element} which the new created {@link Element}
     *            will be appended to.
     * @param document
     *            {@link Document} which everything belongs to.
     * 
     * @return Returns the created {@link Element}.
     */
    private static Element appendNewElementToNode(String nodeTagName, String nodeAttributeName,
            String nodeAttributeValue, String nodeValue, Element elementToBeApppendedTo,
            Document document)
    {
        // create element and append it
        Element element = document.createElement(nodeTagName);
        if ((nodeAttributeName != null) && (nodeAttributeValue != null))
        {
            element.setAttribute(nodeAttributeName, nodeAttributeValue);
        }
        if (nodeValue != null)
        {
            element.setTextContent(nodeValue);
        }
        elementToBeApppendedTo.appendChild(element);

        return element;
    }

    /**
     * Add all attributes and children in a {@link Document}, given a
     * {@link LineElement}.
     * 
     * @param document
     *            DOM where elements are added.
     * @param map
     *            Map holding all {@link LineElement}s.
     * @param elem
     *            Element to be added to the DOM.
     * @param rootElement
     *            Root element.
     */
    private static void addNodes(Document document, Map<Integer, LineElement> map,
            LineElement elem, Element rootElement)
    {
        if (elem.getType() == LineElement.LineType.ELEMENT)
        {
            // add element or root
            Element element = document.createElement(elem.getName());
            if (rootElement == null)
            {
                document.appendChild(element);
            }
            else
            {
                rootElement.appendChild(element);
            }

            // add children
            for (Integer childElementMapIndex : elem.getChildLines())
            {
                LineElement childElement = map.get(childElementMapIndex);
                // add all attributes from this node
                if (childElement.getType() == LineElement.LineType.ATTRIBUTE)
                {
                    element.setAttribute(childElement.getName(), childElement.getValue());
                }
                // add a child element
                else
                {
                    addNodes(document, map, childElement, element);
                }

            }
        }
    }

    /**
     * Retrieve the Value of an Text line.
     * 
     * @param lineText
     *            Text line where the value will be retrieved from.
     * 
     * @return Value retrieved.
     */
    private static String getElementLineValue(String aaptPath, String apkPath, String xmlFileName,
            String lineText)
    {
        Matcher matcher = null;
        Pattern pattern = null;
        String matchText = null;
        String name = null;

        // Get the values, depending on their pattern

        // start with Raw values
        pattern = Pattern.compile("(\\(Raw: \".*\"\\)){1}"); //$NON-NLS-1$
        matcher = pattern.matcher(lineText);
        if (matcher.find())
        {
            matchText = matcher.group();
            // get the element within ""
            pattern = Pattern.compile("(\".*\"){1}"); //$NON-NLS-1$
            matcher = pattern.matcher(matchText);
            if (matcher.find())
            {
                matchText = matcher.group();
                name = matchText.replaceAll("\"", "").trim(); //$NON-NLS-1$ //$NON-NLS-2$
            }
        }
        else
        {
            // get values after @
            pattern = Pattern.compile("(\\)=@.*){1}"); //$NON-NLS-1$
            matcher = pattern.matcher(lineText);
            if (matcher.find())
            {
                matchText = matcher.group();
                name = matchText.replaceAll("\\)=@", "").trim(); //$NON-NLS-1$ //$NON-NLS-2$
                name = getResourceMatch(aaptPath, apkPath, xmlFileName, name);
            }
            else
            {
                // get values with type
                pattern = Pattern.compile("(\\(type .*\\).*){1}"); //$NON-NLS-1$
                matcher = pattern.matcher(lineText);
                if (matcher.find())
                {
                    matchText = matcher.group();
                    name = matchText.replaceAll("(\\(type .*\\))", ""); //$NON-NLS-1$ //$NON-NLS-2$
                    name = name.replace("0x", ""); //$NON-NLS-1$ //$NON-NLS-2$
                    try
                    {
                        long longValue = Long.parseLong(name, 16);
                        name = Long.toHexString(longValue).trim();

                        // TODO: correctly handle types instead of doing this kind of verification
                        if (lineText.contains(ANDROID_SMALL_SCREENS)
                                || lineText.contains("android:normalScreens")
                                || lineText.contains("android:largeScreens")
                                || lineText.contains("android:xlargeScreens")
                                || lineText.contains("android:anyDensity")
                                || lineText.contains("android:resizeable"))

                        {
                            name = longValue == 0 ? "false" : "true";
                        }

                    }
                    catch (NumberFormatException ex)
                    {
                        /*
                         * Do nothing because the number could not be converted
                         * to an integer. Leave it as it is to put in the XML
                         * file.
                         */
                    }
                }
            }
        }

        return name;
    }

    /**
     * Get the Resource reference from a @x value in the AAPT XML output.
     * 
     * @param aaptPath
     *            AAPT Path.
     * @param apkPath
     *            APK Path.
     * @param xmlFileName
     *            XML file Name
     * @param resourceId
     *            Resource Id which the value will be retrieved.
     * 
     * @return Value referenced by a resource Id.
     */
    private static String getResourceMatch(String aaptPath, String apkPath, String xmlFileName,
            String resourceId)
    {
        xmlFileName = xmlFileName.substring(xmlFileName.indexOf(".tmp") + 5);

        // we parse a xml file only once, so we check if its values are already
        // stored
        if (resourceValues.get(xmlFileName) == null)
        {
            HashMap<String, String> currentMap = new HashMap<String, String>();

            BufferedReader bReader = null;
            InputStreamReader reader = null;
            try
            {
                Process aapt =
                        runAAPTCommandForExtractingResourcesAndValues(aaptPath, apkPath,
                                xmlFileName);

                // read output and store it in a buffer
                reader = new InputStreamReader(aapt.getInputStream());
                bReader = new BufferedReader(reader);

                String infoLine = ""; //$NON-NLS-1$
                StringBuffer strBuf = new StringBuffer();
                while ((infoLine = bReader.readLine()) != null)
                {
                    strBuf.append(infoLine);
                    strBuf.append("\n"); //$NON-NLS-1$
                }

                // apply pattern to retrieve resource id and its value
                Pattern pattern =
                        Pattern.compile("resource\\s[0-9a-fxA-FX]+\\s[a-zA-Z_0-9.]+:[a-z0-9./_]+:"); //$NON-NLS-1$
                Matcher matcher = pattern.matcher(strBuf);

                Pattern keyPattern = Pattern.compile("\\s[0-9a-fxA-FX]+\\s"); //$NON-NLS-1$
                Pattern valuePattern = Pattern.compile(":[a-z0-9./_]+:"); //$NON-NLS-1$

                while (matcher.find())
                {
                    String match = matcher.group();
                    // key matcher
                    Matcher keyMatcher = keyPattern.matcher(match);
                    keyMatcher.find();
                    String key = keyMatcher.group();
                    key = key.trim();

                    // aapt output has a resource reference for each
                    // configuration
                    // e.g. a drawable resource can present three densities:
                    // hpdi, mpdi, lpdi
                    if (!currentMap.containsKey(key))
                    {
                        // value matcher
                        Matcher valueMatcher = valuePattern.matcher(match);
                        valueMatcher.find();
                        String value = valueMatcher.group();
                        value = "@" + value.substring(1, value.length() - 1); //$NON-NLS-1$

                        currentMap.put(key, value);
                    }
                }
                // store in global variable
                resourceValues.put(xmlFileName, currentMap);
            }
            catch (Exception e)
            {
                PreflightingLogger.error(ApkUtils.class, e.getMessage());
            }
            finally
            {
                if (reader != null)
                {
                    try
                    {
                        reader.close();
                    }
                    catch (IOException e)
                    {
                        //Do nothing.
                    }
                }
                if (bReader != null)
                {
                    try
                    {
                        bReader.close();
                    }
                    catch (IOException e)
                    {
                        //Do nothing.
                    }
                }
            }
        }

        return resourceValues.get(xmlFileName).get(resourceId);
    }
}

/**
 * Class which holds each line information from the AAPT XML output. 
 */
class LineElement
{

    /**
     * Enumerator which determines which type of the emement it is to be put in
     * the XML file.    
     */
    public enum LineType
    {
        ELEMENT, ATTRIBUTE
    }

    private final List<Integer> childLines = new ArrayList<Integer>();

    /**
     * Get the list of children indexes.
     * 
     * @return List of children indexes.
     */
    public List<Integer> getChildLines()
    {
        Collections.sort(childLines);
        return childLines;
    }

    /**
     * Add a child index representation.
     * 
     * @param index
     *            Child inex representation.
     */
    public void addChildLine(Integer index)
    {
        childLines.add(index);
    }

    private LineType type;

    /**
     * Get the {@link LineType}.
     * 
     * @return The {@link LineType}.
     */
    public LineType getType()
    {
        return type;
    }

    /**
     * Set the {@link LineType}.
     * 
     * @param type
     *            The {@link LineType}.
     */
    public void setType(LineType type)
    {
        this.type = type;
    }

    /**
     * Get the Name.
     * 
     * @return The name.
     */
    public String getName()
    {
        return name;
    }

    /**
     * Set the Name.
     * 
     * @param name
     *            The name.
     */
    public void setName(String name)
    {
        this.name = name;
    }

    /**
     * Get the node depth.
     * 
     * @return The node depth.
     */
    public int getDepth()
    {
        return depth;
    }

    /**
     * Set the node depth.
     * 
     * @param depth
     *            The node depth.
     */
    public void setDepth(int depth)
    {
        this.depth = depth;
    }

    private String name;

    private String value;

    /**
     * Get the Node value.
     * 
     * @return The node value.
     */
    public String getValue()
    {
        return value;
    }

    /**
     * Set the node value.
     * 
     * @param value
     *            The node value.
     */
    public void setValue(String value)
    {
        this.value = value;
    }

    private int depth;

}