// variável global que armazena o nome atual do arquivo (utilizado ao gerar o log de erros javascript no servidor)
var funcoes = 'funcoes.js';


/**
 * Gera o log de erro javascript no servidor
 * @param   {string} nomePagina     Nome da página onde onde o erro aconteceu
 * @param   {string} nomeFuncao     O nome da função o erro aconteceu
 * @param   {string} mensagemErro   A mensagem de erro a ser logada
 * @returns {undefined}
 */
function geraLog(nomePagina, nomeFuncao, mensagemErro)
{
    try {
        // mostra o erro no console do navegador
        console.log(nomePagina + ' > ' + nomeFuncao + ': ' + mensagemErro);
        
        var json = {
            'message':  nomeFuncao + ': ' + mensagemErro,
            'file':     nomePagina
        };
        
        // realiza o envio do relato via ajax 'tradicional'
        var urlLog  = 'admin/cgi-bin/dispatcher.php';
        var dados   = 'ac=logjs/gerar/msg=' + encodeURIComponent(JSON.stringify(json));
        var xmlHttp = (window.XMLHttpRequest) ? new XMLHttpRequest : new ActiveXObject('Microsoft.XMLHTTP');
        
        xmlHttp.onreadystatechange = function() {
            if (xmlHttp.readyState === 4 && xmlHttp.status !== 200) {
                throw new Error(xmlHttp.responseText);
            }
        };
        
        xmlHttp.open('POST', urlLog, true);
        xmlHttp.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
        xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
        xmlHttp.send(dados);
    } catch (erro) {
        console.log(funcoes + ' > geraLog(): ' + erro.message);
    }
} // geraLog()


/**
 * Realiza uma requisição via ajax para o servidor
 * @param   {string} metodo         O método de envio dos dados (via GET ou POST)
 * @param   {string} pagina         O nome da página que se deseja buscar
 * @param   {string} queryString    O(s) valor(es) a ser(em) enviado(s) através da requisição
 * @returns {object}                Retorna uma instância da classe jqXHR (jQuery XMLHttpRequest)
 */
function ajax(metodo, pagina, queryString)
{
    try {
        metodo = (metodo === 'POST') ? 'POST' : 'GET';
        
        return $.ajax({
            method:     metodo,
            async:      true,
            cache:      false,
            url:        pagina,
            data:       queryString
        }).fail(function(jqXHR) {
            throw new Error('Erro HTTP número ' + jqXHR.status);
        });
    } catch (erro) {
        geraLog(funcoes, 'ajax()', erro.message);
    }
} // ajax()


/**
 * Carrega uma página HTML via ajax e a insere no conteúdo da página inicial
 * @param   {string} pagina         O nome da página que se deseja buscar
 * @param   {string} queryString    O(s) valor(es) a ser(em) enviado(s) através da requisição
 * @returns {object}                Retorna uma instância da classe jqXHR (jQuery XMLHttpRequest)
 */
function carregaPagina(pagina, queryString)
{
    try {
        if (pagina === '') {
            return false;
        }
        
        return $.ajax({
            method:     'POST',
            async:      true,
            cache:      false,
            url:        pagina,
            data:       queryString,
            beforeSend: function() {
                $('#status, #preloader').fadeIn('fast');
            }
        }).fail(function(jqXHR) {
            location.hash = (jqXHR.status == '404') ? '' : '';
        }).done(function(conteudoPagina) {
            $('#divConteudo').html(conteudoPagina);
        }).always(function() {
            $('#status, #preloader').fadeOut('fast');
        });
    } catch (erro) {
        geraLog(funcoes, 'carregaPagina()', erro.message);
    }
} // carregaPagina()


/**
 * Carrega a página despachante (responsável pela comunicação entre as páginas web e o servidor)
 * @param   {string} queryString    O(s) dado(s) a ser(em) enviado(s) ao servidor
 * @returns {object}                Retorna uma instância da classe jqXHR (jQuery XMLHttpRequest)
 */
function carregaDispatcher(queryString)
{
    try {
        return $.ajax({
            complete: function() {
                $('#status, #preloader').fadeOut('fast');
            },
            dataType:   'json',
            method:     'POST',
            async:      true,
            cache:      false,
            global:     false,
            url:        'admin/cgi-bin/dispatcher.php',
            data:       'ac=' + encodeURIComponent(queryString)
        });
    } catch (erro) {
        geraLog(funcoes, 'carregaDispatcher()', erro.message);
    }
} // carregaDispatcher()


/**
 * Carrega uma página html do sistema e todas as suas dependências (caso existam)
 * @returns {boolean} Retorna falso quando não há página a ser carregada
 */
function carregaModulo()
{
    try {
        var pagina      = pegaNmPagina();
        var queryString = pegaQuerystring();

        if (pagina === '') {
            pagina = 'html/inicio.html';
        }

        // se a página foi carregada com sucesso, carrega o arquivo .js correspondente ao seu nome
        carregaPagina(pagina, queryString).done(function() {
            carregaArqJs(pagina);
        });
    } catch (erro) {
        geraLog(funcoes, 'carregaModulo()', erro.message);
    }
} // carregaModulo()


/**
 * Renderiza um template utilizando o plugin mustache.js
 * @param   {object}    $elemento   Um objeto Jquery representando a tag <script> que contém o template
 * @param   {object}    json        Um objeto JSON contendo os dados a serem enviados ao tempĺate
 * @returns {mixed}                 Retorna o HTML renderizado pelo template em caso de sucesso e falso em caso de falha
 */
function renderizaTemplate($elemento, json)
{
    try {
        var retorno = false;
        // verifica pela existência da instância do plugin mustache
        if (!Mustache) {
            throw new Error('Falha ao carregar o plugin Mustache.js.');
        } else {
            retorno = Mustache.render($elemento.html(), json);
        }
    } catch (erro) {
        geraLog(funcoes, 'renderizaTemplate()', erro.message);
    } finally {
        return retorno;
    }
} // renderizaTemplate()


/**
 * Carrega um arquivo .js inserindo-o no final do corpo da página
 * @param   {string} pagina O nome da página a ser carregada
 *                          (OBS: pagina precisa ter o mesmo nome do arquivo .js)
 * @returns {undefined}
 */
function carregaArqJs(pagina)
{
    try {
        var arqJs = 'js/' + pagina.split('.html')[0].toLowerCase() + '.js';
        // verifica se o arquivo .js já existe na página e o remove
        $('script[src*="' + arqJs + '"]').remove();
        
        var elemento = document.createElement('script');
        elemento.setAttribute('src', arqJs + '?_=' + Date.now());
        document.body.appendChild(elemento);
    } catch (erro) {
        geraLog(funcoes, 'carregaArqJs()', erro.message);
    }
} // carregaArqJs()


/**
 * Pega uma string e a converte para objeto JSON
 * @param   {string} string A string a ser convertida
 * @returns {Object}        O objeto JSON formado a partir da string em caso de sucesso, 
 *                          ou um objeto vazio em caso de falha
 */
function parseJson(string)
{
    try {
        var json = {};
        json = ($.type(string) === 'string') ? JSON.parse(string) : JSON.parse(JSON.stringify(string));
    } catch (erro) {
        geraLog(funcoes, 'parseJson()', erro.message);
    } finally {
        return json;
    }
} // parseJson()


/**
 * Pega o nome da página carregada através da hash (#!)
 * @returns {string} O nome da página (caso exista)
 */
function pegaNmPagina()
{
    try {
        return (location.hash.split('#!')[1] !== undefined) ? location.hash.split('#!')[1] : '';
    } catch (erro) {
        geraLog(funcoes, 'pegaNmPagina()', erro.message);
    }
} // pegaNmPagina()


/**
 * Pega a querystring de uma página carregada através da hash (#!)
 * @returns {string} A querystring da página (caso exista)
 */
function pegaQuerystring()
{
    try {
        return (location.hash.split('?')[1] !== undefined) ? location.hash.split('?')[1] : '';
    } catch (erro) {
        geraLog(funcoes, 'pegaQuerystring()', erro.message);
    }
} // pegaQuerystring()


/**
 * Gera a formatação de alerta de campo inválido
 * @param   {object} $elemento O elemento jQuery que receberá a formatação
 * @returns {undefined}
 */
function geraAlertaCampo($elemento)
{
    try {
        $elemento.focus().next('span').addClass('icon-info');
        $elemento.parent('.form-group').addClass('has-warning');
    } catch (erro) {
        geraLog(funcoes, 'geraAlertaCampo()', erro.message);
    }
} // geraAlertaCampo()


/**
 * Remove a formatação de alerta de campo inválido
 * @param   {object} $elemento O elemento jQuery que terá sua formatação removida
 * @returns {undefined}
 */
function removeAlertaCampo($elemento)
{
    try {
        $elemento.focus().next('span').removeClass('icon-info');
        $elemento.parent('.form-group').removeClass('has-warning');
    } catch (erro) {
        geraLog(funcoes, 'removeAlertaCampo()', erro.message);
    }
} // removeAlertaCampo()


/**
 * Gera uma div contendo uma mensagem de alerta para o usuário
 * @param   {object} $elemento  Elemento jQuery da div utilizada para mostrar as mensagens
 * @param   {string} mensagem   A mensagem de alerta a ser inserida na div
 * @param   {string} tpMensagem O tipo de mensagem a ser mostrada
 * @returns {undefined}
 */
function geraMensagem($elemento, mensagem, tpMensagem)
{
    try {
        $elemento.html('');
        
        switch (tpMensagem) {
            case 'alerta':
                classeDiv   = 'notice';
                classeIcone = 'fa-exclamation-triangle';
                break;
            case 'erro':
                classeDiv   = 'error';
                classeIcone = 'fa-times-circle';
                break;
            case 'sucesso':
                classeDiv   = 'success';
                classeIcone = 'fa-check-circle-o';
                break;
            case 'info':
            default:
                classeDiv   = 'info';
                classeIcone = 'fa-comments-o';
                break;
        }
        
        var htmlDiv =   '<div class="alert ' + classeDiv + '"><span class="fa fa-lg ' + classeIcone + '"></span> '
                            + mensagem + 
                        '<button data-dismiss="alert" class="close" type="button"><span class="icon-circle-cross"></span></button></div>';
        $elemento.html(htmlDiv).focus();
        // rola a página até a div de mensagem
        $('html').animate({
            scrollTop: $elemento.offset().top - 100
        });
    } catch (erro) {
        geraLog(funcoes, 'geraMensagem()', erro.message);
    }
} // geraMensagem()


/**
 * Remove da página a div gerada em geraMensagem()
 * @param {object} $elemento Elemento jQuery da div utilizada para mostrar as mensagens
 */
function removeMensagem($elemento)
{
    try {
        $elemento.html('');
    } catch (erro) {
        geraLog(funcoes, 'removeMensagem()', erro.message);
    }
} // removeMensagem()


/**
 * Validação fraca de formulário
 * @param   {object}    $elementos  Objeto jQuery contendo um ou mais elementos a serem validados
 * @param   {object}    $divMsg     Elemento jQuery da div utilizada para mostrar as mensagens
 * @returns {Boolean}               Retorna true quando os campos obrigatórios estiverem preenchidos corretamente, e falso caso contrário
 */
function validaForm($elementos, $divMsg)
{
    try {
        var retorno = true;
        
        $elementos.each(function() {
            if ($(this).attr('data-campo-obrigatorio') !== 'nao' && !$(this).val().trim()) {
                geraMensagem($divMsg, 'Campo obrigatório!', 'alerta');
                geraAlertaCampo($(this));
                retorno = false;
                return false;
            } else {
                removeMensagem($divMsg);
                removeAlertaCampo($(this));
            }
        });
        
        return retorno;
    } catch (erro) {
        geraLog(funcoes, 'validaForm()', erro.message);
    }
} // validaForm()


/**
 * Modifica o valor contido na tag <title> da página principal
 * @returns {undefined}
 */
function modificaTituloPag()
{
    try {
        var tituloPagina = $('#divFundoPagina h1').text().trim();
        $('title').text(((tituloPagina) ? tituloPagina + '' : ''));
        //$('title').remove();
        //$('head').append('<title>' + ((tituloPagina) ? tituloPagina + '' : '') + '</title>');
    } catch (erro) {
        geraLog(funcoes, 'modificaTituloPag()', erro.message);
    }
} // modificaTituloPag()


/**
 * Carrega o plugin PgwSlideshow (responsável pela galeria de imagens)
 * @returns {undefined}
 */
function carregaPgwSlideshow()
{
    try {
        $('.pgwSlideshow').pgwSlideshow({
            transitionEffect:   'fading',
            touchControls:      true,
            autoSlide:          false,
            displayControls:    true,
            displayList:        true
        });
        
        // força as imagens selecionadas da galeria a manterem uma altura fixa
        $('.ps-current img').css('height', '600px').css('width', 'auto');
    } catch (erro) {
        geraLog(funcoes, 'carregaPgwSlideshow()', erro.message);
    }
} // carregaPgwSlideshow()


/**
 * Muda aleatoriamente o fundo da imagem a ser apresentada nas páginas
 * @returns {undefined}
 */
function geraFundoAleatorio()
{
    try {
        var nomeClasse = 'page_header_parallax' + (Math.floor((Math.random() * 15) + 1));
        $('#divFundoPagina').removeClass().addClass(nomeClasse);
    } catch (erro) {
        geraLog(funcoes, 'geraFundoAleatorio()', erro.message);
    }
} // geraFundoAleatorio()


/**
 * Visualiza uma imagem utilizando o plugin MagnificPopup
 * @param   {object} $elemento Elemento jQuery da tag <img> que contém a imagem a ser mostrada
 * @returns {undefined}
 */
function visualizarImagem($elemento)
{
    try {
        $.magnificPopup.open({
            type:   'image',
            items:  {
                src: $elemento.attr('src')
            }
        });
    } catch (erro) {
        geraLog(funcoes, 'visualizarImagem()', erro.message);
    }
} // visualizarImagem()


/**
 * Gera um objeto (array associativo) da querystring da página atual
 * @returns {object} Retorna um objeto contendo os nomes e os valores da querystring
 */
function pegaValoresQuerystring()
{
    try {
        var valores = [], hash;
        var hashes  = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
        
        for (var i = 0; i < hashes.length; i++) {
            hash = hashes[i].split('=');
            valores.push(hash[0]);
            valores[hash[0]] = hash[1];
        }
        
        return valores;
    } catch (erro) {
        geraLog(funcoes, 'pegaValoresQuerystring()', erro.message);
    }
} // pegaValoresQuerystring()


/**
 * Inicia a análise do Google analytics
 * @returns {undefined}
 */
function initGoogleAnalytics()
{
    try {
        // ID de acompanhamento do Google Analytics
        var IdAcompanhamento = 'UA-101487996-1';
        $.getScript('//www.google-analytics.com/analytics.js');
        window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments);};ga.l=+new Date;
        
        ga('create', IdAcompanhamento, 'auto');
        ga('send', 'pageview');
    } catch (erro) {
        geraLog(funcoes, 'initGoogleAnalytics()', erro.message);
    }
} // initGoogleAnalytics()


/**
 * Envia ao Google analytics os dados da página acessada
 * @param   {string} nmPagina   O nome da página acessada
 * @param   {string} titulo     O título da página acessada
 * @returns {undefined}
 */
function trackPaginaGa(nmPagina, titulo)
{
    try {
        window.ga('set', {page: nmPagina, title: titulo});
        window.ga('send', 'pageview');
    } catch (erro) {
        geraLog(funcoes, 'trackPaginaGa()', erro.message);
    }
} // trackPaginaGa()