#!/bin/bash

# Library of bash functions use by test/*.sh
# The scripts begin "source functions.source"
# Don't detab this file! removeTest() addModTest() need them!

##
# run a test
runTest()
{
    local prog=$1
    shift
    (
        mkdir -p $here/tmp
        cd       $here/tmp
        if [ ! -z $EXIV2_ECHO ]; then
            echoTest $VALGRIND $bin$prog$exe "$@"
        fi
        $VALGRIND $bin$prog$exe "$@"
    )
}

##
# echo commands and arguments
echoTest()
{
    local count=1
    for i in $@ ; do
        echo $((count++)):  $i
    done
    echo -----------------------
}

##
# predictate
existsTest()
{
    local prog=$1
    result=0
    if [ -z "$bin" ]; then
        if [ ! -z $(which $prog) ]; then
            result=1
        fi
    else
        if [ -e $bin$prog -o -e $bin$prog$exe ]; then
            result=1
        fi
    fi
    echo $result
}

##
# copy file (used by conversions.sh)
copy()
{
    \cp "$1" "$2"
}

##
# copy file from data to tmp (copyTestFile from to)
copyTestFile()
{
    if [ $# == 2 ]; then
        cp -f "$here/data/$1" "$here/tmp/$2"
    elif [ $# == 1 ]; then
        stub=$(basename $1)
        cp -f "$here/data/$1" "$here/tmp/$stub"
    else
        echo "*** error copyTestFile: illegal number of inputs = $# ***"
    fi

}

##
# copy 1 or more files from data to tmp
copyTestFiles()
{
    for i in "$@" ; do
        copyTestFile "$i" "$i"
    done
}

##
# result analysis
reportTest()
{
    cat $results | tr '\\' '/' > ${results}-new
    mv -f ${results}-new $results

    if [ $# -eq 0 ]; then
        lhs=$results
        rhs=$good
    else
        if [ $# -eq 3 ] ; then
            diffargs=$1
            lhs=$2
            rhs=$3
        else
            lhs=$1
            rhs=$2
        fi
    fi

    diff $diffargs $lhs $rhs
    rc=$?
    if [ $rc -eq 0 ] ; then
        echo "all testcases passed."
    fi
}

##
# moved here from write-test.sh
# Function:
#     runTestCase number file
# Params:
#     number: Test case number
#     file  : Input file
# Abstract:
# Run the requested test case number with the given file
runTestCase()
{
    rtc_number=$1
    rtc_infile=$2

    rtc_outfile=test${rtc_number}.jpg
    rtc_jpgthumb=thumb${rtc_number}.jpg
    rtc_tifthumb=thumb${rtc_number}.tif

    rm -f $rtc_outfile $rtc_jpgthumb $rtc_tifthumb
    rm -f iii ttt;

    echo "------------------------------------------------------------"
    runTest exifprint $rtc_infile > iii;
    cp $rtc_infile $rtc_outfile;
    runTest write-test $rtc_infile $rtc_number > ttt;
    diff $diffargs iii ttt
}

##
# moved here from imagetest.sh
eraseTest()
{
    src=$1
    test=${src}.etst
    good=$datapath/${src}.egd

    #setup
    cp $datapath/$src $test

    #run tests
    ${bin}metacopy $test $test

    #check results
    diffCheck $test $good
    printf "."
}

copyTest()
{
    num=$1    # case number
    src=$2    # input file
    dst=$3    # copy to hear
    test=${dst}.c${num}tst
    good=$datapath/${dst}.c${num}gd

    #setup
    cp $datapath/$dst $test

    #run tests
    ${bin}metacopy -a $datapath/$src $test

    #check results
    diffCheck $test $good
    printf "."
}

iptcTest()
{
    num=$1    # case number
    src=$2    # input file
    dst=$3    # copy to hear
    test=${dst}.i${num}tst
    good=$datapath/${dst}.i${num}gd

    #setup
    cp $datapath/$dst $test

    #run tests
    runTest metacopy -ip $datapath/$src $test

    #check results
    diffCheck $test $good
    printf "."
}

##
# Make sure to pass the test file first and the known good file second
diffCheck()
{
    test=$(real_path $1)
    good=$(real_path $2)
    if [ -z "$errors" ]; then let -a errors=0; fi

    #run diff and check results
    if [ $PLATFORM == SunOS ]; then
        bdiff $diffargs "$test" "$good"
    elif [ $PLATFORM == FreeBSD -o $PLATFORM == NetBSD ]; then
        diff $diffargs "$test" "$good"
    else
        diff --binary $diffargs "$test" "$good"
    fi
    if [ $? -ne 0 ]; then
       errors=$(expr $errors + 1)
    else
       rm $test
    fi
}

##
# moved here from iotest.sh
ioTest()
{
    src=$datapath/$1
    out1=${1}.1
    out2=${1}.2

    #run tests
    runTest iotest $src $out1 $out2
    if [ $? -ne 0 ]; then
       errors=`expr $errors + 1`
       return
    fi

    #check results
    diffCheck $out1 $src
    diffCheck $out2 $src
    printf "."
}

##
# moved here from iptctest.sh
printTest()
{
    src=$1
    test=${src}.iptst
    good=$datapath/${src}.ipgd

    #run tests
    runTest iptcprint $datapath/$src > $test

    #check results
    diffCheck $test $good
    printf "."
}

removeTest()
{
    src=$1
    tmp="temp"
    test=${src}.irtst
    good=$datapath/${src}.irgd

    #setup
    cp $datapath/$src $tmp

    #run tests
    runTest iptctest $tmp <<-eoc
		r Iptc.Application2.Byline
		r Iptc.Application2.Caption
		r Iptc.Application2.Keywords
		r Iptc.Application2.Keywords
		r Iptc.Application2.Keywords
		r Iptc.Application2.CountryName
eoc
    runTest iptcprint $tmp > $test

    #check results
    diffCheck $test $good
    printf "."
    rm $tmp
}

addModTest()
{
    src=$1
    tmp="temp"
    test=${src}.iatst
    good=$datapath/${src}.iagd

    #setup
    cp $datapath/$src $tmp

    #run tests
    runTest iptctest $tmp <<-eoc
		a Iptc.Application2.Headline		  The headline I am
		a Iptc.Application2.Keywords		  Yet another keyword
		m Iptc.Application2.DateCreated		  2004-8-3
		a Iptc.Application2.Urgency			  3
		m Iptc.Application2.SuppCategory	  "bla bla ba"
		a Iptc.Envelope.ModelVersion		  2
		a Iptc.Envelope.TimeSent			  14:41:0-05:00
		a Iptc.Application2.RasterizedCaption 230 42 34 2 90 84 23 146
eoc
    runTest iptcprint $tmp > $test

    #check results
    diffCheck $test $good
    printf "."
    rm $tmp
}

extendedTest()
{
    src=$1
    tmp="temp"
    test=${src}.ixtst
    good=$datapath/${src}.ixgd

    #setup
    cp $datapath/$src $tmp

    #run tests
    runTest iptctest $tmp < $datapath/ext.dat
    runTest iptcprint $tmp > $test

    #check results
    diffCheck $test $good
    printf "."
    rm $tmp
}

##
#
hardLinkFiles()
{
    target="$1"
    shift
    for var; do
        if [ -e $var ]; then rm -rf $var ; fi
        ln $target $var
    done
}

##
# real_path - report the absolute path to a file
real_path ()
{
    if [ "$PLATFORM" == "Darwin" -o "$PLATFORM" == "mingw" ]; then
        if [ -d "$1" ]; then
            cd "$1"
            echo $PWD
        else
            cd $(dirname $1)
            echo "$PWD"/$(basename "$1")
        fi
    else
        which realpath 2>/dev/null >/dev/null
        if [ $? == 0 ]; then
            realpath "$1"
        else
            readlink -f "$1"
        fi
    fi
}

##
# print checksum for one file
checkSum()
{
    if [ "$PLATFORM" == 'NetBSD' -o "$PLATFORM" == 'FreeBSD' -o "$PLATFORM" == 'Darwin' ]; then
        md5 -q $1
    else
        md5sum $1 | cut -d' ' -f 1
    fi
}

##
# startHttpServer - power up the python web server
startHttpServer() {
    cd "${testdir}/.."                   # testdir is the tmp output directory
    
    if    [ "$platform" == "cygwin" ]; then dport=12762
    elif  [ "$platform" == "mingw"  ]; then dport=12761
    else                                    dport=12760
    fi

    if [ ! -z $EXIV2_PORT ]; then port=$EXIV2_PORT ; else port=$dport          ; fi
    if [ ! -z $EXIV2_HTTP ]; then http=$EXIV2_HTTP ; else http=http://localhost; fi
    exiv2_url=$http:$port
    python3 -m http.server $port &       # start a background local HTTP server in the "real" test directory
    sleep 2                              # wait for it to init or die!
    exiv2_httpServer=$!
    # ask the server to reply
    echo $exiv2_url status = $(python3 -c "import urllib.request;print(urllib.request.urlopen('$exiv2_url/').status)")
}

##
# closeHttpServer - power down the python web server
closeHttpServer() {
    if [ ! -z $exiv2_httpServer ]; then
        echo kill  exiv2_httpServer $exiv2_httpServer
             kill $exiv2_httpServer      # kill the server
    fi 
}

##
# prepare tmp directory and variables
prepareTest()
{
    ##
    # locale and timezone setting
    export LC_ALL=C
    export TZ=BST-1

    os=$(uname)
    export PLATFORM=$os
    if [ $os != FreeBSD -a $os != NetBSD -a $os != SunOS -a $os != Darwin -a $os != Linux ]; then
        os=$(uname -o)
        if [ $os == Cygwin ]; then
            PLATFORM=cygwin
        elif [ os == Msys ]; then
            PLATFORM=mingw
        fi
    fi

    if [ "$PLATFORM" == cygwin -o "$PLATFORM" == mingw ]; then
        exe=.exe
    fi
    
    if [ ! -z $EXIV2_EXT ]; then
        exe=$EXIV2_EXT
    fi

    ##
    # initialize globals
    this=$(basename $0 .sh)
    here=$PWD
    datapath="../data"
    testdir="$here/tmp"
    datadir="../data"

    if [ -z "$EXIV2_BINDIR" ] ; then
        bin="$here/../build/bin/"
    else
        bin="$EXIV2_BINDIR/"
    fi
    
    # update PATHs to ensure we load the the correct dynamlic library
    if [ $PLATFORM == 'mingw' -a $PLATFORM == 'cygwin' ]; then
        export PATH="$bin:$PATH"
    elif [ 'PLATFORM' == 'Darwin' ]; then
        export DYLD_LIBRARY_PATH="$bin/../lib:$DYLD_LIBRARY_PATH"
    else
        export LD_LIBRARY_PATH="$bin/../lib:$LD_LIBRARY_PATH"
    fi

    ##
    # figure out arguments for diff
    good="$here/data/${this}.out"
    results="$here/tmp/${this}.out"
    mkdir -p $here/tmp
    tmpfile=$here/tmp/$this
    echo '' >> $tmpfile

    if [ "$PLATFORM" == SunOS -o "$PLATFORM" == FreeBSD -o "$PLATFORM" == NetBSD ] ; then
        da1=""
        da2=""
    else
        diffargs="--strip-trailing-cr"
        diff -q $diffargs $tmpfile $tmpfile 2>/dev/null
        if [ $? -ne 0 ]; then
            diffargs=""
        fi

        tmpfile=tmp/ttt
        echo '' >> $tmpfile
        da1="--strip-trailing-cr"
        diff -q $da1 $tmpfile $tmpfile 2>/dev/null
        if [ $? -ne 0 ] ; then
            da1=""
        fi
        da2="--ignore-matching-lines=^Usage:.*exiv2"
        diff -q $da2 $tmpfile $tmpfile 2>/dev/null
    fi
    diffargs="$da1 $da2"

    ##
    # test that exiv2 and some sample apps are in the bin!
    for e in exiv2 exifprint easyaccess-test metacopy ; do
        e="${bin}${e}${exe}"
        if [ ! -e "$e" ]; then
            echo '******************************************'
            echo '***' $(real_path "$e") does not exist
            echo '******************************************'
            exit 42
        fi
    done

    # set platform for msvc builds
    platform=$PLATFORM
    if [ $PLATFORM == mingw -o $PLATFORM == cygwin ]; then
        platform=$(runTest exiv2 -vV 2>/dev/null | grep platform=)
        if [ "$platform" == "platform=windows" ]; then
            platform="windows"
        fi
    fi
}

prepareTest

# That's all Folks!
##