/*
* 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.samplechecker.androidlabel.implementation;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

import org.eclipse.core.runtime.IStatus;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.motorolamobility.preflighting.core.applicationdata.ApplicationData;
import com.motorolamobility.preflighting.core.applicationdata.Element;
import com.motorolamobility.preflighting.core.applicationdata.Element.Type;
import com.motorolamobility.preflighting.core.applicationdata.ElementUtils;
import com.motorolamobility.preflighting.core.applicationdata.ResourcesFolderElement;
import com.motorolamobility.preflighting.core.applicationdata.StringsElement;
import com.motorolamobility.preflighting.core.applicationdata.XMLElement;
import com.motorolamobility.preflighting.core.checker.condition.CanExecuteConditionStatus;
import com.motorolamobility.preflighting.core.checker.condition.Condition;
import com.motorolamobility.preflighting.core.checker.condition.ICondition;
import com.motorolamobility.preflighting.core.devicespecification.DeviceSpecification;
import com.motorolamobility.preflighting.core.exception.PreflightingCheckerException;
import com.motorolamobility.preflighting.core.logging.PreflightingLogger;
import com.motorolamobility.preflighting.core.utils.CheckerUtils;
import com.motorolamobility.preflighting.core.validation.ValidationManagerConfiguration;
import com.motorolamobility.preflighting.core.validation.ValidationResult;
import com.motorolamobility.preflighting.core.validation.ValidationResultData;
import com.motorolamobility.preflighting.samplechecker.androidlabel.AndroidLabelActivator;
import com.motorolamobility.preflighting.samplechecker.androidlabel.i18n.AndroidLabelCheckerNLS;

/**
 * This Condition verifies whether a given text is a substring of the Android Application Label.
 * <br><br>
 * For this condition, a text is entered using the parameter labelText. In order to
 * have no warnings reported, all resources which the Android Application
 * Label points out, must have this parameter as a part of its name.
 */
public class CorrectTextInLabelCondition extends Condition implements ICondition
{
    /**
     * Represents the AndroidManifest.xml application node.
     */
    private static final String MANIFEST_TAG_APPLICATION = "application"; //$NON-NLS-1$

    /**
     * Represents the AndroidManifest.xml label property name.
     */
    private static final String MANIFEST_TAG_LABEL = "android:label"; //$NON-NLS-1$

    /**
     * Represents the prefix for String resources on the AndroidManifest.xml
     */
    private static final String ANDROID_STRING_IDENTIFIER = "@string/"; //$NON-NLS-1$

    private String parameterText;

    /**
     * Executes the {@link AndroidLabelChecker} validations, which are:
     * <ul>
     *  <li>The entered label must be contained in the default resource.</li>
     *  <li>The entered label must be contained in all alternative resources.</li>
     *  <li>In case the Application Label is declared inside AndroidManifest.xml, the entered label is contained in it.</li>
     * </ul>
     * 
     * @param data Data Structure of the Android Project. It serves for APKs and Android Projects.
     * @param deviceSpecs Device specifications for phones.
     * @param platformRules Rules and standards for the Android APi being used.
     * @param valManagerConfig App Validator Manager configuration.
     * @param results The results which will be returned from the validation performed in this method.
     * 
     * @throws PreflightingCheckerException Exception thrown when there are unexpected problems validating
     * the Android Application.
     */
    @Override
    public void execute(ApplicationData data, List<DeviceSpecification> deviceSpecs,
            ValidationManagerConfiguration valManagerConfig, ValidationResult results)
            throws PreflightingCheckerException
    {
        // get the label from AndroidManifest.xml
        XMLElement document = data.getManifestElement();
        Document manifestDoc = document.getDocument();
        Node labelNode = getLabelNode(manifestDoc);
        String androidLabelText = labelNode.getNodeValue();

        // get entered parameter
        AndroidLabelChecker checker = (AndroidLabelChecker) getChecker();
        parameterText =
                checker.getParameters().get(AndroidLabelChecker.PARAMETER_LABEL_TEXT).getValue();

        if (parameterText == null)
        {
            PreflightingLogger
                    .debug("Variable parameterText is null. Check if parameter \"labelText\" of checker androidLabel is being set.");
        }

        // handle case where the label is a resource identifier
        if (androidLabelText.startsWith(ANDROID_STRING_IDENTIFIER))
        {
            analyzeLocalizedLabel(data, valManagerConfig, results, document, androidLabelText);
        }
        else
        {
            // the label is a hard coded text, check the string itself
            analyzeHardcodedLabel(valManagerConfig, results, document, labelNode, androidLabelText);
        }
    }

    /**
     * Verify if the label value contains the parameterText. 
     */
    private void analyzeHardcodedLabel(ValidationManagerConfiguration valManagerConfig,
            ValidationResult results, XMLElement document, Node labelNode, String androidLabelText)
    {
        if ((parameterText != null)
                && !androidLabelText.toLowerCase().contains(parameterText.toLowerCase()))
        {
            List<Integer> lineList = new ArrayList<Integer>();
            int lineNumber = document.getNodeLineNumber(labelNode);
            if (lineNumber > 0) //Verify if line number is available.
            {
                lineList.add(lineNumber);
            }

            // create validation result - error structure
            ValidationResultData result =
                    createValidationResult(
                            AndroidLabelCheckerNLS.bind(
                                    AndroidLabelCheckerNLS.CorrectTextInLabelCondition_LabelNotContainedAndroidXML,
                                    parameterText),
                            AndroidLabelCheckerNLS
                                    .bind(AndroidLabelCheckerNLS.CorrectTextInLabelCondition_AddTextInLabel,
                                            parameterText), valManagerConfig, document,
                            parameterText, lineList);

            // add created result to the results list
            results.addValidationResult(result);
        }
    }

    /*
     * Verify if all string resources (from all locales) referred by the label resource identifier
     * contains the parameterText
     */
    private void analyzeLocalizedLabel(ApplicationData data,
            ValidationManagerConfiguration valManagerConfig, ValidationResult results,
            XMLElement document, String androidLabelText)
    {
        // get resource identifier
        String resId = androidLabelText.replace(ANDROID_STRING_IDENTIFIER, ""); //$NON-NLS-1$

        // get resource folder
        List<Element> folderResElements =
                ElementUtils.getElementByType(data.getRootElement(), Type.FOLDER_RES);
        ResourcesFolderElement resFolder =
                folderResElements.size() > 0 ? (ResourcesFolderElement) folderResElements.get(0)
                        : null;

        // check default locale
        StringsElement defaultElements = resFolder.getDefaultValuesElement();
        if (defaultElements != null)
        {
            Object value = defaultElements.getValue(resId);
            androidLabelText = (value != null) ? (String) value : ""; //$NON-NLS-1$

            // execute the checker condition - the entered text must be within the label
            if ((parameterText != null)
                    && !androidLabelText.toLowerCase().contains(parameterText.toLowerCase()))
            {
                // create validation result - error structure
                ValidationResultData result =
                        createValidationResult(
                                AndroidLabelCheckerNLS.bind(
                                        AndroidLabelCheckerNLS.CorrectTextInLabelCondition_LabelReferedAndroidXML,
                                        parameterText),
                                AndroidLabelCheckerNLS
                                        .bind(AndroidLabelCheckerNLS.CorrectTextInLabelCondition_LabelReferedAndroidXMLDefaultLocale,
                                                parameterText), valManagerConfig, document,
                                parameterText, new ArrayList<Integer>());

                // add created result to the results list
                results.addValidationResult(result);
            }
        }

        // check non-default locales
        if ((resFolder != null) && (resFolder.getAvailableLocales() != null)
                && (resFolder.getAvailableLocales().size() > 0))
        {
            for (Locale locale : resFolder.getAvailableLocales())
            {
                String localeText =
                        locale.getLanguage()
                                + ((locale.getCountry() != null)
                                        && (locale.getCountry().length() > 0)
                                        ? "_" + locale.getCountry() : ""); //$NON-NLS-1$ //$NON-NLS-2$

                // get the android label for each locale
                StringsElement stringsElement = resFolder.getValuesElement(locale);

                Object value = stringsElement.getValue(resId);
                androidLabelText = (value != null) ? (String) value : ""; //$NON-NLS-1$

                // execute the checker condition - the entered text must be within the label
                if (!androidLabelText.toLowerCase().contains(parameterText.toLowerCase()))
                {
                    // create validation result - error structure
                    ValidationResultData result =
                            createValidationResult(
                                    AndroidLabelCheckerNLS.bind(
                                            AndroidLabelCheckerNLS.CorrectTextInLabelCondition_LabelReferedAndroidXMLLocale,
                                            parameterText, localeText),
                                    AndroidLabelCheckerNLS
                                            .bind(AndroidLabelCheckerNLS.CorrectTextInLabelCondition_AddLabelAndroidXMLLocale,
                                                    parameterText, localeText), valManagerConfig,
                                    document, parameterText, new ArrayList<Integer>());

                    // add created result to the results list
                    results.addValidationResult(result);
                }
            }
        }
    }

    /**
     * In order to execute the checker, first several conditions must be verified.
     * <ul>
     *  <li>There must be an AndroidManifest.xml file in the Android Project.</li>
     *  <li>There must be a label in the AndroidManifest.xml file.</li>
     *  <li>There must be a value for the parameter labelText.</li>
     * </ul>
     * 
     * @param data Data structure holding all files, classes and resources of the
     * APK or Project.
     * @param deviceSpecs List of device specifications.
     * 
     * @return Returns the {@link IStatus} which states whether the Checker
     * can be run.
     * 
     * @throws PreflightingCheckerException Exception thrown in case there is any problem
     * verifying the conditions.
     */
    @Override
    public CanExecuteConditionStatus canExecute(ApplicationData data,
            List<DeviceSpecification> deviceSpecs) throws PreflightingCheckerException
    {
        // first check the manifest file status
        CanExecuteConditionStatus status =
                CheckerUtils.isAndroidManifestFileExistent(data, getId());

        // there must be parameters AndroidLabelChecker.PARAMETER_LABEL_TEXT set
        String labelParameterValue =
                getChecker().getParameters().get(AndroidLabelChecker.PARAMETER_LABEL_TEXT)
                        .getValue();
        if (labelParameterValue == null)
        {
            status =
                    new CanExecuteConditionStatus(IStatus.INFO, AndroidLabelActivator.PLUGIN_ID,
                            AndroidLabelCheckerNLS.CorrectTextInLabelCondition_NoEnteredParamWarn);
        }

        if (status.getSeverity() != IStatus.ERROR)
        {
            // there must be a parameter set
            AndroidLabelChecker checker = (AndroidLabelChecker) getChecker();
            if ((checker.getParameters() != null)
                    && checker.getParameters()
                            .containsKey(AndroidLabelChecker.PARAMETER_LABEL_TEXT))
            {

                XMLElement document = data.getManifestElement();
                Document manifestDoc = document.getDocument();

                // there must be a label in order to allow the checker execution
                Node labelNode = getLabelNode(manifestDoc);
                if ((labelNode != null) && (labelNode.getNodeValue() != null))
                {
                    status = new CanExecuteConditionStatus(IStatus.OK, getChecker().getId(), ""); //$NON-NLS-1$
                }
                else
                {
                    status =
                            new CanExecuteConditionStatus(
                                    IStatus.ERROR,
                                    AndroidLabelActivator.PLUGIN_ID,
                                    AndroidLabelCheckerNLS.CorrectTextInLabelCondition_AndroidXMlMustHaveLabelRunChecker);
                }
            }
            else
            {
                status =
                        new CanExecuteConditionStatus(
                                IStatus.ERROR,
                                AndroidLabelActivator.PLUGIN_ID,
                                AndroidLabelCheckerNLS.CorrectTextInLabelCondition_ExecuteCheckerEnterLabelText);
            }
        }

        status.setConditionId(getId());

        return status;
    }

    /**
     * Create the {@link ValidationResultData} which represents the error that
     * has occurred during the validation. It will be reported to the user.
     * 
     * @param issueDescription The description of the error.
     * @param quickFixSuggestion The quick-fix-suggestion for the error.
     * @param valManagerConfig App Validator Manager configuration.
     * @param document AndroidManifest.xml in a {@link Document} object.
     * @param parameterText The text entered by the user as a parameter.
     * @param lineList The list of lines where the error has occurred.
     * 
     * @return Returns the {@link ValidationResultData} which holds the error
     * to be displayed by the App Validator.
     */
    private ValidationResultData createValidationResult(String issueDescription,
            String quickFixSuggestion, ValidationManagerConfiguration valManagerConfig,
            XMLElement document, String parameterText, List<Integer> lineList)
    {
        ValidationResultData result = new ValidationResultData();
        result.setConditionID(getId());
        result.addFileToIssueLines(document.getFile(), lineList);
        result.setIssueDescription(issueDescription);
        result.setQuickFixSuggestion(quickFixSuggestion);
        result.setInfoURL("http://developer.motorola.com/docstools/library/motodev-app-validator/#androidLabel-findTextInLabel"); //$NON-NLS-1$
        result.setSeverity(getSeverityLevel());
        return result;
    }

    /**
     * Get the label {@link Node} from the AndroidManifext.xml file
     * represented as a {@link Document}.
     * <br>
     * In case nothing is found, <code>null</code> is returned.
     * 
     * @param manifestDoc AdnroidManifest.xml file as a {@link Document} where
     * the label will be sought.
     * 
     * @return Returns the AndroidManifest.xml label {@link Node}.
     */
    private Node getLabelNode(Document manifestDoc)
    {
        final int APPLICATION_NODE_INDEX = 0;

        Node labelNode = null;

        NodeList applicationNodes = manifestDoc.getElementsByTagName(MANIFEST_TAG_APPLICATION);

        // there must be one application note, get it
        Node applicationNode = applicationNodes.item(APPLICATION_NODE_INDEX);
        if (applicationNode != null)
        {
            // get label node
            labelNode = applicationNode.getAttributes().getNamedItem(MANIFEST_TAG_LABEL);
        }

        return labelNode;
    }
}