#!/bin/bash
.   driglibash-base

REPO_NAME=performance_testing
REPO_PATH=./remote
WITH_SUBMODULE="true"
SUB_NAME="submodule_for_performance_testing"
FILES_TO_KEEP='sample0'
REMOTE="./remote/performance_testing"

if [ "$WITH_SUBMODULE" = "true" ]; then
    bash creation_repo.sh -s &> /dev/null
else 
    bash creation_repo.sh &> /dev/null
fi

Help()
{
   echo "
NAME
    performance_tests.sh
SYNOPSIS
    performance_tests.sh [-a] [-h] [-n number]
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. The first four test different cloning methods. Te following apply changes to the local remote before testing fetching and merging commands.
    TEST0: classic cloning 
    TEST1: --single-branch cloning
    TEST2: --depth=1 --no-single-branch cloning
    TEST3: --depth=1 cloning
    TEST4: sparse-checking 1M sample0 only cloning
    _________________
    TEST5: classic fetching and merging after addition of a 1M file
    TEST6: classic fetching and merging, after removal of a 1M file
    TEST7: classic fetching and merging, after addition then removal of a 1M file
    TEST8: --depth=1 fetching and merging, after addition of a 1M file
    TEST9: --depth=1 fetching and merging, after removal of a 1M file
    TEST10: --depth=1 fetching and merging, after addition then removal of 1M a file"
}

#USEFUL FUNCTIONS FOR THE TESTS
create_random_file(){
    run dd if=/dev/urandom of=$1 bs=$2 count=1 &> /dev/null
}

get_storage_used(){
    mem=$(du $1 | tail -n1 | tr -cd [:digit:])
}

get_bandwidth(){
    bw="unknown"
    bw=$(grep -e "Receiving objects:" $1 | grep -o "Receiving objects: [[:alnum:]%/(),. ]*" | tail -n1)
    bw=${bw#*,}
}

#TESTS ON THE INITIAL POPULATING OF THE REPO
test0(){
    section TEST0
    echo "TEST 0 : case of classic cloning."
    git clone --recurse-submodules --progress --no-local $1 &> cloning_text
    cd $REPO_NAME
    run git submodule update --init --recursive --force --remote --progress &> /dev/null
    cd ..
    get_storage_used "./$REPO_NAME" 
    get_bandwidth cloning_text
    echo "memory usage in a classic cloning : $mem"
    echo "bandwidth usage : $bw"    
    run rm cloning_text
    run rm -rf $REPO_NAME 
}

test1(){
    section TEST1
    echo "TEST 1 : case of --single-branch cloning."
    git clone --recurse-submodules --progress --single-branch --no-local $1 &> cloning_text
    cd $REPO_NAME
    run git submodule update --init --recursive --force --remote --progress &> /dev/null
    cd ..
    get_storage_used ./$REPO_NAME
    get_bandwidth cloning_text
    echo "memory usage in a --single-branch cloning : $mem"
    echo "bandwidth usage : $bw"
    run rm cloning_text
    run rm -rf $REPO_NAME
}

test2(){
    section TEST2
    echo "TEST 2 : case of --depth=1 --no-single-branch"
    git clone --recurse-submodules --progress --depth=1 --no-local --no-single-branch $1 &> cloning_text
    cd $REPO_NAME
    run git submodule update --init --recursive --force --remote --progress --depth=1 --no-single-branch &> /dev/null
    cd ..
    get_storage_used ./$REPO_NAME
    get_bandwidth cloning_text
    echo "memory usage in a --depth=1 --no-single-branch cloning : $mem"
    echo "bandwidth usage : $bw"
    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 --recurse-submodules --recurse-submodules --progress --single-branch --no-local --depth=1 $1 &> cloning_text
    cd $REPO_NAME
    run git submodule update --init --recursive --force --remote --progress --depth=1 &> /dev/null
    cd ..
    get_storage_used ./$REPO_NAME
    get_bandwidth cloning_text
    echo "memory usage in a --depth=1 with single-branch cloning : $mem"
    echo "bandwidth usage : $bw"
    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 $FILES_TO_KEEP with depth=1"
    #creating a git repo with sparse-checking settings
    run cd $REPO_NAME
    run git init -q
    run git config core.sparsecheckout true 
    run echo $FILES_TO_KEEP >> .git/info/sparse-checkout 
    #pulling from the remote with sparse-checking enabled
    run git remote add -f origin ../$1 &> /dev/null
    run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
    run git fetch --progress --tags --depth=1 origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    echo "memory usage: $mem"
    echo "bandwidth usage : unknown"
    cd ..
    run rm -rf $REPO_NAME
}


#TESTS ON THE UPDATING OF THE REPOSITORY
test5(){
    section TEST5
    run echo 'TEST 5 : case of classic fetching and merging, after addition of a 1M file'
    #initialization
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
    cd $REPO_NAME
    #run git submodule update --init --recursive --force --depth=1
    get_storage_used . 
    mem_before=$mem
    #modification of the remote repo  
    cd ../$REMOTE
    create_random_file 'sample5' '1M' #adding a 1M file
    run git add sample5 
    run git commit --quiet -m"fourth 1M sample created"
    cd ../../$REPO_NAME
    #fetching
    run git submodule update --init --recursive --force --remote &> /dev/null
    run git fetch --progress --tags origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    mem_after=$mem
    mem=$(($mem_after-$mem_before))
    echo "memory usage: +$mem"
    cd ../$REMOTE
    git reset --hard -q HEAD~1
    cd ../..
    rm -rf performance_testing
}

test6(){
    section TEST6
    run echo 'TEST 6 : case of classic fetching and merging, after removal of a 1M file'
    #initialization
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
    cd $REPO_NAME
    get_storage_used .
    mem_before=$mem
    #modification of the remote repo  
    cd ../$REMOTE
    run rm sample0
    run git add sample0 
    run git commit --quiet -m"1M sample0 deleted"
    cd ../../$REPO_NAME
    #fetching
    run git submodule update --init --recursive --force --remote &> /dev/null
    run git fetch --progress --tags origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    mem_after=$mem
    mem=$(($mem_after-$mem_before))
    echo "memory usage: $mem"
    cd ../$REMOTE
    git reset --hard -q HEAD~1
    git clean -df
    cd ../..
    rm -rf performance_testing
}

test7(){
    section TEST7
    run echo 'TEST 7 : case of classic fetching and merging, after addition then removal of a 1M file'
    #initialization
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
    cd $REPO_NAME
    get_storage_used .
    mem_before=$mem 
    #modification of the remote repo  
    cd ../$REMOTE
    create_random_file 'sample5' '1M' #adding a 1M file
    run git add sample5 
    run git commit --quiet -m"fourth 1M sample created"
    run rm sample5
    run git add sample5
    run git commit --quiet -m"1M "sample5" deleted"
    cd ../../$REPO_NAME
    #fetching
    run git submodule update --init --recursive --force --remote &> /dev/null
    run git fetch --progress --tags origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    mem_after=$mem
    mem=$(($mem_after-$mem_before))
    echo "memory usage: $mem"
    cd ../$REMOTE
    git reset --hard -q HEAD~2
    cd ../..
    rm -rf performance_testing
}

test8(){
    section TEST8
    run echo 'TEST 8 : case of fetching --depth=1 and merging, after addition of a 1M file'
    #initialization
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
    cd $REPO_NAME
    echo "un truc écrit en plus" >> untexte
    get_storage_used .
    mem_before=$mem
    #modification of the remote repo  
    cd ../$REMOTE
    create_random_file 'sample5' '1M' #adding a 1M file
    run git add sample5 
    run git commit --quiet -m"fourth 1M sample created"
    cd ../../$REPO_NAME
    run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
    run git fetch --progress --tags --depth=1 origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    mem_after=$mem
    mem=$(($mem_after-$mem_before))
    echo "memory usage: +$mem"
    cd ../$REMOTE
    git reset --hard -q HEAD~1 
    cd ../..
    rm -rf performance_testing
}

test9(){
    section TEST9
    run echo 'TEST 9 : case of --depth=1 fetching and merging, after removal of a 1M file'
    #initialization 
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
    cd $REPO_NAME
    get_storage_used .
    mem_before=$mem
    #modification of the remote repo  
    cd ../$REMOTE
    run rm sample0
    run git add sample0 
    run git commit --quiet -m"1M sample0 deleted"
    cd ../../$REPO_NAME
    #fetching
    run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
    run git fetch --progress --tags --depth=1 origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    mem_after=$mem
    mem=$(($mem_after-$mem_before))
    echo "memory usage: $mem"
    cd ../$REMOTE
    git reset --hard -q HEAD~1
    cd ../..
    rm -rf performance_testing
}

test10(){
    section TEST10
    run echo 'TEST 10 : case of --depth=1 fetching and merging, after addition then removal of a 1M file'
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
    cd $REPO_NAME
    get_storage_used .
    mem_before=$mem
    #modification of the remote repo  
    cd ../$REMOTE
    create_random_file 'sample5' '1M' #adding a 1M file
    run git add sample5 
    run git commit --quiet -m"fourth 1M sample created"
    run rm sample5
    run git add sample5
    run git commit --quiet -m"1M "sample5" deleted"
    cd ../../$REPO_NAME
    #fetching
    run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
    run git fetch --progress --tags --depth=1 origin &> /dev/null
    git checkout -f origin/main &> /dev/null
    get_storage_used .
    mem_after=$mem
    mem=$(($mem_after-$mem_before))
    echo "memory usage: $mem"
    cd ../$REMOTE
    git reset --hard -q HEAD~2
    cd ../..
    rm -rf performance_testing
}

test11(){
    section TEST11
    run echo 'TEST 11 : case of --depth=1 fetching and merging, after addition of a 1M file in submodule'
    if [ "$WITH_SUBMODULE" = "true" ]; then
    git clone --recurse-submodules --progress --no-local $1 &> /dev/null
        cd $REPO_NAME
        get_storage_used .
        mem_before=$mem
        #modification of the remote submodule  
        cd ..
        cd $REPO_PATH/$SUB_NAME
        create_random_file 'sub_sample1' '1M'
        git add sub_sample1
        git commit --quiet -m"second 1M sample created"
        cd ../../$REPO_NAME
        #fetching
        run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
        run git fetch --progress --tags --depth=1 origin &> /dev/null
        git checkout -f origin/main &> /dev/null
        get_storage_used .
        mem_after=$mem
        mem=$(($mem_after-$mem_before))
        echo "memory usage: $mem"
        cd ../$REPO_PATH/$SUB_NAME
        git reset --hard -q HEAD~1
        cd ../..
        rm -rf performance_testing
    else 
        echo "This test will not be performed because we are in no-submodule mode. Change boolean \$WITH_SUBMODULE to switch."
    fi
}

test12(){
    section TEST12
    run echo 'TEST 12 : case of --depth=1 fetching and merging, after removal of a 1M file in submodule'
    if [ "$WITH_SUBMODULE" = "true" ]; then
        git clone --recurse-submodules --progress --no-local $1 &> /dev/null
        cd $REPO_NAME
        get_storage_used .
        mem_before=$mem
        #modification of the remote submodule  
        cd ..
        cd $REPO_PATH/$SUB_NAME
        rm sub_sample0
        git add sub_sample0
        git commit --quiet -m"1M 'sub_sample0' deleted"
        cd ../../$REPO_NAME
        #fetching
        run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
        run git fetch --progress --tags --depth=1 origin &> /dev/null
        git checkout -f origin/main &> /dev/null
        get_storage_used .
        mem_after=$mem
        mem=$(($mem_after-$mem_before))
        echo "memory usage: $mem"
        cd ../$REPO_PATH/$SUB_NAME
        git reset --hard -q HEAD~1
        cd ../..
        rm -rf performance_testing
    else 
        echo "This test will not be performed because we are in no-submodule mode. Change boolean \$WITH_SUBMODULE to switch."
    fi
}

test13(){
    section TEST13
    run echo 'TEST 13 : case of --depth=1 fetching and merging, after addition then removal of a 1M file in submodule'
    if [ "$WITH_SUBMODULE" = "true" ]; then
        git clone --recurse-submodules --progress --no-local $1 &> /dev/null
        cd $REPO_NAME
        get_storage_used .
        mem_before=$mem
        #modification of the remote submodule  
        cd ..
        cd $REPO_PATH/$SUB_NAME
        create_random_file 'sub_sample1' '1M'
        git add sub_sample1
        git commit --quiet -m"second 1M sample created"
        rm sub_sample1
        git add sub_sample1
        git commit --quiet -m"1M 'sub_sample1' deleted"
        cd ../../$REPO_NAME
        #fetching
        run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
        run git fetch --progress --tags --depth=1 origin &> /dev/null
        git checkout -f origin/main &> /dev/null
        get_storage_used .
        mem_after=$mem
        mem=$(($mem_after-$mem_before))
        echo "memory usage: $mem"
        cd ../$REPO_PATH/$SUB_NAME
        git reset --hard -q HEAD~2
        cd ../..
        rm -rf performance_testing
    else 
        echo "This test will not be performed because we are in no-submodule mode. Change boolean \$WITH_SUBMODULE to switch."
    fi
}

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
    test6 $REMOTE
    test7 $REMOTE
    test8 $REMOTE
    test9 $REMOTE
    test10 $REMOTE
    test11 $REMOTE
    test12 $REMOTE
    test13 $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;;
        6)
            test6 $REMOTE;;
        7) 
            test7 $REMOTE;;
        8) 
            test8 $REMOTE;;
        9)
            test9 $REMOTE;;
        10)
            test10 $REMOTE;;
        11)
            test11 $REMOTE;;
        12)
            test12 $REMOTE;;
        13)     
            test13 $REMOTE;;
        *)
            echo "Error: Invalid test number"
            die;;
    esac
else
    Help
fi

#add the submodules management to the cloning
#add run