#!/bin/bash

.   driglibash-base
.   creation_repo.sh &> /dev/null
#prerequisite: creation_repo.sh has been run
FILES_TO_KEEP='sample0'
REMOTE="./remote/performance_testing"
Help()
{
   echo "
NAME
    performance_tests.sh 
SYNOPSIS
    performance_tests.sh [-h] [-a] [-n number] [SSH LINK to en empty remote git repository] OPTIONS
    -a excutes all the tests.
    -n [number] executes test [number]
    -h prints the help. 
DESCRIPTION
    This script is in writing. It allows you to measure memory and bandwidth usage for different method of cloning on the remote repository given.
    TEST0: classic cloning 
    TEST1: --single-branch "
}

#TESTS ON THE INITIAL CLONING
test0(){
    section TEST0
    echo "TEST 0 : case of classic cloning."
    git clone --progress --no-local $1 2> cloning_text
    mem0=$(du ./$REPO_NAME | tail -n1 | tr -cd [:digit:])
    bw0=$(grep -e "Receiving objects:" cloning_text| grep -o "[[:digit:].]* MiB " | tail -n1)
    echo "memory usage in a classic cloning : $mem0"
    echo "bandwidth usage : $bw0"    
    run rm cloning_text
    run rm -rf $REPO_NAME
}

test1(){
    section TEST1
    echo "TEST 1 : case of --single-branch cloning."
    git clone --progress --single-branch --no-local $1 2> cloning_text
    mem1=$(du ./$REPO_NAME| tail -n1 | tr -cd [:digit:])
    bw1=$(grep -e "Receiving objects:" cloning_text| grep -o "[[:digit:].]* MiB " | tail -n1)
    echo "memory usage in a --single-branch cloning : $mem1"
    echo "bandwidth usage : $bw1"
    run rm cloning_text
    run rm -rf $REPO_NAME
}

test2(){
    section TEST2
    echo "TEST 2 : case of --depth=1 --no-single-branch"
    git clone --progress --depth=1 --no-local --no-single-branch $1 2> cloning_text
    mem2=$(du ./$REPO_NAME| tail -n1 | tr -cd [:digit:])
    bw2=$(grep -e "Receiving objects:" cloning_text| grep -o "[[:digit:].]* MiB " | tail -n1)
    echo "memory usage in a --depth=1 --no-single-branch cloning : $mem2"
    echo "bandwidth usage : $bw2"
    run rm cloning_text
    run rm -rf $REPO_NAME
}

test3(){
    section TEST3
    echo "TEST 3 : case of --depth=1 with single-branch (default))"
    git clone --progress --single-branch --no-local --depth=1 $1 2> cloning_text
    mem3=$(du ./$REPO_NAME| tail -n1 | tr -cd [:digit:])
    bw3=$(grep -e "Receiving objects:" cloning_text| grep -o "[[:digit:].]* MiB " | tail -n1)
    echo "memory usage in a --depth=1 with single-branch cloning : $mem3"
    echo "bandwidth usage : $bw3"
    run rm cloning_text
    run rm -rf $REPO_NAME
}

test4(){
    section TEST4
    run mkdir $REPO_NAME
    run echo 'TEST 4 : case of sparse-checking only some files with depth=1'
    run cd $REPO_NAME
    run git init -q
    run git config core.sparsecheckout true 
    run echo $FILES_TO_KEEP >> .git/info/sparse-checkout 
    run git remote add -f origin file://$1 #&> /dev/null
    run git pull origin main #&> /dev/null
    mem4=$(du . | tail -n1 | tr -cd [:digit:])
    echo "memory usage with sparse checking only $FILES_TO_KEEP : $mem4"
    echo "The bandwidth usage is not available through the Git commands."
    run rm cloning_text
    run rm -rf $REPO_NAME
}

#TESTS ON THE UPDATING OF THE REPOSITORY
#WITHOUT CHANGING ANYTHING
test5(){
    section TEST5
    run echo 'TEST 5 : case of classic fetching and merging'
    run git clone $1 &> /dev/null
    cd $REPO_NAME
    run git fetch -v origin &> fetching_text
    run git merge -v &> merging_text
    mem5before=$(du . | tail -n1 | tr -cd [:digit:]) 
    #modification of the remote repo  
    cd $REMOTE
    run dd if=/dev/urandom of=sample5 bs=1M count=1  #adding a 1M file
    run git add sample5
    run git commit -m"fourth 1M sample created"
    cd -
    run git fetch -v origin &> fetching_text
    run git merge -v &> merging_text
    mem5after=$(du . | tail -n1 | tr -cd [:digit:]) 
    mem5=$(($mem5after-$mem5before))
    echo "memory usage in a classic fetching and merging : $mem5"
    #echo "bandwidth usage : $bw5"
}

#test 6 : shallow exclude

while getopts ":hn:a" option; do
   case $option in
      h) # display Help
         Help
         exit;;
      n) 
            TEST_NUM=$OPTARG;;
      a) 
            ALL_TESTS=true;; 
     \?) # Invalid option
         echo "Error: Invalid option here"
         exit;;
   esac
done

if [ "$ALL_TESTS" = true ]; then
    test0 $REMOTE
    test1 $REMOTE
    test2 $REMOTE
    test3 $REMOTE
    test4 $REMOTE
    test5 $REMOTE

elif [ -n "$TEST_NUM" ]; then
    case $TEST_NUM in
        0) 
            test0 $REMOTE;;
        1)
            test1 $REMOTE;;
        2) 
            test2 $REMOTE;;
        3) 
            test3 $REMOTE;;
        4) 
            test4 $REMOTE;;
        5) 
            test5 $REMOTE;;
        *)
            echo "Error: Invalid test number"
            die;;
    esac
else
    Help
fi

#optimize in case all tests are run