/*
 *  Copyright 2012 Research In Motion Limited.
 *
 * 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.
 */
/*jshint sub:true*/
var fs = require("fs"),
    util = require('util'),
    xml2js = require('xml2js'),
    packagerUtils = require('./packager-utils'),
    check = require('validator').check,
    sanitize = require('validator').sanitize,
    localize = require("./localize"),
    logger = require("./logger"),
    fileManager = require("./file-manager"),
    utils = require("./packager-utils"),
    i18nMgr = require("./i18n-manager"),
    et = require("elementtree"),
    _config_doc,
    _self,
    _predefinedFeatures;

//This function will convert a wc3 paramObj with a list of
//<param name="" value=""> elements into a single object
function processParamObj(paramObj) {
    var processedObj = {},
        attribs,
        paramName,
        paramValue;

    if (paramObj) {
        //Convert to array for single param entries where only an object is created
        if (!Array.isArray(paramObj)) {
            paramObj = [paramObj];
        }

        paramObj.forEach(function (param) {
            attribs = param["@"];

            if (attribs) {
                paramName = attribs["name"];
                paramValue = attribs["value"];

                if (paramName && paramValue) {
                    //Add the key/value pair to the processedObj
                    processedObj[paramName] = paramValue;
                }
            }
        });
    }

    return processedObj;
}

function processFeatures(featuresArray, widgetConfig, processPredefinedFeatures) {
    var features = [],
        attribs;
    if (featuresArray) {
        featuresArray.forEach(function (feature) {
            attribs = feature["@"];
            if (attribs) {
                attribs.required = packagerUtils.toBoolean(attribs.required, true);

                // We do NOT want to auto defer networking and JavaScript if the
                // blackberry.push feature is being used
                if (attribs.id === "blackberry.push") {
                    widgetConfig.autoDeferNetworkingAndJavaScript = false;
                }

                if (_predefinedFeatures[attribs.id]) {
                    //Handle features that do NOT contain an API namespace
                    if (processPredefinedFeatures) {
                        _predefinedFeatures[attribs.id](feature, widgetConfig);
                    }
                } else {
                    features.push(attribs);
                }
            } else {
                features.push(attribs);
            }
        });
    }

    return features;
}

function createAccessListObj(uriOrOrigin, allowSubDomain) {
    return {
        uri: uriOrOrigin,
        allowSubDomain: allowSubDomain
    };
}

function processVersion(widgetConfig) {
    if (widgetConfig.version) {
        var versionArray = widgetConfig.version.split(".");

        //if 4rth number in version exists, extract for build id
        if (versionArray.length > 3) {
            widgetConfig.buildId = versionArray[3];
            widgetConfig.version = widgetConfig.version.substring(0, widgetConfig.version.lastIndexOf('.'));
        }
    }
}

function processBuildID(widgetConfig, session) {
    if (session.buildId) {
        //user specified a build id (--buildId), override any previously set build id
        widgetConfig.buildId = session.buildId;
    }
}

function processWidgetData(data, widgetConfig, session) {
    var attribs,
        featureArray,
        uriExist,
        originExist,
        header;

    if (data["@"]) {
        widgetConfig.version = data["@"].version;
        widgetConfig.id = data["@"].id;

        if (data["@"]["rim:header"]) {
            widgetConfig.customHeaders = {};
            header = data["@"]["rim:header"].split(":");
            // Just set it for now, in the future we can append them
            widgetConfig.customHeaders[header[0]] = header[1];
        }

        if (data["@"]["rim:userAgent"]) {
            widgetConfig.userAgent = data["@"]["rim:userAgent"];
        }
    }

    //Default values
    widgetConfig.hasMultiAccess = false;
    widgetConfig.accessList = [];
    widgetConfig.enableFlash = false;
    widgetConfig.autoOrientation = true;
    widgetConfig.autoDeferNetworkingAndJavaScript = true;
    widgetConfig.theme = "default";
    widgetConfig.autoHideSplashScreen = "true";

    //set locally available features to access list
    if (data.feature) {
        featureArray = packagerUtils.isArray(data.feature) ? data.feature : [data.feature];
    }

    //Handle features that do not have source code
    featureArray = processFeatures(featureArray, widgetConfig, true);

    //Push empty WIDGET_LOCAL access obj until whitelisting is cleaned up
    widgetConfig.accessList.push(createAccessListObj("WIDGET_LOCAL", true));

    //add whitelisted features to access list
    if (data.access) {
        //If there is only one access list element, it will be parsed as an object and not an array
        if (!packagerUtils.isArray(data.access)) {
            data.access = [data.access];
        }

        //check if uri and origin attributes are used
        data.access.forEach(function (accessElement, accessIndex) {
            attribs = accessElement["@"];

            if (attribs) {
                if (attribs.uri) {
                    uriExist = true;
                }
                if (attribs.origin) {
                    originExist = true;
                }
            }
        });
        if (uriExist === true && originExist === true) {
            logger.warn(localize.translate("WARNING_URI_AND_ORIGIN_FOUND_IN_CONFIG"));
        }

        data.access.forEach(function (accessElement) {
            attribs = accessElement["@"];

            if (attribs) {
                if (attribs.uri === "*" || attribs.origin === "*") {
                    if (accessElement.feature) {
                        throw localize.translate("EXCEPTION_FEATURE_DEFINED_WITH_WILDCARD_ACCESS_URI_OR_ORIGIN");
                    }
                    widgetConfig.hasMultiAccess = true;
                } else {
                    attribs.subdomains = packagerUtils.toBoolean(attribs.subdomains);
                    if (attribs.uri || attribs.origin) {
                        if (uriExist === true && originExist === true) {
                            widgetConfig.accessList.push(createAccessListObj(attribs.uri, attribs.subdomains)); //using uri attribute by default
                        } else {
                            widgetConfig.accessList.push(createAccessListObj(attribs.uri || attribs.origin, attribs.subdomains));
                        }
                    }
                }
            }
        });
    }
}

function trim(obj) {
    return (typeof obj === "string" ? obj.trim() : obj);
}

function processSplashScreenIconSrc(data, widgetConfig, key) {
    if (data[key]) {
        widgetConfig[key] = [];

        if (!(data[key] instanceof Array)) {
            data[key] = [data[key]];
        }

        data[key].forEach(function (obj) {
            if (obj["@"]) {
                widgetConfig[key].push(obj["@"].src);
            } else {
                widgetConfig[key].push(obj);
            }
        });
    }
}

function processSplashScreenData(data, widgetConfig) {
    //
    // This takes config.xml markup in the form of:
    //
    // <rim:splash src="splash-1280x768.jpg" />
    // <rim:splash src="splash-768x1280.jpg" />
    // <rim:splash src="splash-1024x600.jpg" />
    // <rim:splash src="splash-600x1024.jpg" />
    //
    // and turns it into:
    //
    // icon: ["splash-1280x768.jpg", "splash-768x1280.jpg", "splash-1024x600.jpg", "splash-600x1024.jpg"]
    //
    // Folder-based localization now done in i18n-manager
    //
    processSplashScreenIconSrc(data, widgetConfig, "rim:splash");
}

function processIconData(data, widgetConfig, session) {
    //
    // This takes config.xml markup in the form of:
    //
    // <icon src="icon-86.png" />
    // <icon src="icon-150.png" />
    //
    // and turns it into:
    //
    // icon: ["icon-86.png", "icon-150.png"]
    //
    // Folder-based localization now done in i18n-manager
    //
    var default_icon_filename = "default-icon.png",
        default_icon_src = session.conf.DEFAULT_ICON,
        default_icon_dst = session.sourceDir;

    processSplashScreenIconSrc(data, widgetConfig, "icon");

    if (!widgetConfig.icon) {
        packagerUtils.copyFile(default_icon_src, default_icon_dst);

        widgetConfig["icon"] = [];
        widgetConfig["icon"].push(default_icon_filename);
    }
}

function validateSplashScreensIcon(widgetConfig, key) {
    if (widgetConfig[key]) {
        var msg = localize.translate(key === "icon" ? "EXCEPTION_INVALID_ICON_SRC" : "EXCEPTION_INVALID_SPLASH_SRC");

        if (widgetConfig[key].length === 0) {
            // element without src attribute
            throw msg;
        } else {
            widgetConfig[key].forEach(function (src) {
                var msg2 = localize.translate(key === "icon" ? "EXCEPTION_INVALID_ICON_SRC_LOCALES" : "EXCEPTION_INVALID_SPLASH_SRC_LOCALES");

                // check that src attribute is specified and is not empty
                check(src, msg).notNull();

                // check that src attribute does not start with reserved locales folder
                src = src.replace(/\\/g, "/");
                check(src, msg2).notRegex("^" + i18nMgr.LOCALES_DIR + "\/");
            });
        }

    }
}

function processAuthorData(data, widgetConfig) {
    if (data.author) {
        var attribs = data.author["@"];

        if (!attribs && typeof data.author === "string") {
            //do not sanitize empty objects {} (must be string)
            widgetConfig.author = sanitize(data.author).trim();
        } else if (data.author["#"]) {
            widgetConfig.author = sanitize(data.author["#"]).trim();
        }

        if (attribs) {
            widgetConfig.authorURL = attribs.href;
            widgetConfig.copyright = attribs["rim:copyright"];
            widgetConfig.authorEmail = attribs.email;
        }
    }
}

function processLicenseData(data, widgetConfig) {
    if (data.license && data.license["#"]) {
        widgetConfig.license = data.license["#"];
    } else {
        widgetConfig.license = "";
    }

    if (data.license && data.license["@"]) {
        widgetConfig.licenseURL = data.license["@"].href;
    } else {
        widgetConfig.licenseURL = "";
    }
}

function processContentData(data, widgetConfig) {
    if (data.content) {
        var attribs  = data.content["@"],
            startPage;
        if (attribs) {
            widgetConfig.content = attribs.src;

            startPage = packagerUtils.parseUri(attribs.src);

            // if start page is local but does not start with local:///, will prepend it
            // replace any backslash with forward slash
            if (!packagerUtils.isAbsoluteURI(startPage) && !packagerUtils.isLocalURI(startPage)) {
                if (!startPage.relative.match(/^\//)) {
                    widgetConfig.content = "local:///" + startPage.relative.replace(/\\/g, "/");
                } else {
                    widgetConfig.content = "local://" + startPage.relative.replace(/\\/g, "/");
                }
            }

            widgetConfig.foregroundSource = attribs.src;
            widgetConfig.contentType = attribs.type;
            widgetConfig.contentCharSet = attribs.charset;
            widgetConfig.allowInvokeParams = attribs["rim:allowInvokeParams"];
            //TODO content rim:background
        }
    }
}

function processPermissionsData(data, widgetConfig) {
    if (data["rim:permissions"] && data["rim:permissions"]["rim:permit"]) {
        var permissions = data["rim:permissions"]["rim:permit"];

        if (permissions instanceof Array) {
            widgetConfig.permissions = permissions;
        } else {
            //user entered one permission and it comes in as an object
            widgetConfig.permissions = [permissions];
        }
    } else {
        widgetConfig.permissions = [];
    }

    // We do NOT want to auto defer networking and JavaScript if the
    // run_when_backgrounded permission is set
    if (widgetConfig.permissions.indexOf("run_when_backgrounded") >= 0) {
        widgetConfig.autoDeferNetworkingAndJavaScript = false;
    }
}

function processInvokeTargetsData(data, widgetConfig) {

    if (data["rim:invoke-target"]) {
        widgetConfig["invoke-target"] = data["rim:invoke-target"];

        //If invoke-target is not an array, wrap the invoke-target in an array
        utils.wrapPropertyInArray(widgetConfig, "invoke-target");

        widgetConfig["invoke-target"].forEach(function (invokeTarget) {
            if (invokeTarget.type && !packagerUtils.isEmpty(invokeTarget.type)) {
                invokeTarget.type = invokeTarget.type.toUpperCase();
            }

            if (invokeTarget.filter) {
                utils.wrapPropertyInArray(invokeTarget, "filter");

                invokeTarget.filter.forEach(function (filter) {

                    if (filter["action"]) {
                        utils.wrapPropertyInArray(filter, "action");
                    }

                    if (filter["mime-type"]) {
                        utils.wrapPropertyInArray(filter, "mime-type");
                    }

                    if (filter["property"]) {
                        utils.wrapPropertyInArray(filter, "property");
                    }
                });
            }
        });
    }
}

function validateConfig(widgetConfig) {
    check(widgetConfig.version, localize.translate("EXCEPTION_INVALID_VERSION"))
        .notNull()
        .regex("^[0-9]{1,3}([.][0-9]{1,3}){2,3}$");

    for (var prop in widgetConfig.name) {
        if (widgetConfig.name.hasOwnProperty(prop)) {
            check(widgetConfig.name[prop], localize.translate("EXCEPTION_INVALID_NAME")).notEmpty();
        }
    }

    check(widgetConfig.author, localize.translate("EXCEPTION_INVALID_AUTHOR")).notNull();
    check(widgetConfig.id, localize.translate("EXCEPTION_INVALID_ID")).notNull().notEmpty();

    validateSplashScreensIcon(widgetConfig, "rim:splash");

    validateSplashScreensIcon(widgetConfig, "icon");

    if (widgetConfig.accessList) {
        widgetConfig.accessList.forEach(function (access) {
            if (access.uri) {
                if (access.uri !== "WIDGET_LOCAL") {
                    check(access.uri, localize.translate("EXCEPTION_INVALID_ACCESS_URI_NO_PROTOCOL", access.uri))
                        .regex("^[a-zA-Z]+:\/\/");
                    check(access.uri, localize.translate("EXCEPTION_INVALID_ACCESS_URI_NO_URN", access.uri))
                        .notRegex("^[a-zA-Z]+:\/\/$");
                }
            }

            if (access.features) {
                // Assert each feature has a proper ID and is not empty
                access.features.forEach(function (feature) {
                    if (!feature) {
                        throw localize.translate("EXCEPTION_INVALID_FEATURE_ID");
                    }
                    check(feature.id, localize.translate("EXCEPTION_INVALID_FEATURE_ID")).notNull().notEmpty();
                });
            }

        });
    }

    if (widgetConfig["invoke-target"]) {

        widgetConfig["invoke-target"].forEach(function (invokeTarget) {

            check(typeof invokeTarget["@"] === "undefined",
                    localize.translate("EXCEPTION_INVOKE_TARGET_INVALID_ID"))
                .equals(false);
            check(invokeTarget["@"].id, localize.translate("EXCEPTION_INVOKE_TARGET_INVALID_ID"))
                .notNull()
                .notEmpty();
            check(invokeTarget.type, localize.translate("EXCEPTION_INVOKE_TARGET_INVALID_TYPE"))
                .notNull()
                .notEmpty();

            if (invokeTarget.filter) {

                invokeTarget.filter.forEach(function (filter) {

                    check(filter["action"] && filter["action"] instanceof Array && filter["action"].length > 0,
                            localize.translate("EXCEPTION_INVOKE_TARGET_ACTION_INVALID"))
                        .equals(true);

                    check(filter["mime-type"] && filter["mime-type"] instanceof Array && filter["mime-type"].length > 0,
                            localize.translate("EXCEPTION_INVOKE_TARGET_MIME_TYPE_INVALID"))
                        .equals(true);

                    if (filter.property) {
                        filter.property.forEach(function (property) {
                            check(property["@"] && property["@"]["var"] && typeof property["@"]["var"] === "string",
                                    localize.translate("EXCEPTION_INVOKE_TARGET_FILTER_PROPERTY_INVALID"))
                                .equals(true);
                        });
                    }
                });
            }
        });
    }
}

function processLocalizedText(tag, data, widgetConfig) {
    var tagData = data[tag],
        DEFAULT = 'default';

    function processLanguage(tagElement) {
        var attribs = tagElement['@'],
            language;

        if (attribs) {
            language = attribs['xml:lang'] || DEFAULT;
            widgetConfig[tag][language.toLowerCase()] = tagElement['#'];
        } else {
            widgetConfig[tag][DEFAULT] = tagElement;
        }
    }

    if (Array.isArray(tagData)) {
        //i.e. <element xml:lang="en">english value</element>
        //     <element xml:lang="fr">french value</element>
        tagData.forEach(processLanguage);
    } else if (tagData instanceof Object) {
        //i.e. <element xml:lang="en">english value</element>
        processLanguage(tagData);
    } else {
        //i.e <element>value</element>
        widgetConfig[tag][DEFAULT] = tagData;
    }
}

function processNameAndDescription(data, widgetConfig) {
    widgetConfig.name = {};
    widgetConfig.description = {};

    processLocalizedText('name', data, widgetConfig);
    processLocalizedText('description', data, widgetConfig);
}

function processCordovaPreferences(data, widgetConfig) {
    if (data.preference) {
        var preference = JSON.parse(JSON.stringify(processParamObj(data.preference)).toLowerCase()),
            hideFormControl = preference.hidekeyboardformaccessorybar;

        widgetConfig.packageCordovaJs = preference.packagecordovajs === "enable";
        widgetConfig.autoHideSplashScreen = preference.autohidesplashscreen !== "false";

        // <preference name="backgroundColor" value="hex" />
        if (preference.backgroundcolor) {
            widgetConfig.backgroundColor = processBgColor(preference.backgroundcolor);
        }

        // <preference name="childBrowser" value="enable or disable" />
        if (preference.childbrowser) {
            widgetConfig.enableChildWebView = (preference.childbrowser === 'disable') === false;
        }

        // <preference name="HideKeyboardFormAccessoryBar" value="enable/true or disable/false" />
        if (preference.hidekeyboardformaccessorybar) {
            widgetConfig.enableFormControl = (hideFormControl !== 'enable') && (hideFormControl !== 'true');
        }

        // <preference name="popupBlocker" value="enable or disable" />
        if (preference.popupblocker) {
            widgetConfig.enablePopupBlocker = (preference.popupblocker === 'enable') === true;
        }

        // <preference name="orientation" value="portrait, landscape, north, auto or default" />
        if (preference.orientation) {
            if (preference.orientation ===  "landscape" || preference.orientation === "portrait" || preference.orientation === "north") {
                widgetConfig.autoOrientation = false;
                widgetConfig.orientation = preference.orientation;
            } else if (preference.orientation !== "auto" && preference.orientation !== "default") {
                throw localize.translate("EXCEPTION_INVALID_ORIENTATION_MODE", preference.orientation);
            }
        }

        // <preference name="theme" value="bright, dark, inherit or default" />
        if (preference.theme && (typeof preference.theme === "string")) {
            if (preference.theme ===  "bright" || preference.theme === "dark" || preference.theme === "inherit" || preference.theme ===  "default") {
                widgetConfig.theme = preference.theme;
            }
        }

        // <preference name="webSecurity" value="enable or disable" />
        if (preference.websecurity && (typeof preference.websecurity === "string") && (preference.websecurity === "disable")) {
            widgetConfig.enableWebSecurity = false;
            logger.warn(localize.translate("WARNING_WEBSECURITY_DISABLED"));
        }

        // <preference name="diskCache" value="enable or disable" />
        if (preference.diskcache) {
            widgetConfig.enableDiskCache = (preference.diskcache === 'enable');
        }
    }
}

function processBgColor(bgColor) {
    //convert bgColor to a number
    var bgColorNum = parseInt(bgColor, 16);

    if (isNaN(bgColorNum)) {
        //bgColor is not a number, throw error
        throw localize.translate("EXCEPTION_BGCOLOR_INVALID", bgColor);
    } else {
        return bgColorNum;
    }
}

function processResult(data, session) {
    var widgetConfig = {};

    processWidgetData(data, widgetConfig, session);
    processIconData(data, widgetConfig, session);
    processAuthorData(data, widgetConfig);
    processLicenseData(data, widgetConfig);
    processContentData(data, widgetConfig);
    processPermissionsData(data, widgetConfig);
    processInvokeTargetsData(data, widgetConfig);
    processSplashScreenData(data, widgetConfig);
    processNameAndDescription(data, widgetConfig);
    processCordovaPreferences(data, widgetConfig);

    widgetConfig.configXML = "config.xml";

    //validate the widgetConfig
    validateConfig(widgetConfig);

    //special handling for version and grabbing the buildId if specified (4rth number)
    processVersion(widgetConfig);

    //if --buildId was specified, it takes precedence
    processBuildID(widgetConfig, session);

    //store any config-file element injections
    widgetConfig.configFileInjections = _config_doc.findall("config-file");

    return widgetConfig;
}

function init() {
    //Predefined features are features that do NOT contain an API namespace
    _predefinedFeatures = {
        "enable-flash" : function (feature, widgetConfig) {
            widgetConfig.enableFlash = true;
        },
        "blackberry.app.orientation": function (feature, widgetConfig) {
            if (feature) {
                var params = processParamObj(feature.param),
                    mode = params.mode;

                if (!mode) {
                    //No mode provided, throw error
                    throw localize.translate("EXCEPTION_EMPTY_ORIENTATION_MODE", mode);
                } else if (mode === "landscape" || mode === "portrait" || mode === "north") {
                    widgetConfig.autoOrientation = false;//Overwrites default value
                    widgetConfig.orientation = mode;
                } else if (mode !== "auto") {
                    //Mode invalid, throw error
                    throw localize.translate("EXCEPTION_INVALID_ORIENTATION_MODE", mode);
                }

                // Throw a warning since this feature is deprecated
                logger.warn(localize.translate("WARNING_ORIENTATION_DEPRECATED"));
            }
        }
    };
}

_self = {
    parse: function (xmlPath, session, callback) {
        if (!fs.existsSync(xmlPath)) {
            throw localize.translate("EXCEPTION_CONFIG_NOT_FOUND");
        }

        var fileData = fs.readFileSync(xmlPath),
            xml = utils.bufferToString(fileData),
            parser = new xml2js.Parser({trim: true, normalize: true, explicitRoot: false});

        //Used for config-file injections
        _config_doc = new et.ElementTree(et.XML(xml));

        init();

        //parse xml file data
        parser.parseString(xml, function (err, result) {
            if (err) {
                logger.error(localize.translate("EXCEPTION_PARSING_XML"));
                fileManager.cleanSource(session);
            } else {
                callback(processResult(result, session));
            }
        });
    }
};

module.exports = _self;