#! /bin/bash

set -euo pipefail


HOSTURL="${1:-http://127.0.0.1:7703}"


#------------------------------------------------------------------------------------------------
SCRIPT_DIR=$(dirname "$0")
SCRIPT_NAME=$(basename "$0")

# Download dshash utility if not already present
TEMP_DIR=$(mktemp -d)
trap "rm -rf $TEMP_DIR" EXIT
DSHASH="$TEMP_DIR/dshash"

echo "Downloading dshash utility..."
ARCH=$(uname -m)
if [ "$ARCH" = "x86_64" ]; then
    ARCH="x86_64"
elif [ "$ARCH" = "aarch64" ] || [ "$ARCH" = "arm64" ]; then
    ARCH="aarch64"
else
    echo "Unsupported architecture: $ARCH"
    exit 1
fi

curl -L -o "$DSHASH" "https://getbin.xyz/dshash:latest-$ARCH" 2>/dev/null || die "Failed to download dshash"
chmod +x "$DSHASH"
echo "dshash downloaded successfully"

# FUNCTIONS
function title() {
    echo "----------------------------------------"
    # Center the text
    local text="$1"
    local line_length=40
    local text_length=${#text}
    local padding=$(( (line_length - text_length) / 2 ))
    printf "%*s%s%*s\n" $padding "" "$text" $padding ""
    echo "----------------------------------------"
}   


function die() {
    title "error: $1"
    exit 1
}


#------------------------------------------------------------------------------------------------
cat << EOF


EOF

title "TESTING ${HOSTURL}"

cat << EOF


EOF


function test0() {
    # Test 0: Verify the script is running
    title "0: Verify the server is running"

    # test jq is installed
    if ! command -v jq &> /dev/null; then
        echo "jq could not be found"
        echo "sudo apt-get install jq"
        exit 1
    fi

    # read sos_config.json
    CONFIG_PATH="${SCRIPT_DIR}/sos_config.json"
    if [ ! -f "${CONFIG_PATH}" ]; then
        echo "config file not found at ${CONFIG_PATH}"
        exit 1
    fi
    CONFIG=$(cat "${CONFIG_PATH}")

    # Use plaintext tokens from environment (set by generate_test_config.sh or manually)
    # The config file should only contain hashed tokens
    if [ -n "${TEST_TOKEN1:-}" ] && [ -n "${TEST_TOKEN2:-}" ] && [ -n "${TEST_TOKEN3:-}" ]; then
        # Use environment tokens (plaintext)
        TOKENS=("$TEST_TOKEN1" "$TEST_TOKEN2" "$TEST_TOKEN3")
        TOKEN_COUNT=${#TOKENS[@]}
        RANDOM_INDEX=$((RANDOM % TOKEN_COUNT))
        WRITE_TOKEN="${TOKENS[$RANDOM_INDEX]}"
        echo "Using plaintext token index $RANDOM_INDEX from environment"
    else
        # For static test configs, use hardcoded plaintext tokens
        # These correspond to the hashes in the static sos_config.json
        TOKENS=("t570H7DmK2VBfCwUmtFaUXyzVklL90E1" "U3x9V39Y7rjXdRK0oxZsCz5lD6jFFDtm" "UhtchhGDEGXlJ37GumimFtPe0imjAvak")
        TOKEN_COUNT=${#TOKENS[@]}
        RANDOM_INDEX=$((RANDOM % TOKEN_COUNT))
        WRITE_TOKEN="${TOKENS[$RANDOM_INDEX]}"
        echo "Using hardcoded plaintext token index $RANDOM_INDEX (for static config)"
    fi

    BASE_TAG="autotest"

    if ! command -v wget &> /dev/null; then
        echo "wget could not be found"
        exit 1
    fi

    # test if server is running
    if ! wget -qO- "${HOSTURL}/status" | jq -r '.result' | grep -q 'success'; then
        wget -O - "${HOSTURL}/status"
        die "server is not running on ${HOSTURL}"
    fi

    echo "Simple Object Storage server is running at ${HOSTURL}"
}


function test1() {
    # test every action in the README.md file, leaving the system in the same state it was found
    # and print the output of each action

    # Construct metadata JSON
    METADATA_JSON=$(cat <<EOF
{
  "labeltags": ["${BASE_TAG}:test1"],
  "description": "Example file",
  "custom_field": "custom value"
}
EOF
)

    #------------------------------------------------------------------------------------------------
    # Test 1: Verify extra metadata fields are preserved
    title "1: Upload script to ${BASE_TAG}:test1"

    TEST_FILE="${SCRIPT_DIR}/${SCRIPT_NAME}"

    # upload this script as an object
    echo "uploading ${TEST_FILE} to ${BASE_TAG}:test1"
    UPLOAD_RESPONSE=$(curl -X PUT \
    -H "Authorization: Bearer ${WRITE_TOKEN}" \
    -F "file=@${TEST_FILE}" \
    -F "metadata=${METADATA_JSON}" \
    "${HOSTURL}/upload")

    echo "upload response: ${UPLOAD_RESPONSE}"

    OBJECT_HASH=$(echo "${UPLOAD_RESPONSE}" | jq -r '.hash')
}

function test2() {
#------------------------------------------------------------------------------------------------
title "2: Check sos hash matches"

# check the hash matches.
CMD="${HOSTURL}/hash/${BASE_TAG}:test1"
echo "checking hash via ${CMD}"
CHECK_HASH=$(curl --fail-with-body -s "${CMD}" | jq -r '.hash')
[ "${OBJECT_HASH}" = "${CHECK_HASH}" ] || die "hash does not match: ${OBJECT_HASH} != ${CHECK_HASH}"
}

function test3() {
#------------------------------------------------------------------------------------------------
title "3: Check MD5Sum matches, for both label:tag and hash downloads"

    # get SHA256 hash of this file
    HASH_SUM=$("$DSHASH" "${TEST_FILE}")
    echo "SHA256 hash of ${TEST_FILE} is ${HASH_SUM}"

    # download the object
    DOWNLOAD_FILE="${TEST_FILE}.downloaded"
    echo "downloading ${OBJECT_HASH} to ${DOWNLOAD_FILE}1"
    if ! curl --fail-with-body -s "${HOSTURL}/${OBJECT_HASH}" -o "${DOWNLOAD_FILE}1"; then
        die "Command failed: curl -s ${HOSTURL}/${OBJECT_HASH} -o ${DOWNLOAD_FILE}1"
    fi

    # download the object again via the label:tag
    echo "downloading ${BASE_TAG}:test1 to ${DOWNLOAD_FILE}2"
    if ! curl --fail-with-body -s "${HOSTURL}/${BASE_TAG}:test1" -o "${DOWNLOAD_FILE}2"; then
        die "failed to download ${BASE_TAG}:test1"
    fi

    # get SHA256 hash of the downloaded file
    HASH_SUM_DOWNLOADED1=$("$DSHASH" "${DOWNLOAD_FILE}1")
    echo "SHA256 hash of ${DOWNLOAD_FILE}1 is ${HASH_SUM_DOWNLOADED1}"
    [ "${HASH_SUM}" != "${HASH_SUM_DOWNLOADED1}" ] && die "SHA256 hashes do not match"
    HASH_SUM_DOWNLOADED2=$("$DSHASH" "${DOWNLOAD_FILE}2")
    [ "${HASH_SUM}" != "${HASH_SUM_DOWNLOADED2}" ] && die "SHA256 hashes do not match"

    rm "${DOWNLOAD_FILE}1"
    rm "${DOWNLOAD_FILE}2"
}

#------------------------------------------------------------------------------------------------
function test3b() {
    LABELTAG="finangle-wrangler:fuzzy_test"
    title "3b: Upload script to ${LABELTAG}"

    METADATA_JSON=$(cat <<EOF
{
  "labeltags": ["${LABELTAG}"],
  "description": "Test File for fuzzy test",
  "custom_field": "Upload2!!!111 Yay. This is a test file for the fuzzy test."
}
EOF
)

    # upload this script as an object
    echo "uploading ${TEST_FILE} to ${LABELTAG}"
    UPLOAD_RESPONSE=$(curl -X PUT \
  -H "Authorization: Bearer ${WRITE_TOKEN}" \
  -F "file=@${TEST_FILE}" \
  -F "metadata=${METADATA_JSON}" \
  "${HOSTURL}/upload")

    echo "upload response: ${UPLOAD_RESPONSE}"

    OBJECT_HASH2=$(echo "${UPLOAD_RESPONSE}" | jq -r '.hash')

    if [ ! "${OBJECT_HASH}" == "${OBJECT_HASH2}" ]; then
        die "object hash does not match: ${OBJECT_HASH} != ${OBJECT_HASH2}"
    fi

    # test the description and custom field matches our new ones.
    METADATA_RESPONSE=$(curl "${HOSTURL}/meta/${OBJECT_HASH2}")

    echo "metadata response: ${METADATA_RESPONSE}"

    if ! echo "${METADATA_RESPONSE}" | jq -r '.metadata.description' | grep -q "Test File for fuzzy test"; then
        die "description does not match"
    fi

    if ! echo "${METADATA_RESPONSE}" | jq -r '.metadata.custom_field' | grep -q "Upload2!!!111 Yay. This is a test file for the fuzzy test."; then
        die "custom field does not match"
    fi

    # download via the label:tag
    echo "downloading ${LABELTAG} to ${DOWNLOAD_FILE}3"
    if ! curl --fail-with-body -s "${HOSTURL}/${LABELTAG}" -o "${DOWNLOAD_FILE}3"; then
        die "failed to download ${LABELTAG}"
    fi

    # get SHA256 hash of the downloaded file
    HASH_SUM_DOWNLOADED3=$("$DSHASH" "${DOWNLOAD_FILE}3")
    echo "SHA256 hash of ${DOWNLOAD_FILE}3 is ${HASH_SUM_DOWNLOADED3}"
    [ "${HASH_SUM}" != "${HASH_SUM_DOWNLOADED3}" ] && die "SHA256 hashes do not match"

    rm "${DOWNLOAD_FILE}3"
}

function test4() {
    #------------------------------------------------------------------------------------------------
    title "4: Delete the object"

    # delete the object
    echo "deleting ${OBJECT_HASH}"
    if ! curl -s -H "Authorization: Bearer ${WRITE_TOKEN}" "${HOSTURL}/deleteobject?hash=${OBJECT_HASH}" | jq -r '.result' | grep -q 'success'; then
        die "failed to delete ${OBJECT_HASH}"
    fi

    # verify the object is deleted
    echo "verifying ${OBJECT_HASH} is deleted"
    DELETE_RESPONSE=$(curl -s "${HOSTURL}/${OBJECT_HASH}")
    if ! echo "${DELETE_RESPONSE}" | jq -r '.result' | grep -q 'error'; then
        die "failed to verify ${OBJECT_HASH} is deleted"
    fi
}

function test5() {
    #------------------------------------------------------------------------------------------------
    title "5: Test metadata field preservation"

    # Upload with extra metadata fields
    EXTRA_METADATA_JSON=$(cat <<EOF
{
  "labeltags": ["${BASE_TAG}:test2"],
  "description": "Test with extra fields",
  "custom_field": "custom value",
  "extra_field1": "value1",
  "extra_field2": "value2"
}
EOF
)

    echo "uploading with extra metadata fields"
    UPLOAD_RESPONSE=$(curl -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -F "file=@${SCRIPT_DIR}/${SCRIPT_NAME}" \
      -F "metadata=${EXTRA_METADATA_JSON}" \
      "${HOSTURL}/upload")
    UPLOAD_EXIT_CODE=$?
    echo "Upload response: ${UPLOAD_RESPONSE}"
    echo "Upload exit code: ${UPLOAD_EXIT_CODE}"

    if [ ${UPLOAD_EXIT_CODE} -ne 0 ]; then
        die "Failed to upload object: curl returned ${UPLOAD_EXIT_CODE}"
    fi

    if ! echo "${UPLOAD_RESPONSE}" | jq -e . >/dev/null 2>&1; then
        die "Invalid JSON response from upload: ${UPLOAD_RESPONSE}"
    fi

    OBJECT_HASH=$(echo "${UPLOAD_RESPONSE}" | jq -r '.hash')
    echo "Received hash: ${OBJECT_HASH}"

    # Verify the object exists
    echo "Verifying object exists..."
    EXISTS_RESPONSE=$(curl -s "${HOSTURL}/exists/${BASE_TAG}:test2")
    echo "Exists response: ${EXISTS_RESPONSE}"

    # Get metadata and verify extra fields are preserved
    echo "Retrieving metadata for ${BASE_TAG}:test2"
    METADATA_RESPONSE=$(curl -s "${HOSTURL}/meta/${BASE_TAG}:test2")
    CURL_EXIT_CODE=$?
    echo "Curl exit code: ${CURL_EXIT_CODE}"
    echo "Full metadata response: ${METADATA_RESPONSE}"

    if [ ${CURL_EXIT_CODE} -ne 0 ]; then
        die "Failed to retrieve metadata: curl returned ${CURL_EXIT_CODE}"
    fi

    if ! echo "${METADATA_RESPONSE}" | jq -e . >/dev/null 2>&1; then
        die "Invalid JSON response: ${METADATA_RESPONSE}"
    fi

    if ! echo "${METADATA_RESPONSE}" | jq -r '.metadata.extra_field1' | grep -q 'value1'; then
        die "extra_field1 not preserved in metadata"
    fi
    if ! echo "${METADATA_RESPONSE}" | jq -r '.metadata.extra_field2' | grep -q 'value2'; then
        die "extra_field2 not preserved in metadata"
    fi
}

function test6() {
    #------------------------------------------------------------------------------------------------
    title "6: Test tag versioning behavior"

    # Clean up
    curl -s -H "Authorization: Bearer ${WRITE_TOKEN}" "${HOSTURL}/deleteobject?hash=${OBJECT_HASH}" > /dev/null

    # Upload first version with tag 'latest'
    FIRST_METADATA_JSON=$(cat <<EOF
{
  "labeltags": ["${BASE_TAG}:latest", "${BASE_TAG}:v1"],
  "description": "First version"
}
EOF
)

    echo "uploading first version with tag 'latest'"
    UPLOAD_RESPONSE=$(curl -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -F "file=@${SCRIPT_DIR}/${SCRIPT_NAME}" \
      -F "metadata=${FIRST_METADATA_JSON}" \
      "${HOSTURL}/upload")

    FIRST_HASH=$(echo "${UPLOAD_RESPONSE}" | jq -r '.hash')

    # check downloading without tag!
    echo "downloading ${BASE_TAG} to ${DOWNLOAD_FILE}4"
    if ! curl -s --fail-with-body "${HOSTURL}/${BASE_TAG}" -o "${DOWNLOAD_FILE}4"; then
        die "failed to download ${BASE_TAG}"
    fi
    # get SHA256 hash of the downloaded file
    HASH_SUM_DOWNLOADED4=$("$DSHASH" "${DOWNLOAD_FILE}4")
    HASH_SUM_ORIGINAL=$("$DSHASH" "${SCRIPT_DIR}/${SCRIPT_NAME}")
    [ "${HASH_SUM_ORIGINAL}" != "${HASH_SUM_DOWNLOADED4}" ] && die "SHA256 hashes do not match"

    # Store first version's metadata before uploading second version
    FIRST_METADATA=$(curl -s "${HOSTURL}/meta/${FIRST_HASH}")
    echo "First version metadata response: ${FIRST_METADATA}"
    if ! echo "${FIRST_METADATA}" | jq -r '.metadata.labeltags[]' | grep -q "${BASE_TAG}:v1"; then
        die "First version does not have v1 tag"
    fi

    # Upload second version with same tag 'latest'
    SECOND_METADATA_JSON=$(cat <<EOF
{
  "labeltags": ["${BASE_TAG}:latest", "${BASE_TAG}:v2"],
  "description": "Second version"
}
EOF
)

    echo "uploading second version with tag 'latest'"
    UPLOAD_RESPONSE=$(curl -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -F "file=@${SCRIPT_DIR}/test_1GB_file_upload.sh" \
      -F "metadata=${SECOND_METADATA_JSON}" \
      "${HOSTURL}/upload")

    SECOND_HASH=$(echo "${UPLOAD_RESPONSE}" | jq -r '.hash')

    # Verify first version's metadata still has v1 tag
    FIRST_METADATA=$(curl -s "${HOSTURL}/meta/${FIRST_HASH}")
    echo "First version metadata response: ${FIRST_METADATA}"
    if ! echo "${FIRST_METADATA}" | jq -r '.metadata.labeltags[]' | grep -q "${BASE_TAG}:v1"; then
        die "First version does not have v1 tag"
    fi

    # Verify first version's metadata no longer has the latest tag
    if echo "${FIRST_METADATA}" | jq -r '.metadata.labeltags[]' | grep -q "${BASE_TAG}:latest"; then
        die "First version still has latest tag"
    fi

    # Verify second version has the correct tags: v2 and latest
    SECOND_METADATA=$(curl -s "${HOSTURL}/meta/${SECOND_HASH}")
    echo "Second version metadata response: ${SECOND_METADATA}"
    if ! echo "${SECOND_METADATA}" | jq -r '.metadata.labeltags[]' | grep -q "${BASE_TAG}:latest"; then
        die "Second version does not have latest tag"
    fi
    if ! echo "${SECOND_METADATA}" | jq -r '.metadata.labeltags[]' | grep -q "${BASE_TAG}:v2"; then
        die "Second version does not have v2 tag"
    fi
}

function test7() {
    #------------------------------------------------------------------------------------------------
    title "7: Test rate limiting behavior"

    # Clean up
    curl -s -H "Authorization: Bearer ${WRITE_TOKEN}" "${HOSTURL}/deleteobject?hash=${FIRST_HASH}" > /dev/null
    curl -s -H "Authorization: Bearer ${WRITE_TOKEN}" "${HOSTURL}/deleteobject?hash=${SECOND_HASH}" > /dev/null

    # Use a known invalid token
    INVALID_TOKEN="invalid_token"

    # Make 5 requests with an invalid token
    for i in {1..5}; do
        echo "Attempt $i with invalid token"
        RESPONSE=$(curl -s -X PUT -H "Authorization: Bearer ${INVALID_TOKEN}" -F "file=@${SCRIPT_DIR}/${SCRIPT_NAME}" -F "metadata={\"labeltags\":[\"test:latest\"]}" "${HOSTURL}/upload")
        echo "Response: ${RESPONSE}"
    done

    # Now try a request with a valid token - should be rate limited
    echo "Attempting request with valid token (should be rate limited)"
    RESPONSE=$(curl -s -X PUT -H "Authorization: Bearer ${WRITE_TOKEN}" -F "file=@${SCRIPT_DIR}/${SCRIPT_NAME}" -F "metadata={\"labeltags\":[\"test:latest\"]}" "${HOSTURL}/upload")
    if ! echo "${RESPONSE}" | jq -r '.error' | grep -q "Too many authentication attempts"; then
        die "Expected rate limit error, got: ${RESPONSE}"
    fi

    echo "Sleeping for 3 seconds to allow rate limit to reset"
    echo "(Normally 5 mins, but we set to 2s for this test!)"

    sleep 3
    # Now try a request with a valid token - should be rate limited
    echo "Attempting request with valid token (should NOT be rate limited)"
    RESPONSE=$(curl -s -X PUT -H "Authorization: Bearer ${WRITE_TOKEN}" -F "file=@${SCRIPT_DIR}/${SCRIPT_NAME}" -F "metadata={\"labeltags\":[\"test:latest\"]}" "${HOSTURL}/upload")
}

function test8() {
    #------------------------------------------------------------------------------------------------
    title "8: Test update endpoint"

    # First upload a test file
    UPLOAD_RESPONSE=$(curl -s -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -F "file=@${SCRIPT_DIR}/${SCRIPT_NAME}" \
      -F "metadata={\"labeltags\":[\"test:update\"]}" \
      "${HOSTURL}/upload")

    HASH=$(echo "${UPLOAD_RESPONSE}" | jq -r '.hash')
    if [ -z "${HASH}" ] || [ "${HASH}" = "null" ]; then
        die "Failed to upload test file for update test"
    fi

    # Test 8.1: Update metadata using JSON
    UPDATED_METADATA='{"labeltags":["test:updated", "version:1.0"], "new_field":"test_value"}'
    UPDATE_RESPONSE=$(curl -s -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -H "Content-Type: application/json" \
      -d "{\"hash\":\"${HASH}\", \"metadata\":${UPDATED_METADATA}}" \
      "${HOSTURL}/update")

    echo "Update response: ${UPDATE_RESPONSE}"
    if [ "$(echo "${UPDATE_RESPONSE}" | jq -r '.result')" != "success" ]; then
        die "Failed to update metadata via JSON"
    fi

    # Verify the update
    UPDATED_METADATA_RESPONSE=$(curl -s "${HOSTURL}/meta/${HASH}")
    if ! echo "${UPDATED_METADATA_RESPONSE}" | jq -e '.metadata.new_field == "test_value"' | grep -q true; then
        die "Metadata was not updated correctly via JSON"
    fi

    # Test 8.2: Update metadata using form data
    # Update with form data using raw JSON string
    UPDATE_FORM_RESPONSE=$(curl -s -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -F "hash=${HASH}" \
      -F 'metadata={"labeltags":["test:form_updated"], "form_field":"form_value"}' \
      "${HOSTURL}/update")

    echo "Form update response: ${UPDATE_FORM_RESPONSE}"
    if [ "$(echo "${UPDATE_FORM_RESPONSE}" | jq -r '.result')" != "success" ]; then
        die "Failed to update metadata via form data"
    fi

    # Verify the form update
    UPDATED_FORM_METADATA_RESPONSE=$(curl -s "${HOSTURL}/meta/${HASH}")
    if ! echo "${UPDATED_FORM_METADATA_RESPONSE}" | jq -e '.metadata.form_field == "form_value"' | grep -q true; then
        die "Metadata was not updated correctly via form data"
    fi

    # Test 8.3: Test error cases
    # Missing hash
    MISSING_HASH_RESPONSE=$(curl -s -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -d '{"metadata":{}}' \
      "${HOSTURL}/update")
    if [ "$(echo "${MISSING_HASH_RESPONSE}" | jq -r '.error')" != "Missing 'hash' or 'metadata' field in request body" ]; then
        die "Expected error for missing hash, got: ${MISSING_HASH_RESPONSE}"
    fi

    # Missing metadata
    MISSING_METADATA_RESPONSE=$(curl -s -X PUT \
      -H "Authorization: Bearer ${WRITE_TOKEN}" \
      -d "{\"hash\":\"${HASH}\"}" \
      "${HOSTURL}/update")
    if [ "$(echo "${MISSING_METADATA_RESPONSE}" | jq -r '.error')" != "Missing 'hash' or 'metadata' field in request body" ]; then
        die "Expected error for missing metadata, got: ${MISSING_METADATA_RESPONSE}"
    fi

    # Verify that labeltags were actually updated
    echo "Checking if test:updated tag exists..."
    UPDATED_HASH=$(curl -s "${HOSTURL}/hash/test:updated" | jq -r '.hash')
    if [ "${UPDATED_HASH}" = "${HASH}" ]; then
        echo "✓ test:updated tag correctly points to hash ${HASH}"
    else
        echo "✗ test:updated tag not found or points to wrong hash: ${UPDATED_HASH}"
        exit 1
    fi
    
    echo "Checking if test:form_updated tag exists..."
    FORM_UPDATED_HASH=$(curl -s "${HOSTURL}/hash/test:form_updated" | jq -r '.hash')
    if [ "${FORM_UPDATED_HASH}" = "${HASH}" ]; then
        echo "✓ test:form_updated tag correctly points to hash ${HASH}"
    else
        echo "✗ test:form_updated tag not found or points to wrong hash: ${FORM_UPDATED_HASH}"
        exit 1
    fi

    # Clean up using the correct current labeltag
    echo "Cleaning up test object with hash: ${HASH}"
    RESPONSE=$(curl -s -H "Authorization: Bearer ${WRITE_TOKEN}" "${HOSTURL}/deleteobject?hash=${HASH}")
    echo "Delete response: ${RESPONSE}"
    
    if echo "${RESPONSE}" | jq -r '.result' | grep -q 'success'; then
        echo "Successfully deleted test object"
    else
        echo "Failed to delete test object: ${RESPONSE}"
        exit 1
    fi
}

#------------------------------------------------------------------------------------------------

function test9() {
    title "9: Testing 100MB File upload"
    source test_100MB_file_upload.sh
}

#------------------------------------------------------------------------------------------------

function test10() {
    title "10: Testing Input Validation"
    
    # Use the simpler validation test that works in Docker
    local test_script="test_input_validation_simple.sh"
    
    # Fall back to full test if simple doesn't exist
    if [ ! -f "$test_script" ]; then
        test_script="test_input_validation.sh"
    fi
    
    # Check if validation test script exists
    if [ ! -f "$test_script" ]; then
        echo "Warning: No input validation test script found, skipping"
        return 0
    fi
    
    # Run the input validation tests
    # Use the same token that's already set
    export TEST_TOKEN1="${WRITE_TOKEN}"
    
    echo "Running input validation tests..."
    if bash "${SCRIPT_DIR}/$test_script" "${HOSTURL}"; then
        echo "✓ Input validation tests passed"
    else
        die "Input validation tests failed"
    fi
}

#------------------------------------------------------------------------------------------------

function test11() {
    title "11: Testing hash_token utility"
    
    # Check if the hash_token test script exists
    local test_script="${SCRIPT_DIR}/test_hash_token.sh"
    if [ ! -f "$test_script" ]; then
        echo "Warning: hash_token test script not found, skipping"
        return 0
    fi
    
    # Make the script executable
    chmod +x "$test_script"
    
    # Run the hash_token tests
    echo "Running hash_token utility tests..."
    if bash "$test_script"; then
        echo "✓ hash_token utility tests passed"
    else
        die "hash_token utility tests failed"
    fi
}

#------------------------------------------------------------------------------------------------

test0   
test1
test2
test3
test3b
test4
test5
test6
test7
test8
test9
test10
test11

title "ALL TESTS PASSED"
