#!/bin/sh

# ----------------------------
# prepare-mx-chroot.sh
# version 3.8.3.2
# ----------------------------

script_call_name=`basename ${0}`
usage_str=`echo "Usage:" ./"${script_call_name}" "--normal | --fresh | --farm-only [ --copy-gits ]"`

# --------------------------------------------------------------------------------

NORMAL_OPT=""
FRESH_OPT=""
FARM_ONLY_OPT=""
COPY_GITS_OPT=""
for arg in $@
do
  [ $arg = "--normal" ] && NORMAL_OPT="yes" && continue
  [ $arg = "--fresh" ] && FRESH_OPT="yes" && continue
  [ $arg = "--farm-only" ] && FARM_ONLY_OPT="yes" && continue
  [ $arg = "--copy-gits" ] && COPY_GITS_OPT="yes" && continue
  if [ $arg = "--help" ] || [ $arg = "--usage" ]; then
    echo "${usage_str}"
    exit 0
  fi
  echo "${0}: unknown option '${arg}'"
done

if [ -z ${NORMAL_OPT} ] && [ -z ${FRESH_OPT} ] && [ -z ${FARM_ONLY_OPT} ]; then
  echo "${usage_str}"
  exit 0
fi
if [ ! -z ${FRESH_OPT} ] && [ ! -z ${NORMAL_OPT} ]; then
  echo "--normal and --fresh options are mutually exclusive!"
  echo "please, specify only one of them"
  exit 1
fi
if [ ! -z ${FRESH_OPT} ] && [ ! -z ${FARM_ONLY_OPT} ]; then
  echo "--farm-only and --fresh options are mutually exclusive!"
  echo "please, specify only one of them"
  exit 1
fi
if [ ! -z ${FARM_ONLY_OPT} ] && [ ! -z ${NORMAL_OPT} ]; then
  echo "--normal and --farm-only options are mutually exclusive!"
  echo "please, specify only one of them"
  exit 1
fi

# --------------------------------------------------------------------------------

cd `dirname "${0}"`

script_wdir=`pwd`
[ -z "${USERNAME}" ] && USERNAME=`logname`
# sed 's/^[ \t]*//;s/[ \t]*$//' is used to delete both leading and trailing whitespace
USERHOME=`finger -l "${USERNAME}" 2>/dev/null | grep "Directory:" | cut -f1 | cut -d':' -f2 | sed 's/^[ \t]*//;s/[ \t]*$//'`
[ -z "${USERHOME}" ] && USERHOME="/home/`logname`"
[ -z "${CHROOT_DIR}" ] && CHROOT_DIR="${script_wdir}"/mx-chroot
[ -z "${BUILDFARM_DIR}" ] && BUILDFARM_DIR="${USERHOME}/build-farm"

if [ ! -z ${FRESH_OPT} ]; then
  if [ -d "${CHROOT_DIR}" ]; then
    proc_sys_dev_okay=""
    mkdir -p "${CHROOT_DIR}"/proc && rmdir "${CHROOT_DIR}"/proc 2>/dev/null && \
      mkdir -p "${CHROOT_DIR}"/sys && rmdir "${CHROOT_DIR}"/sys 2>/dev/null && \
        mkdir -p "${CHROOT_DIR}"/dev && rmdir "${CHROOT_DIR}"/dev 2>/dev/null && \
          proc_sys_dev_okay="yes"
    if [ -z ${proc_sys_dev_okay} ]; then
      echo "/proc, /sys and/or /dev are \"real\"; can't make totally fresh chroot"
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/bin
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/sbin
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/lib
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/usr
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/root
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/etc
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/var
      [ ! -z "${CHROOT_DIR}" ] && rm -rf "${CHROOT_DIR}"/tmp
    else
      echo "removing everything from previous mx-chroot!"
      rm -rf "${CHROOT_DIR}" && mkdir "${CHROOT_DIR}"
    fi
  else
    echo "directory '${CHROOT_DIR}' doesn't exist; creating it"
    mkdir -p "${CHROOT_DIR}"
  fi
else
  if [ ! -d "${CHROOT_DIR}" ]; then
    printf "%s '%s'\n" "creating chroot directory" "${CHROOT_DIR}"
    mkdir -p "${CHROOT_DIR}"
  fi
fi

if [ -z ${FARM_ONLY_OPT} ]; then
  [ -z "${PACKAGES_DIR}" ] && PACKAGES_DIR="PACKAGES"
  
  if [ -z ${ARCH_NAME} ]; then
    binpkg_dir=`find "${BUILDFARM_DIR}/${PACKAGES_DIR}" -name "binpkg-*" | head -1`
    ARCH_NAME=`basename "${binpkg_dir}" | sed 's/binpkg-//'`
  fi
  
  _binpkgs_path=""
  [ -d "${BUILDFARM_DIR}/${PACKAGES_DIR}"/binpkg ] && \
    _binpkgs_path="${BUILDFARM_DIR}/${PACKAGES_DIR}"/binpkg
  [ -d "${BUILDFARM_DIR}/${PACKAGES_DIR}"/binpkg-"${ARCH_NAME}" ] && \
    _binpkgs_path="${BUILDFARM_DIR}/${PACKAGES_DIR}"/binpkg-"${ARCH_NAME}"
  
  if [ -z "${_binpkgs_path}" ]; then
    echo "no packages found"
  else
    list_of_binpkgs=`ls "${_binpkgs_path}" 2>/dev/null`
    _num_of_binpkgs=`echo "${list_of_binpkgs}" | wc -l`
    
    # EXCLUDE_LIST file; note that only lines beginning with `-' are counted
    pkg_exclude_list_real=""
    pkg_exclude_list_from_file=""
    [ -f "${BUILDFARM_DIR}/${PACKAGES_DIR}"/EXCLUDE_LIST ] && \
      pkg_exclude_list_from_file=`cat "${BUILDFARM_DIR}/${PACKAGES_DIR}"/EXCLUDE_LIST 2>/dev/null | grep '^-'`
    if [ ! -z "${pkg_exclude_list_from_file}" ]; then
      printf "packages to be excluded:"
      for pack in `echo "${pkg_exclude_list_from_file}"`; do
        pack=`echo "${pack}" | sed 's/-//'`
        _is_present=`echo "${list_of_binpkgs}" | grep "${pack}\-"`
        [ -z "${_is_present}" ] || pkg_exclude_list_real="${pkg_exclude_list_real} ${pack}"
      done
      if [ ! -z "${pkg_exclude_list_real}" ]; then
        echo "${pkg_exclude_list_real}"
      else
        echo " (none)"
      fi
    fi
    
    printf "copying binary packages"
    
    if [ -z "${pkg_exclude_list_real}" ]; then
      printf " (%d packages)..." $_num_of_binpkgs
    else
      pkg_exclude_list_real=`echo "${pkg_exclude_list_real}" | tr ' ' '\n' | sed '/^$/d'`
      _excluded_count=`echo "${pkg_exclude_list_real}" | wc -l`
      printf " (%d packages out of %d total)..." `expr $_num_of_binpkgs '-' $_excluded_count` $_num_of_binpkgs
    fi
    echo "${list_of_binpkgs}" | while read pkg; do
      _pkgtitle=`echo "${pkg}" | cut -d'-' -f1`
      _is_excluded=`echo "${pkg_exclude_list_real}" | grep -w "${_pkgtitle}"`
      if [ -z "${_is_excluded}" ]; then
        printf " %s" "${_pkgtitle}"
        cp "${_binpkgs_path}"/"${pkg}" "${CHROOT_DIR}"/ 2>/dev/null
      fi
    done
    echo " - ok"
  fi
fi

CHROOT_BUILDFARM_DIR="${CHROOT_DIR}/root/build-farm"

if [ -d "${BUILDFARM_DIR}" ]; then
  rm -f "${CHROOT_DIR}"/*glibc.binpkg*
  rm -f "${CHROOT_DIR}"/*gnu.binpkg*
  rm -f "${CHROOT_DIR}"/*unknown.binpkg*
  if [ -d "${BUILDFARM_DIR}"/SERVICE-SCRIPTS ]; then
    mkdir -p "${CHROOT_BUILDFARM_DIR}"/SERVICE-SCRIPTS
    cp "${BUILDFARM_DIR}"/SERVICE-SCRIPTS/*.sh "${CHROOT_BUILDFARM_DIR}"/SERVICE-SCRIPTS/ 1>/dev/null
    cp -r "${BUILDFARM_DIR}"/SERVICE-SCRIPTS/VCHECKCMDS "${CHROOT_BUILDFARM_DIR}"/SERVICE-SCRIPTS/ 1>/dev/null
    cp "${CHROOT_BUILDFARM_DIR}"/SERVICE-SCRIPTS/chroot-here.sh "${CHROOT_DIR}"/
  fi
else
  echo "build-farm ('${BUILDFARM_DIR}') doesn't exist"
fi

cd "${CHROOT_DIR}"
if [ -z ${FARM_ONLY_OPT} ]; then
  if [ -f "${CHROOT_BUILDFARM_DIR}"/SERVICE-SCRIPTS/unpack-them.sh ]; then
    cp "${CHROOT_BUILDFARM_DIR}"/SERVICE-SCRIPTS/unpack-them.sh "${CHROOT_DIR}"/
    chmod +x ./unpack-them.sh
    ./unpack-them.sh
    rm -f *.tar.*
    rm -f ./unpack-them.sh
  fi
fi

if [ -d "${BUILDFARM_DIR}"/BUILD-SCRIPTS ]; then
  re_or_not_re=""
  if [ -d "${CHROOT_BUILDFARM_DIR}"/BUILD-SCRIPTS ]; then
    rm -rf "${CHROOT_BUILDFARM_DIR}"/BUILD-SCRIPTS
    re_or_not_re="re-"
  fi
  echo -n "${re_or_not_re}generating build farm..."
  mkdir -p "${CHROOT_BUILDFARM_DIR}"
  cp -r "${BUILDFARM_DIR}"/BUILD-SCRIPTS "${CHROOT_BUILDFARM_DIR}"/ 1>/dev/null
  if [ $? -eq 0 ]; then echo " ok"; else echo " fail"; fi
  rm -rf "${CHROOT_BUILDFARM_DIR}"/BUILD-SCRIPTS/_BIGSYSTEM
  
  if [ ! -z ${COPY_GITS_OPT} ]; then
    echo "copying local git repos:"
    cd "${BUILDFARM_DIR}"
    for curr_entry in *
    do
      if [ -d "${BUILDFARM_DIR}/${curr_entry}" ]; then
        if [ -z `echo "${curr_entry}" | grep -- "-build"` ] && 
              [ -z `echo "${curr_entry}" | grep -- "-disabled"` ]; then
          if [ ! -z `echo "${curr_entry}" | grep -- "-git"` ]
          then
            curr_git_repo_dir=`echo "${curr_entry}" | sed 's/"${BUILDFARM_DIR}"//'`
            printf "\t%s..." "${curr_git_repo_dir}"
            cp -dR --preserve=all ./"${curr_git_repo_dir}" "${CHROOT_BUILDFARM_DIR}"/
            if [ $? -eq 0 ]; then echo " done"; else echo " fail!"; fi
          fi
        fi
      fi
    done
  fi
else
  echo "build farm scripts ('${BUILDFARM_DIR}/BUILD-SCRIPTS') not found!"
fi

# self-update
if [ -d "${BUILDFARM_DIR}"/SERVICE-SCRIPTS ]; then
  script_name=`basename "${0}"`
  rm -f "${script_wdir}"/"${script_name}".NEW
  cp "${BUILDFARM_DIR}"/SERVICE-SCRIPTS/"${script_name}" "${script_wdir}"/"${script_name}".NEW
  diff -u "${script_wdir}"/"${script_name}" "${script_wdir}"/"${script_name}".NEW 1>/dev/null 2>&1 && \
    rm -f "${script_wdir}"/"${script_name}".NEW
  [ -f "${script_wdir}"/"${script_name}".NEW ] && printf "found new version of this script, see '%s'\n" "${script_name}".NEW
fi

current_date=`date`
echo "${current_date}" >"${CHROOT_DIR}"/.timestamp
echo "timestamp:" "${current_date}"

echo "-done-"