# The Evaluator -- Shell Function Library
# (c) 2001 Martin Mares <mj@ucw.cz>

# Logging functions.
# File handles used: fd1=log, fd2=progress

function log-init
{
	exec >>$TDIR/log
	HAVE_LOG=1
}

function pstart
{
	echo >&2 -n "$@"
}

function pcont
{
	echo >&2 -n "$@"
}

function pend
{
	echo >&2 "$@"
}

function die
{
	echo >&2 "$@"
	[ -n "$HAVE_LOG" ] && echo "Fatal error: $@"
	exit 1
}

# Sandbox subroutines

function box-init
{
	pstart "Preparing sandbox... "
	[ -n "$TEST_USER" ] || die "TEST_USER not set. Please fix."
	if [ $TEST_USER == $EVAL_USER ] ; then
		pcont "running locally (INSECURE), "
		BOXDIR=box
		BOXCMD=bin/box
		mkdir -p box
	else
		pcont "used account $TEST_USER, "
		BOXDIR=$MO_ROOT/$TEST_USER
		BOXCMD=bin/box-$TEST_USER
	fi
	[ -d $BOXDIR -a -f $BOXCMD ] || die "Sandbox set up incorrectly"
	BOXCMD="$BOXCMD -c$BOXDIR"
	echo "Sandbox directory: $BOXDIR"
	echo "Sandbox command: $BOXCMD"
	box-clean
	pend "OK"
}

function box-clean
{
	[ -n "$BOXCMD" ] || die "box-init not called"
	rm -rf $BOXDIR/*
}

# Initialization of testing directories

function dir-init
{
	pstart "Initializing... "
	PDIR=problems/$PROBLEM
	SDIR=solutions/$CONTESTANT/$PROBLEM
	TDIR=testing/$CONTESTANT/$PROBLEM
	[ -d $PDIR ] || die "Problem $PROBLEM not known"
	[ -d $SDIR ] || die "Solution of $PROBLEM not found"
	mkdir -p $TDIR
	rm -rf $TDIR
	cp -a $SDIR $TDIR
	cat >$TDIR/log <<EOF
Testing solution of $PROBLEM by $CONTESTANT
Test started at `date`
Contestant's solution directory: $SDIR
Problem directory: $PDIR
Testing directory: $TDIR
EOF
	>$TDIR/points
	pend "OK"
}

# Locating source file in SDIR, pass name in SRCN (without path) and extension in SRCEXT

function locate-source
{
	pstart "Locating source... "
	for a in $EXTENSIONS ; do
		if [ -f $SDIR/$PROBLEM.$a ] ; then
			[ -z "$SRCN" ] || die "Multiple source files found: $SDIR/$PROBLEM.$a and $SDIR/$SRCN. Please fix."
			SRCN=$PROBLEM.$a
			SRCEXT=$a
		fi
	done
	[ -n "$SRCN" ] || die "NOT FOUND"
	pend $SRCN
	echo "Found source file: $SDIR/$SRCN"
}

# Compilation (compile SDIR/SRCN with PDIR/EXTRAS to EXE=TDIR/PROBLEM)

function compile
{
	pstart "Compiling... "
	cp -a $SDIR/$SRCN $TDIR/$SRCN
	if [ -n "$EXTRAS" ] ; then
		echo "Extras: $EXTRAS"
		for a in $EXTRAS ; do cp $PDIR/$a $TDIR/ ; done
	fi
	box-clean
	for a in $SRCN $EXTRAS ; do cp $TDIR/$a $BOXDIR/ ; done
	SRC=$SRCN
	EXE=$PROBLEM
	CCMD=COMP_$SRCEXT
	CCMD="`eval echo ${!CCMD}`"
	COMP_SANDBOX_OPTS="`eval echo $COMP_SANDBOX_OPTS`"
	echo "Compiler command: $CCMD"
	echo "Compiler sandbox options: $COMP_SANDBOX_OPTS"

	echo "Compiler input files:"
	ls -Al $BOXDIR
	if ! $BOXCMD $COMP_SANDBOX_OPTS -- $CCMD 2>$TDIR/compile.out ; then
		COMPILE_MSG="`cat $TDIR/compile.out`"
		pend "FAILED: $COMPILE_MSG"
		echo "$COMPILE_MSG"
		return 1
	fi
	cat $TDIR/compile.out
	rm $TDIR/compile.out
	echo "Compiler output files:"
	ls -Al $BOXDIR
	if [ ! -f $BOXDIR/$PROBLEM ] ; then
		pend "FAILED: Missing executable file"
		echo "Missing executable file"
		return 1
	fi
	EXE=$TDIR/$PROBLEM
	cp -a $BOXDIR/$PROBLEM $EXE
	echo "Compiled OK, result copied to $EXE"
	pend "OK"
}

# Running of test program with file input/output

function test-run-with-files
{
	pcont "<init> "
	box-clean
	echo "Executable file: $TDIR/$PROBLEM"
	cp $TDIR/$PROBLEM $BOXDIR/
	echo "Input: $TDIR/$PROBLEM"
	cp $PDIR/$TEST.in $BOXDIR/$PROBLEM.in
	echo "Input files:"
	ls -Al $BOXDIR

	pcont "<run> "
	echo "Timeout: $TIME_LIMIT s"
	echo "Memory: $MEM_LIMIT KB"
	BOXOPTS="`eval echo $TEST_SANDBOX_OPTS`"
	echo "Sandbox options: $BOXOPTS"
	if ! $BOXCMD $BOXOPTS -- ./$PROBLEM 2>$TDIR/exec.out ; then
		TEST_MSG="`cat $TDIR/exec.out`"
		pend "$TEST_MSG"
		echo "$TEST_MSG"
		echo >$PTSFILE "0 $TEST_MSG"
		return 1
	fi
	cat $TDIR/exec.out
	rm $TDIR/exec.out
	echo "Output files:"
	ls -Al $BOXDIR
	if [ ! -s $BOXDIR/$PROBLEM.out ] ; then
		pend "No output file."
		echo "No output file."
		echo >$PTSFILE "0 No output."
		return 1
	fi
	cp $BOXDIR/$PROBLEM.out $TDIR/$TEST.out
}

# Syntax checks

function syntax-check
{
	[ -n "$SYNTAX_CHECK" ] || return 0
	pcont "<syntax> "
	SCHECK="`eval echo $SYNTAX_CHECK`"
	echo "Syntax check command: $SCHECK"
	$SCHECK && return 0
	pend "Wrong syntax."
	echo "Wrong syntax."
	echo >$PTSFILE "0 Wrong syntax."
	return 1
}

# Output checks

function output-check
{
	pcont "<check> "
	ln $PDIR/$TEST.out $TDIR/$TEST.ok
	OCHECK="`eval echo $OUTPUT_CHECK`"
	echo "Output check command: $OCHECK"
	$OCHECK && return 0
	pend "Wrong answer."
	echo "Wrong answer."
	echo >$PTSFILE "0 Wrong answer."
	return 1
}