#!/bin/sh
if [ -x /bin/ksh -a -z "$_PSNP_" ]; then
  _PSNP_=1; export _PSNP_; exec env SH=/bin/ksh /bin/ksh $0 "$@"
fi
myname=`basename $0`
mydir=`dirname $0`
pkgs=${PKGS}
prefix=${PKG_PREFIX:-/usr/pkg.`date +%F`}
export LANG=C LC_CTYPE=C; unset LC_MESSAGES LC_TIME
cc=${COMPILER:-gcc}
NL='
'					# Newline
type setopt >/dev/null 2>&1 && setopt sh_word_split		# for zsh

usage() {
  cat<<_EOF_
$myname - Create new pkgsrc tree with some required packages

Usage:	$myname [options] PackagesToInstall...
Options are:
	-p PREFIX	Set pkg tree prefix to PREFIX ($prefix)
	-P PKGDIR	Set binary package dir to PKGDIR ($packagedir)
	-j N		Set MAKE_JOBS value to N ($jobs)
	-w DIR		Set WRKOBJDIR value to DIR (\$PREFIX/w)
	-s PKGSRCdir	Location of pkgsrc top directory ($psrc)
	-d DISTdir	Location of pkgsrc DISTDIR ($dist)
	-N		Set X11_TYPE=native (default)
	-M		Set X11_TYPE=modular
	-i 		Install pkgs only - Skip bootstrap
	-a "PkgList..."	Add PkgList... to installation list
	-c yes|no|auto	Use cwrappers mode
	-C		Do clean-depends on each successful build
	-b		Use bash for CONFIG_SHELL and WRAPPER_SHELL
	-U		Replace an already installed package if exists
			(Cannot skip pkg with version number eg. py38-*)

Effective environment variables are:
	PKGSRC		Location of pkgsrc source tree
	DISTDIR		Location of distfiles
	LOCALPATCHES	Location of local patches
	MK_JOBS		Number of MAKE_JOBS (make -j)
	PKG_PREFIX	Installation prefix of pkgsrc software
	COMPILER	Which compiler to build (see bootstrap/README*)

Your choice of initial installation list:
[[$pkgs]]
_EOF_
}
cmd_avail () {
  type "$1" >/dev/null 2>&1
}

if [ -d /usr/X11R7/lib/X11 ]; then		# XX: more suitable way needed
  x11type=native
else
  x11type=modular				# no native xorg on Solaris
fi
if [ -n "$MK_JOBS" ]; then
  jobs=$MK_JOBS
elif ncpu=`sysctl -n hw.ncpu 2>&1`; then
  jobs=${ncpu:-2}
elif cmd_avail cpuctl; then
  jobs=`cpuctl list|tail -1|cut -d' ' -f1`
elif test -f /proc/cpuinfo; then
  jobs=`grep -i '^processor[ 	]*:' /proc/cpuinfo|wc -l`
elif cmd_avail cpucontrol; then
  jobs=`sysctl -n kern.smp.cpus`
elif test -x /usr/sbin/psrinfo >/dev/null 2>&1; then
  jobs=`/usr/sbin/psrinfo | grep -i on-line | wc -l`	# Solaris
fi
if [ -x bootstrap/bootstrap ]; then
  psrc=$PWD
else
  psrc=${PKGSRC:-/usr/pkgsrc}
fi
dist=${DISTDIR:-$psrc/distfiles}

while getopts c:d:j:w:s:NMa:rp:P:iCbU i; do
  case "$i" in
    j)	jobs=$OPTARG; arg_j=$OPTARG  ;;
    w)	work=$OPTARG; WRKOBJDIR=$work;	export WRKOBJDIR ;;
    s)	psrc=$OPTARG ;;
    d)	dist=$OPTARG; DISTDIR=$dist;	export DISTDIR ;;
    p)	prefix=$OPTARG ;;
    P)	packagedir=$OPTARG; PACKAGES=$packagedir; export PACKAGES ;;
    a)	pkgs="$pkgs${pkgs:+ }$OPTARG" ;;
    r)	pkgs="" ;;
    N)	x11type=native ;;
    M)	x11type=modular ;;
    i)	nobootstrap=1 ;;
    c)	cwrappers=$OPTARG ;;
    C)	cleandepends=yes ;;
    b)	usebash=yes; ;;
    U)	replup=yes; ;;
    \?)	usage; exit 2 ;;
  esac
done
shift $((OPTIND-1))
work=${work:-$prefix/w}
packagedir=${packagedir:-$prefix/packages}
pkgs="$pkgs${pkgs:+ }$@"
ARG_J=${arg_j:-${MK_JOBS}}

cd ${psrc:-.}
if [ ! -x bootstrap/bootstrap ]; then
  echo "Cannot find bootstrap in `pwd`"
  echo "Specify pkgsrc top directory with \`-s PKGSRCdir'."
  exit 2
fi


##
# Phase 0 - Check Availability and Preparing variables for compiler stuffs
##
if [ -d /usr/xpg4/bin -a -x /usr/sbin/psrinfo ]; then	# Solaris
  export SHELL=/bin/bash CONFIG_SHELL=/bin/bash		# "export" ok for ksh
  export INSTALL_UNSTRIPPED=yes
  if cmd_avail ${CURL:-curl}; then
    cmd_avail psrinfo || PATH=/usr/sbin:$PATH
    if [ x"`which id`" = x"/bin/id" -o x"`which id`" = x"/usr/bin/id" ]; then
      PATH=/usr/xpg4/bin:$PATH
    fi
    OTHERVARS="$OTHERVARS"$NL$(cat<<-EOF
	FETCH_USING=		custom
	FETCH_CMD=		${CURL:-`which curl`}
	FETCH_BEFORE_ARGS=	-4
	FETCH_AFTER_ARGS=	-O
	FETCH_RESUME_ARGS=	-C -
	FETCH_OUTPUT_ARGS=	-o
	EOF
	 )
  else
    cat 1>&2 <<-EOF
	** You have to prepare curl on Solaris/sparc environment beforehand.
	** Without it, pkgsrc build will be fallen into circular dependency.
	** BE SURE to INSTALL curl and set PATH suitably.
	EOF
    exit 1
  fi
elif [ -n "$usebash" ] && type bash >/dev/null 2>&1; then
  export CONFIG_SHELL=`which bash`
  export WRAPPER_SHELL=$CONFIG_SHELL
fi
export CC="${CC:-`which $cc`}"
bindir=$(dirname `which $CC`) 2>/dev/null
case $CC in
  *gcc)		export GCCBASE=${GCCBASE:-$(dirname $bindir)}
		PATH=$GCCBASE/bin:$PATH
		export CXX=${CXX:-`which g++`} ;;
  *clang)	export CLANGBASE=${CLANGBASE:-$(dirname $bindir)}
		PATH=$CLANGBASE/bin:$PATH
		export CXX=${CXX:-`which clang++`} ;;
  *icc)		export ICCBASE=${ICCBASE:-$(dirname $bindir)} ;;
esac

##
# Phase 1 - bootstrapping
##

case `env PATH=/usr/xpg4/bin:/usr/bin:$PATH id -u` in
  0)	;;
  *)	bo='--unprivileged'
	sudocmd=`which sudo 2>/dev/null`
	;;
esac
if [ $PN_DEBUG$nobootstrap ]; then
  echo Creating test prefix
  mkdir -p $prefix/etc
elif [ -x $prefix/sbin/pkg_info ]; then
  echo You have already configured $prefix.  Skipping bootstrap... 1>&2
elif ! (cd bootstrap && rm -rf work \
	    && ./bootstrap $bo --make-jobs $jobs \
			   ${cwrappers:+--cwrappers=$cwrappers} \
			   --workdir=$work --prefix=$prefix); then
  echo 'Bootstrap of new pkgsrc FAILED!!' 1>&2
  exit 1
fi

##
# Phase 2 - Generate mk.conf
##
if [ ! "$nobootstrap" -a ! -x $prefix/bin/digest ]; then
  mkconf=$prefix/etc/mk.conf
  if ! fgrep $myname $mkconf >/dev/null 2>&1; then
    cat<<_EOF_ | uniq >> $mkconf
# Example $prefix/etc/mk.conf file produced by $myname

.ifdef BSD_PKG_MK	# added by $myname
${ABI:+ABI=		$ABI}
PKGSRCDIR?=		$psrc
DISTDIR?=		$dist
WRKOBJDIR?=		$work
PACKAGES?=		$packagedir
${CC:+CC?=		$CC}
${CXX:+CXX?=		$CXX}
${GCCBASE:+GCCBASE?=		$GCCBASE}
${CLANGBASE:+CLANGBASE?=		$CLANGBASE}
${ICCBASE:+ICCBASE?=		$ICCBASE}
${CONFIG_SHELL:+CONFIG_SHELL?=		$CONFIG_SHELL}
${CONFIG_SHELL:+WRAPPER_SHELL=		$CONFIG_SHELL}
${LOCALPATCHES:+LOCALPATCHES?=		$LOCALPATCHES}

FETCH_BEFORE_ARGS?=		-4
#TOOLS_PLATFORM.ftp?=		ftp -4
${INSTALL_UNSTRIPPED:+:INSTALL_UNSTRIPPED?=	${INSTALL_UNSTRIPPED}}
${sudocmd:+SU_CMD?=	$sudocmd /bin/sh -c}
${OTHERVARS}
# MASTER_SITE_OVERRIDE=http://ftp.jaist.ac.jp/pub/pkgsrc/distfiles/

X11_TYPE=		$x11type
MAKE_JOBS=		${jobs:-2}
ALLOW_VULNERABLE_PACKAGES	+=	xfce4-thunar suse
ACCEPTABLE_LICENSES+= openmotif-license
ACCEPTABLE_LICENSES+= flash-license
ACCEPTABLE_LICENSES+= mozilla-trademark-license
PKG_OPTIONS.firefox=official-mozilla-branding
PKG_OPTIONS.firefox60=official-mozilla-branding -pulseaudio oss
PKG_OPTIONS.ghostscript+= disable-compile-inits
PKG_OPTIONS.gvfs=	-samba
ACCEPTABLE_LICENSES+= adobe-flashsupport-license
ACCEPTABLE_LICENSES+= adobe-acrobat-license
ACCEPTABLE_LICENSES+= lame-license
ACCEPTABLE_LICENSES+= generic-nonlicense
ACCEPTABLE_LICENSES+= eclipse-license
ACCEPTABLE_LICENSES+= sun-jdk6-license
ACCEPTABLE_LICENSES+= sun-jre6-license
ACCEPTABLE_LICENSES+=oracle-binary-code-license
ACCEPTABLE_LICENSES+=gnu-agpl-v3

.endif			# end pkgsrc settings by $myname
_EOF_
  fi
fi

##
# Phase 3 - Install required packages
##
PATH=$prefix/bin:$prefix/sbin:$PATH
succ=""
not=""
skip=""
fail=""
logfile=$work/${myname}-build.log
rcode=$work/${myname}-rcode.$$
[ -d $work ] || mkdir $work
: > $logfile
report() {
  echo Build log is recorded in "[$logfile]".
  echo Result of trying bmake install of packages:
  echo " [[$pkgs]]"
  cat<<_EOF_
Success:	$succ
Failed:		$fail
Not found:	$not
Skipped:	$skip
_EOF_
}
cease() {
  rc=$?
  echo "BREAK!!!!" 1>&2
  report
  echo "Interrupted:	$pkg" 1>&2
  rm -f $rcode
  exit $rc
}
trap cease INT TERM HUP

# MAKE_JOBS > 2 sometimes causes build failure
# So we need to down it to $MK_JOBS at run time
mj=${ARG_J:+"MAKE_JOBS=$ARG_J "}

nFail=0
for pkg in $pkgs; do
  case "$pkg" in
    */*|*/*/*)
      ;;
    *)
      npkg=`echo */$pkg`
      case "$npkg" in
        \**)	echo $pkg not found 1>&2; not="$not${not:+ }$pkg"; continue ;;
	*\ *)	echo $pkg ambiguous 1>&2
		skip="$skip${skip:+ }$pkg($npkg)"
		continue ;;
      esac
      pkg=$npkg
  esac
  case "$pkg" in
    *:[ab]*) 		tgt=all ;;		# "all" or "build"
    *:co*|*:c) 		tgt=configure ;;
    *:cd*) 		tgt=clean-depends ;;
    *:cl|*:clean)	tgt=clean ;;
    *:cd)		tgt=clean-depends ;;
    *:dc*) 		tgt=distclean ;;
    *:de*) 		tgt=deinstall ;;
    *:ex*|*:x) 		tgt=extract ;;
    *:fe*) 		tgt=fetch ;;
    *:in*) 		tgt=install ;;
    *:up*) 		tgt=update ;;
    *:pa*) 		tgt=patch ;;
    *:rei*|*:ri) 	tgt=reinstall ;;
    *:rep*)		tgt=replace ;;
    *:show-d*|*:sd*)	tgt=show-depends ;;
    *:show-o*|*:so*)	tgt=show-options ;;
    *:*) 		tgt=`expr x"$pkg" : x".*:\(.*\)"`;;
    *)			if [ -n "$cleandepends" ]; then
			  tgt="install clean clean-depends"
			else
			  tgt="install clean"
			fi
			;;
  esac
  pname=${pkg%%:*}
  pbase=${pname##*/}
  if $prefix/sbin/pkg_info -qE "$pbase"; then
    if [ x"${tgt%% *}" = x"install" ]; then
      echo "Skipping already installed package [$pname]"
      skip="$skip${skip:+ }$pkg"
      continue
    elif [ -n "$replup" -o "$tgt" = "replace" -o "$tgt" = "update" ]; then
      echo "### Replacing existent package [$pname]"
      tgt=replace
    else
      echo "### Do '$tgt' for package [$pname]"
    fi
  fi
  { echo ":::> Entering target of $mj$pname [$tgt]"
    (cd $pname && bmake $mj$tgt 2>&1; echo $? > $rcode )
    echo ":::< Finished target of $pname [$tgt]"
  }  | tee -a $logfile
  r=`cat $rcode`; rm -f "$rcode"
  if [ "$r" -eq 0 ]; then
    succ=$succ${succ:+ }$pkg
  else
    fail=$fail${fail:+ }$pkg
    nFail=$((nFail+1))
  fi
done
report
exit $nFail