matriz.utils = {
    "date": {
        /**
         * Formato de data e hora
         */
        DATE_TIME_FORMAT: "DD/MM/YYYY HH:mm",
        /**
         * Valida o intervalo de duas datas
         * @param {object} $inputDateTimeStart Data inicial
         * @param {object} $inputDateTimeEnd Data final
         * @returns {Boolean} Retorna se intervalo é válido
         */
        validateInterval: function ($inputDateTimeStart, $inputDateTimeEnd) {
            if ($inputDateTimeStart.val() !== "" && $inputDateTimeEnd.val() !== "") {
                var momentStart = moment($inputDateTimeStart.val(), matriz.utils.date.DATE_TIME_FORMAT);
                var momentEnd = moment($inputDateTimeEnd.val(), matriz.utils.date.DATE_TIME_FORMAT);
                return momentStart.isBefore(momentEnd) || momentStart.isSame(momentEnd);
            } else {
                return true;
            }
        },
        format: function (date) {
            return moment(date).format(matriz.utils.date.DATE_TIME_FORMAT);
        }
    },
    "dom": {
        "attributes": function (element, pattern, removePattern) {
            var attributes = {};
            for (var i = 0; i < element.attributes.length; i++) {
                if (!pattern || pattern.test(element.attributes.item(i).nodeName)) {
                    var key = element.attributes.item(i).nodeName;
                    if (removePattern) {
                        key = key.replace(pattern, "");
                    }
                    attributes[key] = element.attributes.item(i).value || element.attributes.item(i).nodeValue;
                }
            }
            return attributes;
        }
    },
    file: {
        extensao: function (file) {
            return ((file.name).split('.').pop()).toLowerCase();
        },
        toTamanhoExtenso: function (filesize) {
            var sizes = ["Bytes", "KBytes", "MBytes", "GBytes", "TBytes", "PBytes", "EBytes", "ZBytes", "YBytes"];
            for (var i = 0; i < sizes.length && filesize > 1024; i++) {
                filesize = filesize / 1024;
            }
            var size = String(Math.ceil(filesize * 100));
            return size.substr(0, size.length - 2) + "," + size.substr(size.length - 2, 2) + " " + sizes[i];
        },
        toNomeCurto: function(filename) {
            var indexOfPoint = filename.lastIndexOf(".");
            var name = filename.substr(0, indexOfPoint);
            var extension = filename.substr(indexOfPoint);
            return name.substr(0, 32) + extension;
        },
        readImageFromFile: function (file) {
            var deferred = $.Deferred();

            var image = new Image();
            image.onload = function () {
                try {
                    deferred.resolve(image);
                } catch (error) {
                    deferred.reject(error);
                }
            };

            var reader = new mOxie.FileReader();
            reader.onloadend = function () {
                image.src = reader.result;
            };

            reader.readAsDataURL(file);

            return deferred.promise();
        },
        readFileAsArrayBuffer: function(file) {
            var deferred = $.Deferred();
            var reader = new FileReader();
            reader.onloadend = function (e) {
                deferred.resolve(reader.result);
            };
            reader.onerror = function (errorEvent) {
                var error = new Error();
                error.errorEvent = errorEvent;
                deferred.reject(error);
            };
            try {
                reader.readAsArrayBuffer(file);
            } catch (error) {
                deferred.reject(error);
            }
            return deferred.promise();
        },
        arrayBufferToBase64: function(arrayBuffer) {
            var binary = '';
            var bytes = new Uint8Array(arrayBuffer);
            var len = bytes.byteLength;
            for (var i = 0; i < len; i++) {
                binary += String.fromCharCode(bytes[ i ]);
            }
            return btoa(binary);
        }
    },
    "string": {
        "consts": {
            "PAD_RIGHT": "PAD_RIGHT",
            "PAD_LEFT": "PAD_LEFT"
        },
        "isInt": function (value) {
            return /^-?[0-9]+$/.test(value);
        },
        "pad": function (val, minlen, char, type) {
            val = '' + val;
            var padstring = (new Array(minlen + 1)).join(char);
            if (val.length < minlen) {
                if (!type || type === matriz.utils.string.consts.PAD_LEFT) {
                    return (padstring + val).substring((padstring + val).length - minlen);
                } else if (type && type === matriz.utils.string.consts.PAD_RIGHT) {
                    return (val + padstring).substring(0, minlen);
                }
            } else {
                return val;
            }
        },
        "toNonAccentCase": function (string) {
            var alphabet = {
                from: 'ÀÁÄÂÃÈÉËÊÌÍÏÎÒÓÖÔÕÙÚÜÛÑÇàáäâãèéëêìíïîòóöôõùúüûñç',
                to: 'AAAAAEEEEIIIIOOOOOUUUUNCaaaaaeeeeiiiiooooouuuunc'
            };

            for (var i = 0; i < alphabet.from.length; i++) {
                string = string.replace(new RegExp(alphabet.from.charAt(i), 'g'), alphabet.to.charAt(i));
            }

            return string;
        },
        "toCodigoExterno": function (string) {
            return matriz.utils.string.toNonAccentCase(string)
                    .toLowerCase()
                    .replace(/[^a-z0-9]+/g, "");
        },
        "truncarTexto": function (texto, separador, maxlength) {
            var textoTruncado = "";
            var afrases = texto.split(separador);
            if (texto.substr(0, maxlength).indexOf(separador) !== -1) {
                for (var i = 0; i < afrases.length; i++) {
                    if ((textoTruncado + afrases[i] + separador).length <= maxlength) {
                        textoTruncado = textoTruncado + afrases[i] + separador;
                    } else {
                        break;
                    }
                }
                return textoTruncado;
            } else {
                return null;
            }
        }
    },
    "form": {
        "serialize": function (form) {
            var formData = $(form).serializeArray();

            for (var i in formData) {
                if (formData[i].name.toLowerCase() === "conteudo[texto]") {
                    formData[i].value = btoa(unescape(encodeURIComponent(formData[i].value)));
                    break;
                }
            }

            return formData;
        },
        "serializeForm": function (form) {
            var data = {};
            var formData = $(form).serializeArray();

            for (var key in formData) {
                data[formData[key].name] = formData[key].value;
            }

            return data;
        },
        post: function (options) {
            var deferred = $.Deferred();

            matriz.ui.loading.modal.show();

            var xhr = new mOxie.XMLHttpRequest();
            xhr.onload = function (e) {
                if (parseInt(xhr.status) >= 200 && parseInt(xhr.status) < 300) {
                    deferred.resolve(xhr);
                } else {
                    var error = new Error(xhr.responseText);
                    error.xhr = xhr;
                    deferred.reject(error);
                }
            };

            var formData = new mOxie.FormData();
            for (var key in options.data) {
                formData.append(key, options.data[key]);
            }

            var data = matriz.utils.form.serializeForm(options.form);
            for (var key in data) {
                formData.append(key, data[key]);
            }

            xhr.open("POST", $(options.form).attr("action"));
            xhr.send(formData);

            return deferred.promise();
        }
    },
    ajax: function (options) {
        if (options.modal !== true) {
            matriz.ui.loading.modal.show();
        }

        if (!options.headers) {
            options.headers = {'X-Requested-With': 'XMLHttpRequest'};
        }
        
        var promise = $.ajax(options).fail(function (xhr) {
            matriz.ajax.messages.fail.default(xhr, xhr.statusText);
            matriz.ui.loading.modal.hide();
        });
        
        // para fins de compatibilidade foi implementado um decorador no metodo done da promise do ajax do jquery
        // o decorador executa a funcao de callback desejada pelo cliente e apos executa a a inicializacao do ui do matriz 'matriz.ui.init.common'
        var super_done = promise.done;
        promise.done = function(callback_done) {
            super_done(function() {
                callback_done.apply(this, arguments);
                matriz.ui.init.common();
            });
            
            return promise;
        };
        
        promise.success = promise.done;
        
        return promise;
    },
    history: {
        isIllegalPopState: null,
        location: null,
        change: function (href, modal) {
            if (modal !== true) {
                if (!href.endsWith(location.pathname.concat(location.search))) {
                    this.pushState({}, href);
                }
            }
        },
        pushState: function (state, href) {
            state = state || {};
            
            if (history.pushState) {
                state.referrer = location.href;
                history.pushState(state, null, href);
            }
            
            matriz.utils.history.onPushState({ state: state });
        },
        replace: function(href) {
            this.replaceState({}, href);
        },
        replaceState: function(state, href) {
            state = state || {};
            
            if (history.replaceState) {
                state.referrer = location.href;
                history.replaceState(state, null, href);
            }
        },
        onPopState: function () {
            if (matriz.utils.history.isIllegalPopState) {
                matriz.utils.history.isIllegalPopState = false;
            } else {
                if (matriz.utils.history.location !== matriz.utils.history.getCurrentLocation()) {
                    location.reload();
                }
                
                matriz.utils.history.changeCurrentLocation();
            }
        },
        onPushState: function() {
            matriz.utils.history.changeCurrentLocation();
        },
        onHashChange: function() {},
        getCurrentLocation: function() {
            return location.pathname.concat(location.search);
        },
        changeCurrentLocation: function() {
            matriz.utils.history.location = matriz.utils.history.getCurrentLocation();
        },
        onLoad: function () {
            matriz.utils.history.isIllegalPopState = matriz.utils.navigator.isSafari();
            matriz.utils.history.changeCurrentLocation();
        }
    },
    regex: {
        escape: function (s) {
            return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
        }
    },
    url: {
        param: function (name, url) {
            if (!url) {
                url = window.location.href;
            }
            var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(url);
            if (!results) {
                return undefined;
            }
            return results[1] || undefined;
        },
        params: function () {
            if (location.search.length > 1) {
                var params = {};
                var searchFields = location.search.substr(1).split("&");
                for (var key in searchFields) {
                    var searchFieldsValue = searchFields[key].split("=");
                    var fieldName = decodeURIComponent(searchFieldsValue[0]);
                    if (fieldName.indexOf("[]") !== -1) {
                        fieldName = fieldName.split("[]")[0];
                        if (typeof params[fieldName] === "undefined") {
                            params[fieldName] = [];
                        }
                        params[fieldName].push(decodeURIComponent(searchFieldsValue[1]));
                    } else {
                        params[fieldName] = decodeURIComponent(searchFieldsValue[1]);
                    }
                }
                return params;
            }
        },
        paramsToForm: function ($form) {
            var params = matriz.utils.url.params();
            if (params) {
                for (var paramName in params) {
                    if (Array.isArray(params[paramName])) {
                        var $input = $form.find(":input[name='" + paramName + "[]']");
                    } else {
                        var $input = $form.find(":input[name='" + paramName + "']");
                    }
                    if ($input) {
                        var paramValue = params[paramName];
                        paramValue = paramValue.replace(/\+/g, " ");
                        $input.val(paramValue);
                        if ($input.hasClass("matriz-ui-combobox")) {
                            $input.selectpicker("refresh");
                        }
                    }
                }
            }
        },
        serializePagedListFilter: function($form) {
            var $data = $form.find(":input").filter(function () {
                if (($(this).is("select")) && !($(this).prop("multiple"))) {
                    if ($(this).find("option:selected").filter("[selected]").length) {
                        return false;
                    }

                    if (($(this).find("option:eq(0):selected").length) && !($(this).find("option[selected]").length)) {
                        return false;
                    }

                    return true;
                }
                return $(this).val() !== '';
            });
            return $data.serialize();
        },
        search: function ($form) {
            var locationHref = location.href.replace(location.search, "").replace("?", "");
            var locationSearch = this.serializePagedListFilter($form);

            if (locationSearch) {
                locationHref = locationHref.concat("?").concat(locationSearch);
            }

            matriz.utils.history.change(locationHref, $form.parents().filter(".modal").length > 0);
        }
    },
    "storage": {
        "session": {
            getItem: function (key) {
                var item = sessionStorage.getItem(key);
                if (item) {
                    item = JSON.parse(item);
                }
                return item;
            },
            setItem: function (key, value) {
                sessionStorage.setItem(key, JSON.stringify(value));
            },
            removeItem: function(key) {
                sessionStorage.removeItem(key);
            },
            getAttribute: function (key, attributeName) {
                var item = matriz.utils.storage.session.getItem(key);
                if (item !== null && item[attributeName]) {
                    item = item[attributeName];
                }
                return item;
            },
            setAttribute: function (key, attributeName, value) {
                var item = matriz.utils.storage.session.getItem(key);
                if (item === null) {
                    item = {};
                }
                item[attributeName] = value;
                matriz.utils.storage.session.setItem(key, item);
            }
        },
        "local": {
            getItem: function (key) {
                var item = localStorage.getItem(key);
                if (item) {
                    item = JSON.parse(item);
                }
                return item;
            },
            setItem: function (key, value) {
                localStorage.setItem(key, JSON.stringify(value));
            },
            removeItem: function(key) {
                localStorage.removeItem(key);
            }
        }
    },
    navigator: {
        isMobile: function () {
            if (navigator.userAgent.match(/Android/i)
                    || navigator.userAgent.match(/webOS/i)
                    || navigator.userAgent.match(/iPhone/i)
                    || navigator.userAgent.match(/iPad/i)
                    || navigator.userAgent.match(/iPod/i)
                    || navigator.userAgent.match(/BlackBerry/i)
                    || navigator.userAgent.match(/Windows Phone/i)) {
                return true;
            } else {
                return false;
            }
        },
        isAndroid: function () {
            return navigator.userAgent.match(/Android/i);
        },
        isSafari: function () {
            return navigator.userAgent.match(/Safari/i) && !navigator.userAgent.match(/Chrome/i);
        }
    },
    script: {
    	load: function(url, callback) {
    		var script = document.createElement("script");
    	    script.type = "text/javascript";
	    	script.onload = callback;
    	    document.getElementsByTagName("head")[0].appendChild(script);
    	    script.src = url;
    	},
        append: function(url, document) {
            if (document === undefined) {
                document = window.document;
            }
            var script = document.createElement("script");
            script.async = false;
            script.src = url;
            document.querySelector("body").appendChild(script);
            var deferred = $.Deferred();
            script.onload = function() {
                deferred.resolve();
            };
            return deferred.promise();
        }
    },
    hash : {
        hexStringToSHA256String: function(string) {
            return CryptoJS.SHA256(string).toString(CryptoJS.enc.Hex);
        },
        arrayBufferToSHA256String: function(arrayBuffer) {
            var wordArray = CryptoJS.lib.WordArray.create(arrayBuffer);
            return CryptoJS.SHA256(wordArray).toString(CryptoJS.enc.Hex);
        }
    },
    internationalization: {
        translate: function(term, context) {
            context = context === undefined ? "default" : context;
            if (this.dictionary[context] !== undefined && this.dictionary[context][term] !== undefined) {
                return this.dictionary[context][term];
            } else {
                return term;
            }
        },
        dictionary: {} /*carregado na master.tpl*/
    }
};

window.onload = matriz.utils.history.onLoad;
window.onpopstate = matriz.utils.history.onPopState;
window.onhashchange = matriz.utils.history.onHashChange;