/*
 * Obtém a applet do SDK de assinatura.
 */
function getApplet(){
	return document.getElementById('assinadorDigital');
}

/**
 * @return Verdadeiro caso as bibliotecas do e-Assinador tenham sido encontradas.
 */
function existeAssinador() {
	var retorno = getApplet().call('existeAssinador', []);
	return (retorno && retorno.toUpperCase() == "TRUE");
}

/**
 * @return Verdadeiro caso o e-assinador precise ser atualizado
 */
function isAtualizar() {
	return getApplet().call('isAtualizar', []);
}

/**
 * Inicia uma sessão para o uso apenas da chave privada selecionada.
 */
function iniciarSessaoChave() {
	if (getApplet()!=null)
		getApplet().call('iniciarSessaoChave', []);
}

/**
 * Fecha a sessão de uso da chave privada.
 */
function fecharSessaoChave() {
	if (getApplet()!=null)
		getApplet().call('fecharSessaoChave', []);
}

/**
 * Codifica os dados informados em Hexadecimal.
 *
 * @param dados Dados para a codificação
 * @return Dados codificados
 */
function encodeToHex(dados) {
	return getApplet().call('encodeToHex', [dados]);
}

/**
 * Decodifica os dados em hexadecimal informados.
 *
 * @param dados Dados para a decodificação
 * @return Dados decodificados
 */
function decodeToHex(dados) {
	return getApplet().call('decodeToHex', [dados]);
}

/*
 * Carimba um dado.
 * parâmetros:
 * 		conteudo: conteúdo que será carimbado.
 * retorno: string contendo carimbo de tempo em hexadecimal.
 */
function carimbarDados(dados) {
	return getApplet().call('carimbar', [dados]);
}

/*
 * Assina um conteúdo no formato detached.
 * parâmetros:
 * 		conteudo: conteúdo que será assinado.
 * retorno: string conteúdo o array de bytes no formato pkcs#7 em hexadecimal.
 */
function assinarConteudoDetached(conteudo) {
	return getApplet().call('assinarConteudoDetached', [conteudo]);
}

/*
 * Assina um conteúdo no formato attached.
 * parâmetros:
 * 		conteudo: conteúdo que será assinado.
 * retorno: string conteúdo o array de bytes no formato pkcs#7 em hexadecimal.
 */
function assinarConteudoAttached(conteudo) {
	return getApplet().call('assinarConteudoAttached', [conteudo]);
}

/*
 * Assina um conteúdo no formato attached.
 * parâmetros: 
 * 		conteudo: conteúdo que será assinado.
 * 		algoritmoOID: OID do algoritmo que será usado para assinar.
 * retorno: string conteúdo o array de bytes no formato pkcs#7 em hexadecimal.
 */
function assinarConteudoDetachedAlgoritmo(conteudo, algoritmoOID) {
	return getApplet().call('assinarConteudoDetached', [conteudo, algoritmoOID]);
}

/*
 * Assina um conteúdo no formato detached.
 * parâmetros: 
 * 		conteudo: conteúdo que será assinado.
 * 		algoritmoOID: OID do algoritmo que será usado para assinar.
 * retorno: string conteúdo o array de bytes no formato pkcs#7 em hexadecimal.
 */
function assinarConteudoAttachedAlgoritmo(conteudo, algoritmoOID) {
	return getApplet().call('assinarConteudoAttached', [conteudo, algoritmoOID]);
}

/*
 * Valida a assinatura do arquivo.
 * parâmetros:
 *      conteudo = conteúdo que foi assinado.
 * 		envelope = envelope de assinatura em hexadecimal.
 * retorno: retorna true caso a assinatura seja validada com sucesso.
 */
function validarAssinatura(conteudo, envelope) {
	return getApplet().call('validarAssinatura', [conteudo, envelope]);
}

/*
 * Efetua uma verificação na validade do certificado quando foi gerado o carimbo de tempo.
 * parâmetros:
 * 		carimbo = carimbo gerado no momento da assinatura em hexadecimal.
 * retorno: retorna true caso o carimbo de tempo esteja valido.
 */
function validarValidadeComDataCarimbo(carimbo) {
	return getApplet().call('validarValidadeComDataCarimbo', [carimbo]);
}

/*
 * Efetua uma comparação entre o hash carimbado e o conteudo carimbado informado.
 * parâmetros:
 * 		carimbo = carimbo gerado no momento da assinatura em hexadecimal.
 * 		conteudoCarimbado = conteúdo que foi carimbado.
 * retorno: retorna true caso o hash carimbo corresponda ao hash do conteúdo informado.
 */
function validarHashCarimbado(carimbo, conteudoCarimbado) {
	return getApplet().call('validarHashCarimbado', [carimbo, conteudoCarimbado]);
}

/*
 * Verifica a integridade de um protocolo. O objetivo é verificar a integridade dos processos,
 * identificando alteraçõeses ou substituições de documentos assinados digitalmente.
 * parâmetros:
 * 		tsAnterior = carimbo de tempo do documento imediatamente posterior no processo de protocolo em hexadecimal.
 * 		tsAtual = carimbo de tempo de um documento em hexadecimal.
 * 		protocolo = protocolo digital do último carimbo de tempo em hexadecimal.
 * retorno: true caso o protocolo esteja íntegro.
 */
function validarProtocolo(tsAnterior, tsAtual, protocolo) {
	return getApplet().call('validarProtocolo', [tsAnterior, tsAtual, protocolo]);
}

/*
 * Cria protocolo.
 * parâmetros:
 * 		tsProtocolo = timeStamp do ultimo protocolo, podendo ser nulo caso seja o primeiro em hexadecimal.
 * 		tsAtual = timeStamp do documento a ser anexado ao protocolo em hexadecimal.
 * retorno: Retorna um array de strings com tamanho 2, onde a primeira string é o carimbo de tempo 
 * e a segunda e o protocolo.
 */
function criarProtocolo(tsProtocolo, tsAtual) {
	var resultado = getApplet().call('criarProtocolo', [tsProtocolo, tsAtual]);
	return resultado.split("|");
}

/*
 * Criptografa um conteúdo.
 * parâmetros:
 * 		conteudo = conteúdo a ser criptografado.
 * retorno: resultado da criptografia em hexadecimal.
 */
function criptografar(conteudo) {
	return getApplet().call('criptografar', [conteudo]);
}

/*
 * Criptografa um conteúdo.
 * parâmetros:
 * 		conteudo = conteúdo a ser decriptografado em hexadecimal.
 * retorno: resultado da decriptografia.
 */
function decriptografar(conteudo) {
	return getApplet().call('decriptografar', [conteudo]);
}

/*
 * Gera o hash de um algoritmo usando o SHA-1.
 * parâmetros:
 * 		conteudo = conteúdo a ser gerado o hash.
 * retorno: hash do conteúdo em hexadecimal.
 */
function gerarHash(conteudo) {
	return getApplet().call('gerarHash', [conteudo]);
}

/**
 * Assina um hash gerado usando SHA1 no formato detached usando o algoritmo RSA. 
 * parâmetros:
 * 		hash = string com o hash.
 * retorno: resultado da decriptografia em hexadecimal.
 */
function assinarHashDetached(hash) {
	return getApplet().call('assinarHashDetached', [hash]);
}

/**
 * Carimba um hash em forma de string.
 * parâmetros:
 * 		hash = hash que será carimbado.
 * 		oidHash = algoritmo que foi usado para gerar o hash.
 * retorno: string representado o dado carimbado em hexadecimal.
 */
function carimbarHash(hash, oidHash) {
	return getApplet().call('carimbarHash', [hash, oidHash]);
}

/**
 * Obtem o valor do dado alternativo do Certificado
 *
 *Dados:
 		- TituloEleitor
    	- Zona
    	- Secao
    	- MunicipioEleitor
    	- UfEleitor
    	- DataNascimento
    	- Cpf
    	- Pis
    	- Rg
    	- OrgaoExpeditor
    	- Uf
    	- NomeResponsavel
        - Cnpj
        - InssPessoaJuridica
     	- InssPessoaFisica
   		- Pj
 */
function obterDadosCertificado(dado) {
	return getApplet().call('obterDadosCertificado', [dado]);
}

/**
 * Assina um arquivo no formato attached.
 * parâmetros:
 * 		caminhoArquivoOrigem: caminho do arquivo que será assinado
 * retorno: string contendo o caminho do arquivo assinado ou mensagem de erro no padrão MSG###
 */
function assinarArquivo(caminhoArquivoOrigem) {
	return getApplet().call("assinarArquivo", new Array(caminhoArquivoOrigem))
}

/**
 * Remove a assinatura de um arquivo com assinatura attached.
 * parâmetros:
 * 		caminhoArquivoOrigem: caminho do arquivo que terá assinatura removida
 * retorno: string contendo o caminho do arquivo sem assinatura ou mensagem de erro no padrão MSG###
 */
function removerAssinaturaArquivo(caminhoArquivoOrigem) {
	return getApplet().call("removerAssinaturaArquivo", new Array(caminhoArquivoOrigem));
}

function getMenssagem(msg){
	
	switch (msg) 
	{
	case "MSG011": return "Propósito inválido (tipicamente problema no certificado, Ex. Usando o certificado de arquivos do AD para assinar um documento)";
		break;
	case "MSG041": return "Erro na leitura das extensões do certificados (tipicamente problema no certificado)";
		break;
	case "MSG999": return "Erro na Assinatura (Ocorre quando existe algum erro não esperado)";
		break;
	case "MSG042": return "Parâmetros inválidos (tipicamente erro nos dados passados pela aplicação, Ex. Dados nulos)";
		break;		
	case "MSG027": return "Algorítimo não suportado pelo certificado (tipicamente problema no certificado)";
		break;
	case "MSG039": return "Erro na Busca da Chave Privada (tipicamente problema no certificado)";
		break;
	case "MSG043": return "Chave Inválida (tipicamente problema no certificado)";
		break;
	case "MSG044": return "Erro ao gerar a Assinatura";
		break;
	case "MSG003": return "Assinatura Inválida detectada na verificação";
		break;
	case "MSG045": return "Falha no Stream do Carimbo (erro de conexão com o carimbo)";
		break;
	case "MSG046": return "Host desconhecido";
		break;
	case "MSG053": return "Timeout do Carimbo";
		break;	
	case "MSG047": return "Tamanho de bloco inválido durante a criptografia";
		break;
	case "MSG048": return "Nenhum certificado encontrado";
		break;
	case "MSG049": return "Envelope inválido (informado na validação da uma assinatura)";
		break;
	case "MSG009": return "Assinatura não encontrada para validação";
		break;
	case "MSG050": return "É informado quando o certificado está inválido no momento do carimbo.";
		break;
	case "MSG051": return "Retorna informando que o carimbo a ser validado está inválido";
		break;
	case "MSG052": return "Verifica se o protocolo está inválido";
		break;
	case "MSG054": return "Sem endereços de carimbo de TEMPO";
		break;
	case "MSG055": return "Sem permissão para acessar o Carimbo";
		break;
	case "MSG056": return "Erro ao tentar ober um dado não existente no certificado (CPF, CNPJ, TituloEleitor, etc) Pode representar ou não um erro, dependendo da obrigatoriedade na aplicação.";
		break;		
	case "MSG057": return "Operação cancelada pelo usuário";
		break;		
	case "MSG058": return "Arquivo a ser assinado não foi encontrado";
		break;		
	case "MSG058": return "Nenhum certificado encontrado";
		break;		
	case "MSG059": return "Erro ocorrido durante a leitura do arquivo";
		break;				
	default:
		return "Erro não identificado.";
		break;
	}
}