#!/usr/bin/env bash

# $Id: livrinho.sh,v 1.1 2004/11/14 01:42:28 mario Exp $

# Changelog:
#
# 2004, Nov 14:  - livrinho-0.6
#                - Corrigidos codigos de saida (ERRO=1, OK=0)
#
# 2003, Abr 29:  - livrinho-0.5
#                - opcoes para especificar o formato de saida dos livrinhos:
#                    * -ps   : saida em PostScript
#                    * -pdf  : saida em PDF
#                    * -psgz : saida em PostScript compactado com gzip (default)
#                - opcao para nao exibir mensagens (-q | --quieto)
#                - suporte a arquivos .Z
#                - deteccao de programas necessarios. Para os nao encontrados,
#                  mensagens de ajuda sao impressas.
#                - opcao para indicar entrada ascii (-a | --ascii)
#                - uso de "#!/usr/bin/env bash" em vez de "#!/bin/bash"
#                - possibilidade de usar uma URL em vez de um arquivo (ainda nao
#                  funciona em muitos casos -- experimental)
#                - algumas correcoes de erro menores
#
# 2003, Jan 07:  - livrinho-0.4
#                - opcoes para 8, 6, 4 ou 2 slides por pagina
#                - deteccao de argumentos invalidos (livrinho_postscript)
#                - suporte a arquivos de sufixo cpp e texi
#                - mensagens coloridas :-)
#                - teste para verificar se o arquivo a ser convertido existe
#                - uso do pstopdf em vez do ps2pdf
#                - -h | --help
#
# 2002, Ago 09:  - livrinho-0.3
#                - Reescrita do livrinho.
#                - Suporte a arquivos de sufixo:
#                  txt   java   el   c
#                  zip   html   gz   h
#                  htm          hh
#                  bz2          cc
#                  pdf          py
#                  dvi          pl
#                  pas
#                  asm
#             
# ????, ??? ??:  - livrinho-0.2
#                - Dá o mesmo trabalho que executar o comando no prompt do shell :-)
#
# ????, ??? ??:  - livrinho-0.1
#                - Dá mais trabalho que executar o comando no prompt do shell :-)


uso(){
    
    local cod_saida
    cod_saida=$1

    echo
    echo "Uso: `basename $0` <tipo saída> [<opções>] [<arquivo> | <URL>]"
    echo "     `basename $0` -h | --help"
    echo
    echo "<tipo saída>:"
    echo "    --gibi1arq | -g1     : formato gibi em 1 arquivo (impressoras duplex)"
    echo "    --gibi2arq | -g2     : formato gibi em 2 arquivos"
    echo "    --8slides  | -8s     : 8 slides por pagina"
    echo "    --6slides  | -6s     : 6 slides por pagina"
    echo "    --4slides  | -4s     : 4 slides por pagina"
    echo "    --2slides  | -2s     : 2 slides por pagina"
    echo
    echo "<opções>:"
    echo "    --quieto   | -q      : não mostra mensagens"
    echo "    --ascii    | -a      : indica que a entrada é ASCII"
    echo "    -pdf                 : saída em pdf"
    echo "    -ps                  : saída em PostScript "
    echo "    -psgz                : saída em PostScript compactado com gzip (default)"
    echo 
    echo "Exemplos:"
    echo "  $ livrinho.sh -pdf -g1 documento.ps"
    echo "    gerará o arquivo documento_livrinho.pdf"
    echo
    echo "  $ livrinho.sh -g2 http://proxy.furg.br/mario/utils/livrinho/index.html"
    echo "    gerará os arquivos index_livrinho_frente.ps.gz e index_livrinho_verso.ps.gz"

    [ -z $1 ] && cod_saida=$ERRO
    exit $cod_saida
}


arquivo_invalido(){

    echo "Não foi possível determinar o tipo de arquivo."
    echo "Os tipos suportados são (identificados pelo sufixo):"
    echo "       Tipo             Sufixos"
    echo "     PostScript           ps"
    echo "       Gzip               gz Z"
    echo "       Zip                zip"
    echo "       Bzip               bz2"
    echo "       PDF                pdf"
    echo "      Ascii               txt  tex c  h  cc  hh  java  el"
    echo "                          py  pl  pas  asm cpp texi"
    echo "       DVI                dvi"
    echo "      HTML                html  htm"
    exit $ERRO
}

msg(){
    [ -z "$QUIETO" ] && echo "$1"
}

msg_falha(){
    [ -z "$QUIETO" ] && echo -e "${ENDCOL} $BAD_ALERT"
}

msg_ok(){
    [ -z "$QUIETO" ] && echo -e "${ENDCOL} $GOOD_ALERT"
}

getcols() {
        echo "${2}"
}


# Cores (de /etc/init.d/functions.sh da distribuicao Gentoo)
NORMAL="\033[0m"
GOOD=$'\e[32;01mok'
BAD=$'\e[31;01mERRO'
LBRACK=$'\e[33;01m['
RBRACK=$'\e[33;01m]'
BAD_ALERT="$LBRACK $BAD $RBRACK $NORMAL"
GOOD_ALERT="$LBRACK $GOOD $RBRACK $NORMAL"
COLS="$(stty size 2>/dev/null)"
COLS="$(getcols $COLS)"
COLS=$((${COLS} -10))
ENDCOL=$'\e[A\e['${COLS}'G'
#now, ${ENDCOL} will move us to the end of the column;
#irregardless of character width


# Gera livrinho a partir de arquivo postscript
livrinho_postscript(){

    local arq
    local arg

    # Parametros para a geracao do livrinho no formato gibi
    local GIBI_FRENTE_2ARQ='4:-3L@.7(21cm,0)+0L@.7(21cm,14.85cm)'
    local GIBI_VERSO_2ARQ='4:1L@.7(21cm,0)+-2L@.7(21cm,14.85cm)'
    local GIBI_1ARQ_1='4:-3L@.7(21cm,0)+0L@.7(21cm,14.85cm),1L@.7(21cm,0)+-2L@.7(21cm,14.85cm)'
    local GIBI_1ARQ_2='2:0,1U(21cm,30cm)'

    arg=$1
    arq=$2
    
    case "$arg" in
	"g2")
	    msg "Gerando ${ARQ_SS}_livrinho_frente.ps"
	    $PSTOPS "$GIBI_FRENTE_2ARQ" $arq $ARQ_SS"_livrinho_frente.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    msg "Gerando ${ARQ_SS}_livrinho_verso.ps"
	    $PSTOPS "$GIBI_VERSO_2ARQ" $arq $ARQ_SS"_livrinho_verso.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    ;;
	"g1")
	    msg "Gerando ${ARQ_SS}_livrinho.ps"
	    cat $arq | $PSTOPS "${GIBI_1ARQ_1}" | $PSTOPS "${GIBI_1ARQ_2}" > $ARQ_SS"_livrinho.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    ;;
	"8s") 
	    msg "Gerando ${ARQ_SS}_livrinho.ps"
	    psnup -pa4 -n 8 -l $arq $ARQ_SS"_livrinho.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    ;;
	"6s")
	    msg "Gerando ${ARQ_SS}_livrinho.ps"
	    psnup -pa4 -n 6 -l $arq $ARQ_SS"_livrinho.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    ;;
	"4s") 
	    msg "Gerando ${ARQ_SS}_livrinho.ps"
	    psnup -pa4 -n 4 -l $arq $ARQ_SS"_livrinho.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    ;;
	"2s") 
	    msg "Gerando ${ARQ_SS}_livrinho.ps"
	    psnup -pa4 -n 2 -l $arq $ARQ_SS"_livrinho.ps"
	    [ $? != "0" ] && msg "Erro ao gerar o livrinho." && msg_falha && exit $? || msg_ok
	    ;;

	*)
	    uso $ERRO
	    
    esac
}


# Gera livrinho a partir de arquivo pdf
livrinho_pdf(){

    local arg
    local arq

    arg=$1
    arq=$2

    tipo_entrada $arq

    msg "Convertendo $arq para $ARQ_SS".ps...""
    $PDF2PS $arq $ARQ_SS".ps"
    [ $? != "0" ] && msg "Erro ao converter o arquivo (PDF -> PS)." && msg_falha && exit $? || msg_ok

    livrinho_postscript $arg $ARQ_SS".ps"
    [ ! -z "$JAH_EXISTIA" ] && [ -e "${ARQ_SS}.ps" ] && rm -f "${ARQ_SS}.ps"

}

# Gera livrinho a partir de arquivo ascii
livrinho_ascii(){

    local arg
    local arq

    arg=$1
    arq=$2

    tipo_entrada $arq

    $A2PS -1 --delegate=no $arq -o $ARQ_SS".ps"
    [ $? != "0" ] && msg "Erro ao converter o arquivo (ascii -> PS)." && msg_falha && exit $?

    livrinho_postscript $arg $ARQ_SS".ps"
    [ ! -z "$JAH_EXISTIA" ] && [ -e "${ARQ_SS}.ps" ] && rm -f "${ARQ_SS}.ps"
}


# Gera livrinho a partir de arquivo dvi
livrinho_dvi(){

    local arg
    local arq

    arg=$1
    arq=$2

    tipo_entrada $arq

    $DVIPS $arq -o $ARQ_SS".ps"
    [ $? != "0" ] && msg "Erro ao converter o arquivo (DVI -> PS)." && msg_falha && exit $?	

    livrinho_postscript $arg $ARQ_SS".ps"
    [ ! -z "$JAH_EXISTIA" ] && [ -e "${ARQ_SS}.ps" ] && rm -f "${ARQ_SS}.ps"
}


# Gera livrinho a partir de arquivo html
livrinho_html(){

    local arg
    local arq

    arg=$1
    arq=$2

    tipo_entrada $arq

    $HTML2PS -o $ARQ_SS".ps" $arq 
    [ $? != "0" ] && msg "Erro ao converter o arquivo (HTML -> PS)." && msg_falha && exit $?	

    livrinho_postscript $arg $ARQ_SS".ps"
    [ ! -z "$JAH_EXISTIA" ] && [ -e "${ARQ_SS}.ps" ] && rm -f "${ARQ_SS}.ps"
}



# Determina o tipo de arquivo e gera o nome do arquivo sem sufixo
# Retorna:
#    nome do arquivo sem sufixo em $ARQ_SS
#    tipo de arquivo em $TIPO_ARQ
tipo_entrada(){

    local arquivo
    local sufixo
    local tam_total

    [ -z $1 ] && echo "Função tipo_entrada: faltam parâmetros." && exit $ERRO
    arquivo=$1

    tam_total=`echo "$arquivo" | wc -c`

    sufixo=`echo ${arquivo##*.}`
    ARQ_SS=`echo ${arquivo%*\.$sufixo}`

    case "$sufixo" in
	"ps" | "PS")
	    TIPO_ARQ=postscript
	    ;;
	"pdf" | "PDF")
	    TIPO_ARQ=pdf
	    ;;
	"txt" | "TXT" | "tex" | "TEX" | "asm" | "ASM" | "pas" | "PAS" | "c" | "C" | "h" | "H" | "hh" | "HH" | "cc" | "CC" | "el" | "py" | "PY" | "java" | "JAVA" | "cpp" | "CPP" | "texi" | "TEXI")
	    TIPO_ARQ=ascii
	    ;;
	"dvi" | "DVI")
	    TIPO_ARQ=dvi
	    ;;
	"gz" | "GZ" | "Z")
	    TIPO_ARQ=gzip
	    ;;
	"bz2" | "BZ2")
	    TIPO_ARQ=bzip
	    ;;
	"zip" | "ZIP")
	    TIPO_ARQ=zip
	    ;;
	"html" | "HTML" | "htm" | "HTM")
	    TIPO_ARQ=html
	    ;;
	*) 
	    arquivo_invalido
	    ;;
    esac

}

#
# Invoca a funcao correspondente ao formato do arquivo
#
mapeia_formato(){

    case "$TIPO_ARQ" in
	"gzip") 
	    msg "Descompactando $ARQ..."
	    $_GZIP -d $ARQ
	    [ $? != "0" ] && msg "Erro ao descompactar o arquivo." && msg_falha && exit $? || msg_ok
	    nome_temp="$ARQ_SS"
	    tipo_entrada $ARQ_SS
	    if [ ! -z "$FORCA_ASCII" ]; then
		livrinho_ascii $TIPO_LIVRINHO $nome_temp
	    fi
	    [ -e "${ARQ_SS}" ] && JAH_EXISTIA=1
	    case "$TIPO_ARQ" in
		"postscript")
		    livrinho_postscript $TIPO_LIVRINHO $nome_temp
		    ;;
		"pdf")
		    livrinho_pdf $TIPO_LIVRINHO $nome_temp
		    ;;
		"ascii")
		    livrinho_ascii $TIPO_LIVRINHO $nome_temp
		    ;;
		"dvi")
		    livrinho_dvi $TIPO_LIVRINHO $nome_temp
		    ;;
		"html")
		    livrinho_html $TIPO_LIVRINHO $nome_temp
		    ;;
		*)
		    arquivo_invalido
		    ;;
	    esac
	    ;;
	
	"bzip") 
	    msg "Descompactando $ARQ..."
	    $_BZIP -d $ARQ
	    [ $? != "0" ] && msg "Erro ao descompactar o arquivo." && msg_falha && exit $? || msg_ok
	    nome_temp="$ARQ_SS"
	    tipo_entrada $ARQ_SS
	    if [ ! -z "$FORCA_ASCII" ]; then
		livrinho_ascii $TIPO_LIVRINHO $nome_temp
	    fi
	    [ -e "${ARQ_SS}" ] && JAH_EXISTIA=1
	    case "$TIPO_ARQ" in
		"postscript")
		    livrinho_postscript $TIPO_LIVRINHO $nome_temp
		    ;;
		"pdf")
		    livrinho_pdf $TIPO_LIVRINHO $nome_temp
		    ;;
		"ascii")
		    livrinho_ascii $TIPO_LIVRINHO $nome_temp
		    ;;
		"dvi")
		    livrinho_dvi $TIPO_LIVRINHO $nome_temp
		    ;;
		"html")
		    livrinho_html $TIPO_LIVRINHO $nome_temp
		    ;;
		*)
		    arquivo_invalido
		    ;;
	    esac
	    ;;
	
	"zip") 
	    echo "Descompactando $ARQ..."
	    $_UNZIP -d $ARQ
	    [ $? != "0" ] && echo "Erro ao descompactar o arquivo." && exit $?
	    nome_temp="$ARQ_SS"
	    tipo_entrada $ARQ_SS
	    if [ ! -z "$FORCA_ASCII" ]; then
		livrinho_ascii $TIPO_LIVRINHO $nome_temp
	    fi
	    [ -e "${ARQ_SS}" ] && JAH_EXISTIA=1
	    case "$TIPO_ARQ" in
		"postscript")
		    livrinho_postscript $TIPO_LIVRINHO $nome_temp
		    ;;
		"pdf")
		    livrinho_pdf $TIPO_LIVRINHO $nome_temp
		    ;;
		"ascii")
		    livrinho_ascii $TIPO_LIVRINHO $nome_temp
		    ;;
		"dvi")
		    livrinho_dvi $TIPO_LIVRINHO $nome_temp
		    ;;
		"html")
		    livrinho_html $TIPO_LIVRINHO $nome_temp
		    ;;
		*)
		    arquivo_invalido
		    ;;
	    esac
	    ;;
	
	"postscript")
	    livrinho_postscript $TIPO_LIVRINHO $ARQ
	    ;;
	"dvi")
	    livrinho_dvi $TIPO_LIVRINHO $ARQ
	    ;;
	"pdf")
	    livrinho_pdf $TIPO_LIVRINHO $ARQ
	    ;;
	"ascii")
	    livrinho_ascii $TIPO_LIVRINHO $ARQ
	    ;;
	"html")
	    livrinho_html $TIPO_LIVRINHO $ARQ
	    ;;
    esac

}



### Determina o tipo de livrinho de saida
tipo_livrinho(){

    local ok
    ok=

    for ts in $ARGS; do
	case "$ts" in
	    "-g1" | "--gibi1arq")
		TIPO_LIVRINHO="g1"
		ok=1
		;;
	    "-g2" | "--gibi2arq")
		TIPO_LIVRINHO="g2"
		ok=1
		;;
	    "-8s" | "--8slides")
		TIPO_LIVRINHO="8s"
		ok=1
		;;
	    "-6s" | "--6slides")
		TIPO_LIVRINHO="6s"
		ok=1
		;;
	    "-4s" | "--4slides")
		TIPO_LIVRINHO="4s"
		ok=1
		;;
	    "-2s" | "--2slides")
		TIPO_LIVRINHO="2s"
		ok=1
		;;
	esac
    done
    
    # Se nao foi especificado o tipo de livrinho,
    # imprime mensagem de erro e sai
    [ -z "$ok" ] && uso $ERRO

}

converte_saida(){

    local nome
    local nome_livrinho

    case $TIPO_LIVRINHO in
	"g2")
	    nome_livrinho="${ARQ_SS}_livrinho_frente.ps ${ARQ_SS}_livrinho_verso.ps"
	    ;;
	*)
	    nome_livrinho="${ARQ_SS}_livrinho.ps"
	    ;;
    esac

    for a in $ARGS; do
	
	case $a in
	    "-pdf")
		for nome in $nome_livrinho; do
		    msg "Convertendo $nome para PDF"
		    $PS2PDF -sPAPERSIZE=a4 $nome
		    retval=$?
		    if [ $retval != "0" ]; then
			msg "Erro ao converter o $nome para pdf."
			msg_falha && exit $? 
		    else
			msg_ok
			rm -f $nome
		    fi
		done
		exit $OK
		;;
	    "-ps")
		exit $OK
		;;
	    "-psgz")
		for nome in $nome_livrinho; do
		    msg "Compactando $nome..."
		    $_GZIP $nome
		    [ $? != "0" ] && msg "Erro ao compactar $nome." && msg_falha && exit $? || msg_ok	    
		done
		exit $OK
	esac
    done 

    # Se nao foi especificado o tipo de arquivo de saida,
    # gera o default
    for nome in $nome_livrinho; do
	msg "Compactando $nome..."
	$_GZIP $nome
	[ $? != "0" ] && msg "Erro ao compactar $nome." && msg_falha && exit $? || msg_ok	    
    done
    exit $OK
    
}

# Verifica se os programas necessarios para o funcionamento do livrinho
# podem ser encontrados na variavel PATH
verifica_programas(){

    local caminho
    local programas
    local prog
    local ok

    programas="$_UNZIP $_GZIP $_BZIP $PSTOPS $PDF2PS $A2PS $DVIPS $HTML2PS $PS2PDF $_WGET"

    for prog in $programas; do
	ok=
	for caminho in ${PATH//:/ }; do
	    [ -x "$caminho/$prog" ] && ok=1
	done
	
	if [ -z "$QUIETO" ]; then
	    if [ -z "$ok" ]; then
		case $prog in
		    "$PSTOPS")
			nao_encontrado $prog "fazer com que 4 páginas sejam agrupadas em uma folha" \
			    "http://www.tardis.ed.ac.uk/~ajcd/psutils"
			;;
		    "$PDF2PS")
			nao_encontrado $prog "converter arquivos PDF para PostScript" \
			    "http://www.easysw.com/"
			;;
		    "$A2PS")
			nao_encontrado $prog "converter arquivos ASCII para PostScript" \
			    "http://www-inf.enst.fr/~demaille/a2ps/"
			;;
		    "$DVIPS")
		    nao_encontrado $prog "converter arquivos DvI para PostScript" \
			"http://tug.org/teTeX/"
		    ;;
		    "$HTML2PS")
			nao_encontrado $prog "converter arquivos HTML para PostScript" \
			    "http://www.tdb.uu.se/~jan/html2ps.html"
			;;
		    "$PS2PDF")
			nao_encontrado $prog "converter arquivos PostScript para PDF" \
			    "http://www.easysw.com/"
			;;
		    "$_UNZIP")
			nao_encontrado $prog "descompactar arquivos .zip" \
			    "ftp://ftp.info-zip.org/pub/infozip/UnZip.html"
			;;
		    "$_GZIP")
			nao_encontrado $prog "descompactar arquivos .gzip e .Z" \
			    "http://sources.redhat.com/bzip2/"
			;;
		    "$_BZIP")
			nao_encontrado $prog "descompactar arquivos .bz2" \
			    "http://www.gnu.org/software/gzip/gzip.html"
			;;
		    "$_WGET")
			nao_encontrado $prog "fazer o \"download\" de arquivos remotos" \
			    "http://www.gnu.org/software/wget"
			;;
		esac
	    fi
	fi
    done
}


# Mensagem para notificar o usuario que $prog nao foi encontrado e que
# algumas funcionalidades do livinho nao estarao disponiveis
# Indica as consequencias da falta de $prog e a URL onde encontra'-lo.
nao_encontrado(){

    local prog
    local acao
    local url

    prog=$1
    acao=$2
    url=$3

    echo
    echo -e "\e[31;01mATENÇÃO:\033[0m"
    echo -e "O programa \e[32;01m$prog\033[0m não foi encontrado. Ou ele não está instalado ou não se encontra em algum dos caminhos contidos na variável PATH. Algumas funcionalidades do livrinho não estarão presentes. Esse programa é necessário para $acao."
    echo -e "\e[32;01m$prog\033[0m pode ser obtido em"
    echo -e "        \e[32;01m $url \033[0m"
    echo
}


###
### Faz o download do arquivo especificado na linha de comando
###
download_arquivo(){

    local url
    local arq_url
    local url_basename
    local tmp
    local base
    local prot
    local hah_arq

    url=$1
    tmp="/tmp/livrinho$$"
    hah_arq=

    if [ "`echo $url | cut -c -6`" == "ftp://" ]; then
	prot='ftp:\/\/' 
	url_basename=`echo $url | cut -c 7- | xargs basename`
    fi

    if [ "`echo $url | cut -c -7`" == "http://" ]; then
	prot='http:\/\/'
	url_basename=`echo $url | cut -c 8- | xargs basename`
    fi

    if [ "`echo $url | cut -c -8`" == "https://" ]; then
	prot='https:\/\/'
	url_basename=`echo $url | cut -c 9- | xargs basename`
    fi

    # Verifica se foi especificado um arquivo ao final da URL
    case ${url_basename##*.} in
	"html" | "htm" | "HTM" | "HTML")
	    hah_arq=1
	    ;;
    esac

    mkdir $tmp
    
    echo -e "\e[31;01mATENÇÃO:\033[0m o uso de URLs como entrada pode não funcionar corretamente (experimental).\n"
    msg "Fazendo o \"download\" de $url"
    $_WGET --quiet -x -E -nv -nH -p -B $tmp $url -P $tmp
    [ $? != "0" ] && msg "Erro ao fazer o \"download\" de $url." && msg_falha && exit $? || msg_ok

    # Insere uma barra no final da URL e a retira (tenta duas vezes)
    url=${url}/
    base=`echo $url | sed "s/${prot}[^/]*\///; s/~/%7E/g; s/\/$//"`
    base=`echo $url | sed "s/${prot}[^/]*\///; s/~/%7E/g; s/\/$//"`


    if [ -z "$hah_arq" ]; then
        # retira a ultima barra da URL
	url=`echo $url | sed "s/\/$//"`

	if [ -e "$tmp/$base/index.html" ]; then
	    filename=index.html
	elif [ -e "$tmp/$base/index.htm" ]; then
	    filename=index.htm
	elif [ -e "$tmp/$base/INDEX.HTM" ]; then
	    filename=INDEX.HTM
	elif [ -e "$tmp/$base/INDEX.HTML" ]; then
	    filename=INDEX.HTML
	else
	    echo "$tmp/$base"
	    msg "Não foi possível encontrar o arquivo a ser convertido."
	    msg_falha
	    rm -rf $tmp
	    exit $ERRO
	fi

	arq="`echo $url | sed "s/${prot}//; s/\/.*//"`.ps"
	arqpdf="`echo $url | sed "s/${prot}//; s/\/.*//"`.pdf"

	msg "Convertendo $url para $arq ..."
	$HTML2PS --number -b "$url" $tmp/${base}/$filename > $arq 2>/dev/null
	[ $? != "0" ] && msg "Erro ao converter $url." && msg_falha && exit $? || msg_ok
	$PS2PDF -sPAPERSIZE=a4 $arq &>/dev/null
	$PDF2PS $arqpdf
	rm -f $arqpdf
	ARQ=$arq
    else
	arq="`echo $url | sed "s/${prot}//; s/\/.*//"`.ps"
	arqpdf="`echo $url | sed "s/${prot}//; s/\/.*//"`.pdf"

	msg "Convertendo $url para $arq ..."
	$HTML2PS --number -b "$url" $tmp/$base > $arq 2>/dev/null
	[ $? != "0" ] && msg "Erro ao converter $url." && msg_falha && exit $? || msg_ok
	$PS2PDF -sPAPERSIZE=a4 $arq &>/dev/null
	$PDF2PS $arqpdf
	rm -f $arqpdf
	ARQ=$arq
    fi

    echo "ARQ = $ARQ"
    rm -rf $tmp

}

################################################################
################################################################
################################################################

# Codigos de saida
ERRO=1
OK=0

# Inicializacao de algumas variaveis
ARQ_SS=
OPTS=
TIPO_LIVRINHO=
QUIETO=
FORCA_ASCII=
JAH_EXISTIA=
EH_URL=

# Programas utilizados
PSTOPS=pstops
PDF2PS=pdftops
A2PS=a2ps
DVIPS=dvips
HTML2PS=html2ps
PS2PDF=ps2pdf
_GZIP=gzip
_UNZIP=unzip
_BZIP=bzip2
_WGET=wget

# ARGS recebe todos os argumentos
ARGS=$@

# Se nao foram especificados argumentos, sai
[ -z "$ARGS" ] && uso $ERRO

# ARQ e' o ultimo argumento e verifica se foram passadas outras opcoes
for a; do
    if [ "$a" == "--quieto" ] || [ "$a" == "-q" ]; then
	QUIETO=1
    fi
    if [ "$a" == "--ascii" ] || [ "$a" == "-a" ]; then
	FORCA_ASCII=1
    fi    

    ARQ=$a
done

# Testa se os argumentos sao validos
for a in ${ARGS%$ARQ}; do
    case $a in
	"-ps" | "-pdf" | "-psgz" | "-g1" | "-g2" | "-2s" | "-4s" | "-6s" | "-8s" | "--gibi1arq" | "--gibi2arq" | "--2slides" | "--4slides" | "--6slides" | "--8slides" | "-h" | "--help" | "--quieto" | "-q" | "--ascii" | "-a")
	    ;;
	*)
	    uso $ERRO
    esac
done

# Se um dos argumentos e' uma solicitacao
# de ajuda (help), imprime e sai
for a; do
    case "$a" in
	"--help" | "-h")
	    uso $OK
	    ;;
    esac
done

# Verifica se a entrada e' uma URL
if [ "`echo $ARQ | cut -c -6`" == "ftp://" ] || \
   [ "`echo $ARQ | cut -c -7`" == "http://" ] || \
   [ "`echo $ARQ | cut -c -8`" == "https://" ]; then
    URL=$ARQ
    EH_URL=1
else
    # Testa se o arquivo de entrada existe
    if [ ! -e "$ARQ" ]; then
	msg "$ARQ não existe ou não é um arquivo."
	msg_falha
	exit $ERRO
    fi
fi

# Verifica se todos os programas necessarios podem ser encontrados
verifica_programas

# Se a entrada for uma URL, faz o download e converte
if [ ! -z "$EH_URL" ]; then
    download_arquivo $URL
fi

# Verifica o tipo de arquivo de entrada
tipo_entrada $ARQ

# Verifica qual tipo de livrinho a gerar
tipo_livrinho

# Invoca a funcao correspondente ao formato do arquivo de entrada
mapeia_formato

# Converte o livrinho para o formato de saida especificado
# na invocacao do programa
converte_saida

exit $OK