p4app

#!/usr/bin/env bash
# Ensure the LANG environment variable is set to UTF-8
export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

P4APP_IMAGE=${P4APP_IMAGE:-p4lang/p4app:latest}
P4APP_CONTAINER_ARGS=${P4APP_CONTAINER_ARGS:-""}

# Ensure QEMU is set up for cross-platform execution if on arm64
function setup_qemu() {
    if ! docker run --rm --privileged multiarch/qemu-user-static --reset -p yes &>/dev/null; then
        echo "Setting up QEMU for cross-platform Docker support."
        docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
    fi
}

# Run QEMU setup if on arm64 platform
if [[ "$(uname -m)" == "aarch64" ]]; then
    setup_qemu
fi

# Function to get absolute path
myrealpath() {
    [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
}

P4APP_LOGDIR=$(myrealpath "${P4APP_LOGDIR:-/tmp/p4app_logs}")

# Function to check and fix encoding with multiple fallback options
function check_and_fix_utf8() {
    local file="$1"
    local encoding

    # Detect encoding
    encoding=$(file -i "$file" | awk -F "=" '{print $2}')

    if [[ "$encoding" != "utf-8" ]]; then
        echo "Invalid UTF-8 detected in: $file (encoding: $encoding)"
        local fixed_file="${file}.fixed"
        local success=false

        # Try iconv with detected or known encodings
        for enc in "$encoding" ISO-8859-1 WINDOWS-1252 ASCII; do
            if iconv -f "$enc" -t UTF-8//IGNORE "$file" -o "$fixed_file" 2>/dev/null; then
                success=true
                echo "Fixed encoding using $enc for: $file"
                break
            fi
        done

        # If iconv failed, remove non-UTF-8 characters
        if ! $success; then
            echo "All iconv attempts failed. Removing non-UTF-8 characters from: $file"
            sed 's/[^[:print:]\t]//g' "$file" > "$fixed_file"
        fi

        # Replace original file if fixed
        if [ -f "$fixed_file" ]; then
            mv "$fixed_file" "$file"
            echo "Fixed encoding in: $file"
        else
            echo "Failed to fix encoding in: $file"
        fi
    else
        echo "Valid UTF-8: $file"
    fi
}

# Function to get absolute filename
function get_abs_filename() {
    echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"
}

# Normalize path by removing any trailing slash
function normalize_path() {
    echo ${1%/}
}

# Build command function
function build-command {
    local output_file=${2:-"out.json"}
    run-command "$1" --build-only "${@:3}"
    rc=$?

    [ $rc -eq 0 ] && cp "$P4APP_LOGDIR/program.json" "$output_file"
    exit $rc
}

# Run p4app function with Docker container
function run-p4app {
    APP_TO_RUN=/tmp/app.tar.gz
    P4APP_NAME=${P4APP_NAME:-"p4app_$RANDOM"}
    docker run --platform linux/amd64 --privileged --interactive --tty --rm \
        --name "$P4APP_NAME" \
        -v "$1:$APP_TO_RUN" \
        -v "$P4APP_LOGDIR:/tmp/p4app_logs" \
        $P4APP_CONTAINER_ARGS \
        $P4APP_IMAGE "$APP_TO_RUN" "${@:2}"
}

# Run command function to handle .p4app packages
function run-command {
    if [ -d "$1" ]; then
        PACKAGE_DIR=$(normalize_path "$1")
        APP_FILE=$(mktemp /tmp/p4app.tar.gz.XXXXXX)

        # Create backup of the package before compilation
        create_backup_object "$PACKAGE_DIR"

        # Package files without extended pax headers
        tar --format=ustar -czf "$APP_FILE" -C "$PACKAGE_DIR" .
        run-p4app "$APP_FILE" "${@:2}"
        rc=$?
        rm "$APP_FILE"
    elif [ -f "$1" ]; then
        APP_FILE=$(get_abs_filename "$1")

        # Create backup of the single file
        create_backup_object "$(dirname "$APP_FILE")"

        # Check and fix encoding for the file
        check_and_fix_utf8 "$APP_FILE"

        run-p4app "$APP_FILE" "${@:2}"
        rc=$?
    else
        echo "Couldn't read p4app package: $1"
        exit 1
    fi
    return $rc
}

function create_backup_object() {
    local package_dir="$1"
    local backup_file="backup_$(basename "$package_dir").txt"

    echo "This is the code:\n" >> "$backup_file"
    # Iterate through files in the package directory and add headers and content to the TXT file
    for file in "$package_dir"/*; do
        if [ -f "$file" ]; then
            local filename=$(basename "$file")

            # Write the file header to the backup file
            echo "$filename" >> "$backup_file"

            # Append file content to the backup file
            cat "$file" >> "$backup_file"

            # Add a newline after each file's content for separation
            echo -e "\n" >> "$backup_file"
        fi
    done

    echo "Backup created at $backup_file"
}

# Main case selector
case "$1" in
  "run")
    run-command "${@:2}"
    ;;
  "build")
    build-command "${@:2}"
    ;;
  "pack")
    pack-command "${@:2}"
    ;;
  "unpack")
    unpack-command "${@:2}"
    ;;
  "update")
    update-command "${@:2}"
    ;;
  "exec")
    exec-command "${@:2}"
    ;;
  *)
    usage-command
    ;;
esac