#!/bin/bash

LFS_PKG_BASE="$(dirname $(pwd))/packages"
LFS_PKG_DIR="${LFS_PKG_BASE}/${LFS_STAGE}"
LFS_LOG_DIR="${LFS}/var/log/hvlinux-install/${LFS_STAGE}"
LFS_LOG_FILE="${LFS_LOG_DIR}/pkg-update.log"
WGET_LOG_FILE="${LFS_LOG_DIR}/pkg-wget.log"

# URL
LFS_BASE_URL="http://www.linuxfromscratch.org"
CLFS_BASE_URL="http://svn.cross-lfs.org/svn/repos/cross-lfs/trunk"
HV_BASE_URL="http://www.hugovil.com/hvlinux-repository"

LFS_PATCHES_URL="${LFS_BASE_URL}/patches/lfs/development"
BLFS_PATCHES_URL="${LFS_BASE_URL}/patches/blfs/svn"
CLFS_PATCHES_URL="http://patches.cross-lfs.org/dev"
HV_PATCHES_URL="${HV_BASE_URL}/patches"

LFS_PACKAGES_URL="ftp://ftp.osuosl.org/pub/lfs/lfs-packages/conglomeration"
HV_PACKAGES_URL="${HV_BASE_URL}/packages"
SOURCEFORGE_URL="http://cdnetworks-us-1.dl.sourceforge.net"
GNOME_URL="http://ftp.gnome.org/pub/gnome/sources"
GNU_URL="http://ftp.gnu.org/pub/gnu"
TETEX_URL="http://www.tug.org/ftp/tex-archive/systems/unix/teTeX"
BLFS_XORG_URL="http://anduin.linuxfromscratch.org/files/BLFS/svn/xorg"
XORG_URL="http://xorg.freedesktop.org/releases/individual"

WGETCMD="wget --directory-prefix=${LFS_PKG_DIR} --timeout=15 --tries=3 -nc --continue --no-check-certificate --no-verbose --output-file=${WGET_LOG_FILE}"

LFS_PATCHES_LIST=${LFS_PKG_DIR}/patches-list-lfs.html
BLFS_PATCHES_LIST=${LFS_PKG_DIR}/patches-list-blfs.html
CLFS_PATCHES_LIST=${LFS_PKG_DIR}/patches-list-clfs.html
HV_PATCHES_LIST=${LFS_PKG_DIR}/patches-list-hv.html

# Arg. #1: URL for patches repository.
# Arg. #2: Destination filename.
static_fetch_patches_list()
{
    PATCHES_URL=${1}
    PATCHES_LIST_FILENAME=${2}

    ${WGETCMD} "${PATCHES_URL}/" &&

    # Append log to global log file
    cat ${WGET_LOG_FILE} >> ${LFS_LOG_FILE} &&

    mv ${LFS_PKG_DIR}/index.html ${PATCHES_LIST_FILENAME}
}

# Arg. #1: URL for patches repository. The trailing
#          slash is absolutely necessary for this to work.
update_packages_init()
{
    # Execute a return statement instead of exit, to be able to continue with
    # downloading other packages
    export RCMD_NO_EXIT=1

    # First create log directory if it does not exists.
    if [ ! -d ${LFS_LOG_DIR} ]; then
	install -m755 -d ${LFS_LOG_DIR} || exit 1
    fi

    # Then create destination directory if it does not exists.
    if [ ! -d ${LFS_PKG_DIR} ]; then
	install -v -m755 -d ${LFS_PKG_DIR} 1> ${LFS_LOG_FILE} 2>&1 || exit 1
    fi

    if [ -n "${USE_LFS_PATCHES}" ]; then
        # Getting list of all patches from LFS server.
        rcmd "Fetching LFS patches list" static_fetch_patches_list ${LFS_PATCHES_URL} ${LFS_PATCHES_LIST}
    fi

    if [ -n "${USE_BLFS_PATCHES}" ]; then
        # Getting list of all patches from BLFS server.
        rcmd "Fetching BLFS patches list" static_fetch_patches_list ${BLFS_PATCHES_URL} ${BLFS_PATCHES_LIST}
    fi

    if [ -n "${USE_CLFS_PATCHES}" ]; then
        # Getting list of all patches from CLFS server.
        rcmd "Fetching CLFS patches list" static_fetch_patches_list ${CLFS_PATCHES_URL} ${CLFS_PATCHES_LIST}
    fi

    if [ -n "${USE_HV_PATCHES}" ]; then
        # Getting list of all patches from hugovil.com server.
        rcmd "Fetching hugovil.com patches list" static_fetch_patches_list ${HV_PATCHES_URL} ${HV_PATCHES_LIST}
    fi
}

# Get patch package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: Patches list file (HTML)
# Arg. #3: Patches URL
static_checkpatch()
{
    local PACK=${1}
    local PATCHES_LIST=${2}
    local PATCHES_URL=${3}

    # Remplace les "+" par "%2B"
    local PACK_URL=$(echo $PACK | sed s!\+!%2B!g)

    local PATCHES_FOUND=$(cat ${PATCHES_LIST} | grep "${PACK_URL}-" | sed "s/.*\(${PACK_URL}-.*\.patch\).*/\1/")
    if [ -n "${PATCHES_FOUND}" ]; then
	for p in ${PATCHES_FOUND}; do
            # Remplace les "%2B" par "+"
            PATCH_NAME=$(echo ${p} | sed s!%2B!\+!g)

	    if [ ! -f ${LFS_PKG_DIR}/${PATCH_NAME} ]; then
		rcmd "Fetching ${PATCH_NAME} from ${PATCHES_URL}" ${WGETCMD} ${PATCHES_URL}/${p}
	    fi
	done
    fi
}

# Get patch package if it is not in the repository
# Arg. #1: Package name and version
static_getpatch()
{
    PACK=${1}

    # Checking for correct number of arguments
    if [ $# -ne 1 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    if [ -n "${USE_LFS_PATCHES}" ]; then
        # Checking if patch is available from LFS.
        static_checkpatch ${PACK} ${LFS_PATCHES_LIST} ${LFS_PATCHES_URL}
    fi

    if [ -n "${USE_BLFS_PATCHES}" ]; then
        # Checking if patch is available from BLFS.
        static_checkpatch ${PACK} ${BLFS_PATCHES_LIST} ${BLFS_PATCHES_URL}
    fi

    if [ -n "${USE_CLFS_PATCHES}" ]; then
        # Checking if patch is available from CLFS.
        static_checkpatch ${PACK} ${CLFS_PATCHES_LIST} ${CLFS_PATCHES_URL}
    fi

    if [ -n "${USE_HV_PATCHES}" ]; then
        # Checking if patch is available from hugovil.com.
        static_checkpatch ${PACK} ${HV_PATCHES_LIST} ${HV_PATCHES_URL}
    fi
}

# Convert multiple compressed gzip files to bzip2.
# Usage: gztobz2 [FILES]
gztobz2()
{
    if [ $# = 0 ]; then
	echo "$0: -- Convert multiple compressed gzip files to bzip2."
	echo "Usage: $0: [FILES]"
	return 1
    fi
    
    while [ $# -ne 0 ]; do
	local ORIG_GZIPPED_FILENAME=${1}
	
	# Checking if input file exist.
	if [ ! -f $1 ]; then
	    echo "$0: File ${ORIG_GZIPPED_FILENAME} not found."
	    return 1
	fi
	
	# Checking if input file is a valid gzipped file.
	gzip -t ${ORIG_GZIPPED_FILENAME}
	if [ $? -ne 0 ] ; then
	    echo "$0: File ${ORIG_GZIPPED_FILENAME} is not a valid gzip file."
	    return 1
	fi
	
	# Obtaining uncompressed name of file
	local FILENAME=$(gunzip -l ${ORIG_GZIPPED_FILENAME} | sed '1d' | sed 's/\(.*\)% \(.*\)/\2/')
	
	# Decompressing file to standard output and piping result to bzip2
	gunzip ${ORIG_GZIPPED_FILENAME} --stdout | bzip2 --best > ${FILENAME}.bz2
	if [ $? -ne 0 ] ; then
	    echo "$0: Error converting file ${ORIG_GZIPPED_FILENAME} to bzip2."
	    return 1
	fi
	
	# Keeping the original file's timestamp
	touch --reference=${ORIG_GZIPPED_FILENAME} ${FILENAME}.bz2
	
	# Deleting original gzipped file
	if [ -f ${FILENAME}.bz2 ]; then
	    rm ${ORIG_GZIPPED_FILENAME}
	fi
	
	shift
    done
}

detect_file_not_found()
{
    # HTTP: will return error code 404.
    # FTP: will say "File not found"
    if grep "404" ${WGET_LOG_FILE} 1> /dev/null 2>&1; then
        echo "404 NOTFOUND"
        return 0
    elif grep "No such file" ${WGET_LOG_FILE} 1> /dev/null 2>&1; then
        echo "No such file"
        return 0
    else
        return 1
    fi
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: URL
# Arg. #3: Optional extension
static_getpkg()
{
    local PACK=${1}
    local URL=${2}
    local MY_ARCH_EXT=${3}

    # Checking for correct number of arguments
    if [ $# -ne 2 -a $# -ne 3 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    if [ -z "${MY_ARCH_EXT}" ]; then
        # List of default archive extensions to try
        MY_ARCH_EXT="tar.bz2 tar.gz tgz tar.Z"
    fi

    for arch_ext in ${MY_ARCH_EXT}; do
        # Don't take any chance: remove any partially downloaded file.
        # If we arrive here, it means the final destination file was not found
        # so we can safely remove any file prior to trying to download it.
        rm -f ${LFS_PKG_DIR}/${PACK}.${arch_ext}

        rcmd "Fetching ${PACK}.${arch_ext}" ${WGETCMD} ${URL}/${PACK}.${arch_ext}
        wget_status=$?

        # Append log to global log file
        cat ${WGET_LOG_FILE} >> ${LFS_LOG_FILE}

        # Failure: if it was a connection timeout, don't try for other file
        # extensions.
        if grep "failed: Connection timed out" ${WGET_LOG_FILE} 1> /dev/null 2>&1; then
            echo "Error, wget reported: Connection timed out"
            return 1
        fi

        if detect_file_not_found; then
            # Try next archive extension if web server reported that file is not
            # found.
            continue;
        fi

        if [ ${wget_status} -ne 0 ]; then
            echo "Error fetching package ${PACK}.${arch_ext}"
            return 1
        fi

        # If we are here, it means the file was successfully downloaded.
        if [ "x${arch_ext}" = "xtar.gz" -o "x${arch_ext}" = "xtgz" \
            -o "x${arch_ext}" = "xtar.Z" ]; then
	    gztobz2 ${LFS_PKG_DIR}/${PACK}.${arch_ext}
        fi
        return $?
    done

    # Failure or file not found
    return 1
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: URL
# Options:
#   -e     File extension (default is tar.bz2)
#   -d     Fetch directory (default is LFS_PKG_DIR)
#   -f     Filename on server (default is PACKAGE)
#   -h     Display this help and returns
#   -s     Subdirectory on server
fpkg()
{
    local FILE_EXT=""
    local DEST_DIR=""
    local SRC_FILENAME=""
    local SRC_DIR=""

    while getopts "e:d:f:hs:" flag ;do
        case ${flag} in
	    e)
                # File extension
                FILE_EXT=${OPTARG}
	        ;;
	    d)
                # Fetch directory (where to put file)
                DEST_DIR=${OPTARG}
	        ;;
	    f)
                # Filename if different than package name
                SRC_FILENAME=${OPTARG}
	        ;;
 	    s)
	        SRC_DIR=${OPTARG}
                ;;
	    ?)
	        echo "${FUNCNAME}(): Invalid option: ${OPTARG}."
	        return 1
	        ;;
        esac
    done
    shift `expr "${OPTIND}" - 1`

    unset OPTSTRING
    unset OPTIND
    unset OPTARG

    # Checking for correct number of arguments
    if [ $# -ne 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    local PACK=${1}
    local URL=${2}

    if [ -z "${SRC_FILENAME}" ]; then
        # Default source filename = name of package
        SRC_FILENAME=${PACK}
    fi

    if [ -z "${FILE_EXT}" -o \
        "x${FILE_EXT}" = "xtar.gz" -o \
        "x${FILE_EXT}" = "xtgz" -o \
        "x${FILE_EXT}" = "xtar.Z" -o \
        "x${FILE_EXT}" = "xtar.bz2" \
        ]; then
        FINAL_EXT=tar.bz2
    else
        FINAL_EXT=${FILE_EXT}
    fi

    if [ -z "${DEST_DIR}" ]; then
        # Default destination directory
        DEST_DIR=${LFS_PKG_DIR}
    fi

    mkdir -v -p ${DEST_DIR} >> ${LFS_LOG_FILE} 2>&1

    if [ -z "${SRC_DIR}" ]; then
        # Default source subdirectory on server
        SRC_DIR=""
    else
        URL=${URL}/${SRC_DIR}
    fi

    DEST_FILE=${DEST_DIR}/${PACK}.${FINAL_EXT}

    if [ ! -f ${DEST_FILE} ]; then
        set +e
        static_getpkg ${SRC_FILENAME} ${URL} ${FILE_EXT}
        set -e

        # Move file if source filename is not equal to package name and/or destination
        # directory is not the default:
        DOWNLOADED_FILE=${LFS_PKG_DIR}/${SRC_FILENAME}.${FINAL_EXT}

        if [ "${DEST_FILE}" != "${DOWNLOADED_FILE}" ]; then
	    mv ${DOWNLOADED_FILE} ${DEST_FILE}
	fi
    fi

    # Test integrity of archive if requested
    if [ -f ${DEST_FILE} -a -n "${TEST_INTEGRITY}" -a "x${FINAL_EXT}" = "xtar.bz2" ]; then
        rcmd "Testing integrity of ${PACK}.${FINAL_EXT}" bzip2 -t ${DEST_FILE}
    fi

    # Check for available patches with PACKAGE (TARGET) name.
    static_getpatch ${PACK}

    if [ ${SRC_FILENAME} != ${PACK} ]; then
        # Check for available patches with SRC_FILENAME name.
        static_getpatch ${SRC_FILENAME}

        # Rename any patch fetched (in fpkg call) and replace SOURCE by TARGET
        # in patch name.
        if ls ${LFS_PKG_DIR}/${SRC_FILENAME}-*.patch 1> /dev/null 2>&1; then
            echo "CMD=${SRC_FILENAME} ${PACK} ${LFS_PKG_DIR}/${SRC_FILENAME}-*.patch"
	    rename ${SRC_FILENAME} ${PACK} ${LFS_PKG_DIR}/${SRC_FILENAME}-*.patch
        fi
    fi
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: Directory name (optional)
fpkg_gnu()
{
    local PACK=${1}

    if [ $# -eq 2 ]; then
	NAME=${2}
    else
	NAME=$(get_pkg_name ${PACK})
    fi

    # Checking for correct number of arguments
    if [ $# -lt 1 -o $# -gt 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    fpkg ${PACK} "${GNU_URL}/${NAME}"
}

# Fetch Gnome package (if it is not in the repository).
# Arg. #1: Package name and version
# Arg. #2: Directory name (optional)
fpkg_gnome()
{
    PACK=${1}

    if [ $# -eq 2 ]; then
	NAME=${2}
    else
	NAME=$(get_pkg_name ${PACK})
    fi

    # Checking for correct number of arguments
    if [ $# -lt 1 -o $# -gt 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    fpkg ${PACK} "${GNOME_URL}/${NAME}/$(get_pkg_ver_base ${PACK})"
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: Directory name (optional)
fpkg_sf()
{
    PACK=${1}

    if [ $# -eq 2 ]; then
	NAME=${2}
    else
	NAME=$(get_pkg_name ${PACK})
    fi
    
    # Checking for correct number of arguments
    if [ $# -lt 1 -o $# -gt 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    fpkg ${PACK} ${SOURCEFORGE_URL}/${NAME}
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: Directory name (optional)
fpkg_hv()
{
    PACK=${1}

    # Checking for correct number of arguments
    if [ $# -lt 1 -o $# -gt 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    if [ $# -eq 2 ]; then
	fpkg ${PACK} "${HV_PACKAGES_URL}/${2}"
    else
	fpkg ${PACK} ${HV_PACKAGES_URL}
    fi
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: Directory name (optional)
fpkg_lfs()
{
    PACK=${1}

    # Checking for correct number of arguments
    if [ $# -lt 1 -o $# -gt 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    if [ $# -eq 2 ]; then
	fpkg ${PACK} "${LFS_PACKAGES_URL}/${2}"
    else
	fpkg ${PACK} ${LFS_PACKAGES_URL}
    fi
}

# Get package if it is not in the repository
# Arg. #1: Package name and version
# Arg. #2: Subdirectory name (module name)
fpkg_xorg()
{
    local PACK=${1}
    local SUBDIR=${2}

    # Checking for correct number of arguments
    if [ $# -ne 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    fpkg -d ${LFS_PKG_DIR}/${SUBDIR} -s ${SUBDIR} ${PACK} ${XORG_URL}
}

# Create a symbolic link to a package that is located in another stage
# repository (to not have the same file twice).
# Arg. #1: Source stage number (1, 2, 3, etc)
# Arg. #2: Package name
lpkg()
{
    SRCSTAGE="stage${1}"
    FILE="${2}.tar.bz2"
    PACKAGE_NAME="${2}"

    # Checking for correct number of arguments
    if [ $# -ne 2 ]; then
	echo "${FUNCNAME}(), wrong number of arguments: ${*}"
	return 1
    fi

    if [ ! -h ${LFS_PKG_DIR}/${FILE} ]; then
	# Issue a warning if source file doesn't exist.
	if [ ! -f ${LFS_PKG_BASE}/${SRCSTAGE}/${FILE} ]; then
            source_link_status=" (missing source file)"
        else
            source_link_status=""
	fi

	# Create link if it doesn't exist
	rcmd "Linking ${PACKAGE_NAME}${source_link_status}" ln -s ../${SRCSTAGE}/${FILE} ${LFS_PKG_DIR}/${FILE}
    fi

    # Create link for patches corresponding to that package:
    if ls ${LFS_PKG_BASE}/${SRCSTAGE}/${PACKAGE_NAME}-*.patch 1> /dev/null 2>&1; then
	for patch in ${LFS_PKG_BASE}/${SRCSTAGE}/${PACKAGE_NAME}-*.patch; do
	    PATCHFILE=$(basename ${patch})
	    if [ ! -h ${LFS_PKG_DIR}/${PATCHFILE} ]; then
		# Create link if it doesn't exist
		rcmd "Linking ${PATCHFILE}" ln -s ../${SRCSTAGE}/${PATCHFILE} ${LFS_PKG_DIR}/${PATCHFILE}
	    fi
	done
    fi
}