/**
* Alguns mtodos destas classes foram baseados nos métodos do YUI,
* com melhoras e atualizaes.
*/

if (typeof ICore == 'undefined') {
    ICore = { };
}

/**
 * Se a página já carregou.
 */
ICore.pageLoaded = false;

/**
 * Método que trata de herdar uma classe da outra
 * @param {Function} subc
 * @param {Function} superc
 * @param {Object} overrides
 */
ICore.extend = function(subc, superc, overrides) {
    if (!superc||!subc) {
        throw new Error("Erro, classes não definidas.");
    }
    var F = function() {};
    F.prototype=superc.prototype;
    subc.prototype=new F();
    subc.prototype.constructor=subc;
    subc.superclass=superc.prototype;
    if (superc.prototype.constructor == Object.prototype.constructor) {
        superc.prototype.constructor=superc;
    }

    if (overrides) {
        for (var i in overrides) {
            subc.prototype[i]=overrides[i];
        }
        if (ICore.nav.isIE) {
            var add=["toString", "valueOf"];
            for (i=0;i<add.length;i=i+1) {
                var fname=add[i],f=overrides[fname];
                if (ICore.util.isFunction(f) && f!=Object.prototype[fname]) {
                    subc.prototype[fname]=f;
                }
            }
        }
    }
};

/**
 * Objeto que trata a de diferenciar os navegadores.
 * @type {Object}
 */
ICore.nav = {
    isIE: (navigator.userAgent.indexOf('MSIE') > -1),
    isIE55: (navigator.userAgent.indexOf('MSIE 5.5') > -1),
    isIE6: (navigator.userAgent.indexOf('MSIE 6') > -1),
    isFF: (navigator.userAgent.indexOf('Firefox') > -1),
    isOpera: (navigator.userAgent.indexOf('Opera') > -1)
};

/**
 * Constantes com os eventos.
 * @type {Object}
 */
ICore.events = {
    LOAD: 'load',
    UNLOAD: 'unload',
    CLICK: 'click',
    DBLCLICK: 'dblclick',
    MOUSEDOWN: 'mousedown',
    MOUSEUP: 'mouseup',
    MOUSEMOVE: 'mousemove',
    MOUSEOVER: 'mouseover',
    MOUSEOUT: 'mouseout',
    KEYDOWN: 'keydown',
    KEYUP: 'keyup',
    KEYPRESS: 'keypress'
};

/**
 * Coleção de exeções do sistema.
 */
ICore.exceptions = {
    abort: function () { }
};

/**
 * Objeto que trata da interação e implementação de operações com os elementos.
 * 
 * @type {Object}
 */
ICore.dom = {
    /**
    * Faz uma busca no documento por um elemento com o ID informado.
    *
    * @param {String} id ID que ser buscado.
    */
    get: function (id) {
        return document.getElementById(id);
    },

    /**
    * Faz uma busca no documento por um elemento com a TagName igual
    * ao parametro passado.
    *
    * Retorna um array de HTMLElement.
    *
    * @param {String} tagname
    * @return {HTMLElement[]}
    */
    getByTag: function (tagname, parent) {
        if (!parent) {
            parent = document;
        }
        return parent.getElementsByTagName(tagname);
    },

    /**
    * Faz uma busca no documento por um elemento que
    * contenha a classe informada no parametro em sua
    * lista.
    *
    * Retorna uma lista de HTMLElement.
    *
    * @param {String} classname
    * @return {HTMLElemet[]}
    */
    getByClass: function (classname, parent) {
        if (ICore.util.isUndefined(parent)) {
            parent = document;
        }
        var me = this;
        return this.findChild(parent, function (el) {
            return me.findClassName(classname, el);
        });
    },

    /**
    * Cria um elemento.
    *
    * @param {String} tname
    * @return {HTMLElement}
    */
    createEl: function (tagname) {
        return document.createElement(tagname);
    },

    /**
    * Adiciona uma elemento dentro de outro criado.
    *
    * @param {HTMLElement} el Elemento pai no qual o parametro child deve ser inserido.
    * @param {HTMLElement} child Filho que ser inserido.
    * @return {HTMLElement}
    */
    appendChild: function (el, child) {
        return el.appendChild(child);
    },

    /**
    * Cria um elemento de texto e o insere no objeto.
    *
    * @param {HTMLElement} el
    * @param {String} text
    */
    appendText: function (el, text) {
        var child = document.createTextNode(text);
        return this.appendChild(child);
    },

    /**
    * Remove um elemento dentro de outro.
    *
    * @param {HTMLElement} el Elemento pai.
    * @param {HTMLElement} child Elemento que ser removido.
    * @return {HTMLElement}
    */
    removeChild: function (el, child) {
        return el.removeChild(child);
    },

    /**
    * Altera a opacidade de um elemento.
    *
    * @param {HTMLElement} el
    * @param {Float} opacity Valor entre 0 (zero) e 1 (um).
    */
    setOpacity: function (el, opacity) {
        if (ICore.nav.isIE) { // IE First by more navigators
            el.style.filter = 'filter:alpha(opacity='+(opacity*100)+')';
        } else if (ICore.nav.isFF) {
            el.style.mozOpacity = opacity;
        } else {
            el.style.opacity = opacity;
        }
    },

    /**
    * Esta classe verifica se uma classe (do css) está aplicada a um
    * elemento.
    *
    * @param {String} classname
    * @param {String} classes
    * @return {Integer}
    */
    findClassName: function (classname, classes) {
        if (typeof classes != 'string') {
            classes = classes.className;
        }
        if (classes) {
            var c = classes.split(' ');
            return (c.indexOf(classname) > -1);
        } else {
            return false;
        }
    },

    /**
    * Adiciona uma classe na lista de classes de um objeto.
    *
    * @param {HTMLObject} obj
    * @param {String} class
    */
    addClass: function (obj, c) {
        var cls;
        if (obj.className) {
            cls = obj.className.split(' ');
        } else {
            cls = [];
        }
        if (cls.indexOf(c) == -1) {
            obj.className = obj.className + (obj.className === ''?'':' ') + c;
        }
    },

    /**
    * Remove uma classe na lista de classes de um objeto.
    *
    * @param {HTMLObject} obj
    * @param {String} class
    */
    removeClass: function (obj, c) {
        var cls = obj.className.split(' ');
        var i = cls.indexOf(c);
        if (i > -1) {
            cls.splice(i, 1);
            obj.className = cls.join(' ');
        }
    },
    
    /**
     * Lista de funções listeners de eventos.
     * 
     * @type {Array}
     */
    listeners: [],
    
    /**
     * Busca no array {ICore.dom.listeners} se um elemento já está inserido. 
     * 
     * @param {HTMLElement} el Elemento ao qual o evento será adicionado
     * @param {String} event Evento que será adicionado
     * @param {Function} fnc Função que será chamada
     * @param {Object} obj Objeto que será o "this" na função chamada.
     */
    findListener: function (el, event, fnc, obj) {
        var l;
        for (var i = 0; i < this.listeners.length; i++) {
            l = this.listeners[i];
            if ((l.el == el) && (event == l.event) && (fnc == l.fnc) && (obj == l.obj)) {
                return i;
            }
        }
        return -1;
    },

    /**
    * Adicionar a função para ser chamada quando o evento for disparado.
    *
    * @param {HTMLElement} el
    * @param {String} event
    * @param {Function} fnc
    * @param {obj} obj Objeto que será o "this" na função chamada, caso não especificado será o proprio el
    */
    addListener: function (el, event, fnc, obj) {
        el = ICore.util.object(el);
        if (obj) {
            wfnc = function (e) {
                e = e || event; // Fix para algum problema de versão do IE.
                fnc.call(obj, e);
            };
            this.listeners.push({el:el, event:event, fnc:fnc, obj:obj, wfnc: wfnc});
            this.addListener(el, event, wfnc);
        } else {
            if (el) {
                if (el.attachEvent) { // Pelo o IE ser mais usado;
                    el.attachEvent('on' + event, fnc);
                } else {
                    el.addEventListener(event, fnc, false);
                }
            } else {
                throw new Error('Objeto não encontrado.');
            }
        }
    },

    /**
    * Remove a função da lista de chamadas quando o evento for disparado.
    *
    * @param {HTMLElement} el
    * @param {String} event
    * @param {Function} fnc
    */
    removeListener: function (el, event, fnc, obj) {
        if (typeof el == "string") {
            el = this.get(el);
        }
        if (obj) {
            var i = this.findListener(el, event, fnc, obj);
            if (i > -1) {
                this.removeListener(el, event, this.listeners[i].wfnc);
                delete this.listeners[i].wfnc;
                delete this.listeners[i];
                this.listeners.deleteItem(i);
            }
        } else {
            if (el) {
                if (el.attachEvent) { // Pelo o IE ser mais usado;
                    el.detachEvent('on' + event, fnc);
                } else {
                    el.removeEventListener(event, fnc, false);
                }
            } else {
                throw new Error('Objeto não encontrado.');
            }
        }
    },

    /**
    * Faz um loop buscando entre os "pais" do elemento.
    * Ele chama uma função, passada por parametro, para avaliar
    * a busca, e ao encontrar e retorna a referência do objeto
    * encontrado.
    *
    * @param {HTMLElement} el
    * @param {Function} fnc
    * @return {HTMLElement}
    */
    findParent: function (el, fnc) {
        while (el.parentNode && !(fnc(el.parentNode))) {
            el = el.parentNode;
        }
        return el.parentNode;
    },

    /**
    * Faz um loop buscando entre os "filhos" do element.
    * Ela chama uma função, passada por parametro, para avaliar
    * a busca e ao finalizar retorna um array com os elementos
    * encontrados.
    *
    * @param {HTMLElement} el
    * @param {Function} fnc
    * @return {HTMLElement[]}
    */
    findChild: function (el, fnc) {
        var c, r;
        r = [];
        for (var i = 0; i < el.childNodes.length; i++) {
            c = el.childNodes[i];
            if (fnc(c)) {
                r.push(c);
            }
            r = r.concat(this.findChild(c, fnc));
        }
        return r;
    },
    
    /**
     * Retorna o X e Y do elemento de acordo com o parent dado. 
     * 
     * @param {Object} obj Objeto que será avaliado
     * @param {Object} parent Objeto que será o teto da busca
     * @return {Object}
     */
    getXYRelative: function (obj, parent) {
        var x = 0, y = 0;
        while (obj && (obj != parent)) {
            y += obj.offsetTop;
            x += obj.offsetLeft;
            obj = obj.offsetParent;
        }
        return {x:x, y:y};
    },
    
    /**
     * Retorna apenas Y do elemento de acordo com o parent dado.
     * 
     * @param {Object} obj Objeto que será avaliado
     * @param {Object} parent Objeto que será o teto da busca
     * @return {Integer}
     */
    getTop: function (obj, parent) {
        if (!parent) {
            parent = document;
        } 
        var r = 0;
        while (obj && (obj != parent)) {
            r += obj.offsetTop;
            obj = obj.offsetParent;
        }
        return r;
    },
    
    /**
     * Retorna apenas X do elemento de acordo com o parent dado.
     * 
     * @param {Object} obj Objeto que será avaliado
     * @param {Object} parent Objeto que será o teto da busca
     * @return {Integer}
     */
    getLeft: function (obj, parent) {
        if (!parent) {
            parent = document;
        } 
        var r = 0;
        while (obj) {
            r += obj.offsetLeft;
            obj = obj.offsetParent;
        }
        return r;
    }
};

ICore.util = {
/*    maskObj: null,
    showMask: function () {
        if (!this.maskObj) {
            this.maskObj = ICore.dom.get('mask');
        }
        this.maskObj.style.top = this.maskObj.style.left = '0px';
        this.maskObj.style.display = '';

        this.maskObj.style.height = document.body.parentNode.scrollHeight + 'px';
        this.maskObj.style.width = document.body.parentNode.scrollWidth + 'px';
    },

    hideMask: function () {
        this.maskObj.style.display = 'none';
    },
*/

    /**
     * Se o parâmetro o for uma String ele tentará retornar um HTMLObject com ID igual a obj
     * senão retorna o próprio obj.
     * @param {String} obj
     */
    object: function (obj) {
        if (this.isString(obj)) {
            return ICore.dom.get(obj);
        } else {
            return obj;
        }
    },

    /**
     * Retorna se o parâmetro informado é uma função ou não.
     * @param {Object} f
     */
    isFunction: function (f) {
        return (typeof f == 'function');
    },

    /**
     * Retorna se o parâmetro informado é um Array ou não.
     * @param {Object} a
     */
    isArray: function (a) {
        return (a instanceof Array);
    },

    /**
     * Retorna se o parâmetro informado é uma String ou não. 
     * @param {Object} s
     */
    isString: function (s) {
        return (typeof s == 'string');
    },
    
    /**
     * Retrona se o parâmetro informado é um número ou não.
     * @param {Object} n
     */
    isNumber: function (n) {
        return (typeof n == 'number');
    },

    /**
     * Retorna se o parâmetro informado é indefinido ou não.
     * @param {Object} o
     */
    isUndefined: function (o) {
        return (typeof o == 'undefined');
    }
};

if (!Array.prototype.indexOf) {
    /**
     * Definindo método não implementado no IE.
     * 
     * @param {Object} el
     */
    Array.prototype.indexOf = function (el) {
        for (var i = 0; i < this.length; i++) {
            if (this[i] == el) {
                return i;
            }
        }
        return -1;
    };
}

/**
 * Busca um elemento no vetor e o remove.
 * 
 * @param {Object} el
 * @return {Integer} Retorna o índice do elemento que foi removido
 */
Array.prototype.remove = function (el) {
    var i = this.indexOf(el);
    if (i > -1) {
        this.deleteItem(i);
    }
    return i;
};

/**
 * Remove um único item do vetor.
 * 
 * @param {Object} index
 */
Array.prototype.deleteItem = function (index) {
    this.splice(index, 1);
};

/**
 * Limpa o vetor.
 */
Array.prototype.clear = function () {
    this.splice(0, this.length);
};

/**
 * Insere um elemento no meio do array.
 */
Array.prototype.insert = function (idx, el) {
    this.splice(idx, 0, el);
};