#!/bin/bash

set -euo pipefail

SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

# list of toolchains to install
TOOLCHAIN_LIST=(
    "aarch64-linux-musl-cross"
    "x86_64-linux-musl-cross"
    "x86_64-linux-musl-native"
)


# If the user is not root, use sudo
SUDOCMD=""
[ "$EUID" -eq 0 ] || SUDOCMD="sudo"

# If the user is not root, use the home directory of the user who ran the script
USER_HOME="$HOME"
if [ -n "${SUDO_USER:-}" ] && [ "$SUDO_USER" != "root" ]; then
    USER_HOME=$(eval echo "~${SUDO_USER}")
fi

# test sudo is working or we're root (return non-zero if not root!)
if ! ${SUDOCMD:-} true; then
    echo "Error: This script must be run as root or with sudo privileges." >&2
    exit 1
fi

_die() {
    echo -e "Error: $1" >&2
    exit 1
}

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Function to print status messages
print_status() {
    echo -e "${GREEN}[*] $1${NC}"
}

print_error() {
    echo -e "${RED}[!] $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}[!] $1${NC}"
}



#----------------------------------------------------------------------------------------------------------
# Headers on Host (Native)
#----------------------------------------------------------------------------------------------------------


# Function to check if a package is installed
is_package_installed() {
    if [ "$OS" = "Alpine Linux" ]; then
        apk info | grep -q "^$1$"
    else
        dpkg -l "$1"
    fi
}
function install_packages() {
    local PACKAGES
    local HAVE_UPDATED=0

    # Detect distribution
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS=$NAME
        VER=$VERSION_ID
    else
        print_error "Could not detect distribution"
        exit 1
    fi

    print_status "Detected OS: $OS $VER"

    # Define packages based on distribution
    case $OS in
        "Ubuntu")
            # Common packages for both Ubuntu and Debian
            PACKAGES="build-essential cmake git wget tar curl ninja-build mold nodejs npm perl jq ccache upx-ucl nlohmann-json3-dev"
            INSTALLCMD="apt-get install -y" 
            UPDATECMD="apt-get update"
            ;;
        "Debian GNU/Linux")
            PACKAGES="build-essential cmake git wget tar curl ninja-build mold nodejs npm perl jq ccache upx-ucl nlohmann-json3-dev"
            INSTALLCMD="apt-get install -y" 
            UPDATECMD="apt-get update"

            # special case for debian 12
            if ! is_package_installed "upx-ucl"; then
                # get from testing.
                # Add testing repo temporarily
                echo "deb http://deb.debian.org/debian testing main" | ${SUDOCMD:-} tee /etc/apt/sources.list.d/testing-temp.list
                # Update package lists
                ${SUDOCMD:-} bash -c "apt-get update"
                ${SUDOCMD:-} bash -c "apt-get -t testing install -y upx-ucl"
                ${SUDOCMD:-} bash -c "rm /etc/apt/sources.list.d/testing-temp.list"
                ${SUDOCMD:-} bash -c "apt-get update"
                HAVE_UPDATED=1
            fi
            ;;            
        "Alpine Linux")
            PACKAGES="build-base cmake git wget tar curl ninja mold nodejs npm linux-headers perl jq ccache upx nlohmann-json-dev"
            INSTALLCMD="apk add --no-cache"
            UPDATECMD="apk update"
            ;;
        *)
            print_error "Unsupported distribution: $OS"
            exit 1
            ;;
    esac

    # Install missing packages
    print_status "Checking and installing required packages..."
    for pkg in $PACKAGES; do
        if ! is_package_installed "$pkg"; then
            print_status "Installing $pkg..."

            # Update package lists
            if [ "$HAVE_UPDATED" -eq 0 ]; then
                print_status "Updating package lists..."
                ${SUDOCMD:-} bash -c "${UPDATECMD}"
                HAVE_UPDATED=1
            fi

            if ! bash -c "${SUDOCMD:-} ${INSTALLCMD} $pkg"; then
                print_error "Failed to install $pkg"
                exit 1
            fi
        else
            print_status "$pkg is already installed"
        fi
    done

}

# function install_libassert() {
#     # put libassert headers on the host.
#     echo "Checking for libassert headers"
#     if [ ! -f "/usr/local/lib/libassert.a" ]; then
#         echo "libassert not found, installing..."
#         git clone https://github.com/jeremy-rifkin/libassert.git
#         #git checkout v2.1.5
#         mkdir libassert/build
#         cd "libassert/build" || exit 1
#         cmake .. -DCMAKE_BUILD_TYPE=Release
#         make -j
#         ${SUDOCMD:-} make install
#         cd ../..
#         rm -rf libassert
#     else
#         echo "libassert headers already installed"
#     fi
# }

#----------------------------------------------------------------------------------------------------------
# unwind for musl cross toolchains
#----------------------------------------------------------------------------------------------------------

function install_unwind_musl() {
    local FULLARCH="$1"
    local ARCH="${FULLARCH%%-*}"
    local ARCH_SHORT_PREFIX="${FULLARCH%-*}"
    local MUSL_PATH="${INSTALL_DIR}/${FULLARCH}"
    [ -d "$MUSL_PATH" ] || _die "MUSL_PATH does not exist: $MUSL_PATH"

    local BUILD_DIR="${SCRIPT_DIR}/build.$ARCH"
    PREVDIR="$PWD"
    rm -rf "$BUILD_DIR"
    mkdir -p "$BUILD_DIR"
    cd "$BUILD_DIR"

    local SYSROOT="$MUSL_PATH/${ARCH_SHORT_PREFIX}/sysroot"

    LIBPATH="$MUSL_PATH/${ARCH_SHORT_PREFIX}/sysroot/usr/lib"
    [ -d "$LIBPATH" ] || LIBPATH="$MUSL_PATH/${ARCH_SHORT_PREFIX}/sysroot/usr/lib64"
    if [ -f "$LIBPATH/libunwind.a" ]; then
        echo "Unwind $ARCH is already installed"
        return
    fi

    # Set cross-compiler and sysroot
    local CC="$MUSL_PATH/bin/${ARCH_SHORT_PREFIX}-gcc"
    [ -f "$CC" ] || CC="$MUSL_PATH/bin/gcc"
    local AR="$MUSL_PATH/bin/${ARCH_SHORT_PREFIX}-ar"
    [ -f "$AR" ] || AR="$MUSL_PATH/bin/ar"
    local RANLIB="$MUSL_PATH/bin/${ARCH_SHORT_PREFIX}-ranlib"
    [ -f "$RANLIB" ] || RANLIB="$MUSL_PATH/bin/ranlib"

    git clone https://github.com/libunwind/libunwind.git
    cd libunwind
    autoreconf -i

    # Configure for cross-compiling
    CC="$CC" AR="$AR" RANLIB="$RANLIB" ./configure \
    --host="$ARCH_SHORT_PREFIX" \
    --prefix="$SYSROOT/usr" \
    --enable-static \
    --disable-shared \
    --disable-minidebuginfo \
    --disable-zlibdebuginfo

    make -j
    ${SUDOCMD:-} make install

    cd "$PREVDIR"
    rm -rf "$BUILD_DIR"
}

#----------------------------------------------------------------------------------------------------------
# OpenSSL for musl cross toolchains
#----------------------------------------------------------------------------------------------------------

toolchain_to_openssl_target() {
    case "$1" in
        aarch64-linux-musl-*) echo "linux-aarch64" ;;
        x86_64-linux-musl-*) echo "linux-x86_64" ;;
        *) _die "unsupported toolchain: $1" ;;
    esac
}

function install_openssl_musl() {
    OPENSSL_VERSION=3.5.0

    PREVDIR="$PWD"

    # set the ARCH, ARCH_OS, ARCH_FULL_PREFIX, ARCH_SHORT_PREFIX, and MUSL_PATH variables
    # e.g. aarch64-linux-musl-cross
    # ARCH=aarch64
    # ARCH_OS=linux-musl-cross
    # ARCH_SHORT_PREFIX=aarch64-linux-musl
    # MUSL_PATH=/home/jde/.musl-cross/aarch64-linux-musl-cross
    # arch should just be x86_64 or aarch64
    local FULLARCH="${1:-}"
    [ -n "$FULLARCH" ] || _die "No toolchain provided"

    local ARCH="${FULLARCH%%-*}"
    #local ARCH_OS="${FULLARCH#*-}"
    local ARCH_SHORT_PREFIX="${FULLARCH%-*}"
    local MUSL_PATH="${INSTALL_DIR}/${FULLARCH}"
    [ -d "$MUSL_PATH" ] || _die "MUSL_PATH does not exist: $MUSL_PATH"

    LIBPATH="$MUSL_PATH/${ARCH_SHORT_PREFIX}/sysroot/usr/lib"
    [ -d "$LIBPATH" ] || LIBPATH="$MUSL_PATH/${ARCH_SHORT_PREFIX}/sysroot/usr/lib64"
    if [ -f "$LIBPATH/libssl.a" ]; then
        echo "OpenSSL $ARCH is already installed"
        return
    fi

    local BUILD_DIR="${SCRIPT_DIR}/build.$ARCH"
    mkdir -p "$BUILD_DIR"

    # Helper: compare versions (returns 0 if $1 >= $2)
    version_ge() {
        [ "$1" = "$2" ] && return 0
        [ "$(printf '%s\n' "$1" "$2" | sort -V | head -n1)" = "$2" ]
    }

    echo "==============================="
    echo "Checking OpenSSL for $ARCH..."
    echo "==============================="
    local OPENSSL_TARGET
    OPENSSL_TARGET=$(toolchain_to_openssl_target "$FULLARCH")
    local SYSROOT="$MUSL_PATH/${ARCH_SHORT_PREFIX}/sysroot"
    local CC="$MUSL_PATH/bin/${ARCH_SHORT_PREFIX}-gcc"
    [ -f "$CC" ] || CC="$MUSL_PATH/bin/gcc"
    local AR="$MUSL_PATH/bin/${ARCH_SHORT_PREFIX}-ar"
    [ -f "$AR" ] || AR="$MUSL_PATH/bin/ar"
    local RANLIB="$MUSL_PATH/bin/${ARCH_SHORT_PREFIX}-ranlib"
    [ -f "$RANLIB" ] || RANLIB="$MUSL_PATH/bin/ranlib"

    DEST_PATH="$SYSROOT/usr/lib/libssl.a"
    if [ -f "$DEST_PATH" ]; then
        echo "OpenSSL $ARCH is already installed"
    else
        cd "$BUILD_DIR"
        if [ ! -d "openssl-${OPENSSL_VERSION}" ]; then
            if [ ! -f "openssl-${OPENSSL_VERSION}.tar.gz" ]; then
                wget "https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz" || _die "Failed to download openssl-${OPENSSL_VERSION}.tar.gz"
            fi
            tar xf "openssl-${OPENSSL_VERSION}.tar.gz" || _die "Failed to extract openssl-${OPENSSL_VERSION}.tar.gz"
        fi
        cd "openssl-${OPENSSL_VERSION}" || _die "Failed to cd to openssl-${OPENSSL_VERSION}"

        echo "----------------------------------------------"    
        echo "Configuring for $ARCH with sysroot $SYSROOT..."
        CC="$CC" AR="$AR" RANLIB="$RANLIB" ./Configure "$OPENSSL_TARGET" no-shared --prefix="$SYSROOT/usr"
        echo "Building..."
        make -j"$(nproc)"
        echo "Installing to $SYSROOT/usr ..."
        make install_sw

        echo "Done for $ARCH."
        echo
    fi

    rm -rf "$BUILD_DIR"

    cd "$PREVDIR"

    echo "OpenSSL built and installed for $FULLARCH"
}



# ----------------------------------------------------------------------------------------------------------
# MUSL CROSS COMPILERS
# ----------------------------------------------------------------------------------------------------------


function check_path() {
    local BASHRC="${USER_HOME}/.bashrc"
    local TOOLCHAIN="$1"
    local MUSL_PATH="$INSTALL_DIR/$TOOLCHAIN/bin"
    if ! echo "$PATH" | grep -q "$MUSL_PATH"; then
        echo "Adding $MUSL_PATH to PATH in $BASHRC"
        PATH_LINE="export PATH=\"$MUSL_PATH:\$PATH\""
        if ! grep -Fxq "$PATH_LINE" "$BASHRC"; then
            echo "" >> "$BASHRC"
            echo "# Add musl cross compilers to PATH for dropshell" >> "$BASHRC"
            echo "$PATH_LINE" >> "$BASHRC"

            echo "Added musl cross compilers to $BASHRC"
            echo "You should run 'source ~/.bashrc' to update your PATH"
        else
            echo "You should run 'source ~/.bashrc' to update your PATH"
        fi
    fi
}

function install_musl_cross() {
    local TOOLCHAIN="$1"
    local MUSL_CC_URL="https://getbin.xyz"
    if [ ! -d "$INSTALL_DIR/$TOOLCHAIN" ]; then
        echo "Downloading $TOOLCHAIN musl cross toolchain..."
        wget -nc -O "$TMPDIR/$TOOLCHAIN.tgz" "$MUSL_CC_URL/$TOOLCHAIN.tgz:latest"
        tar -C "$INSTALL_DIR" -xvf "$TMPDIR/$TOOLCHAIN.tgz"
    else
        echo "$TOOLCHAIN musl cross toolchain already installed"
    fi
}

function install_musl() {
    echo "Installing musl toolchain"

    # Set install directory
    INSTALL_DIR="$USER_HOME/.musl-cross"
    mkdir -p "$INSTALL_DIR"

    TMPDIR=$(mktemp -d)
    trap 'rm -rf "$TMPDIR"' EXIT

    for TOOLCHAIN in "${TOOLCHAIN_LIST[@]}"; do
        install_musl_cross "$TOOLCHAIN"
        check_path "$TOOLCHAIN"

        install_openssl_musl "$TOOLCHAIN"
        install_unwind_musl "$TOOLCHAIN"
    done

    # Clean up
    rm -rf "$TMPDIR"
}

function output_version() {
    local VERSIONDATE
    local CONFIG_DIR="$USER_HOME/.config/dropshell-build/" 
    mkdir -p "$CONFIG_DIR"
    VERSIONDATE="$(date +%Y.%m%d.%H%M)"
    echo "$VERSIONDATE" > "$CONFIG_DIR/version" || echo "Error: Failed to write version file to $CONFIG_DIR/version"

}


#----------------------------------------------------------------------------------------------------------
# Main
#----------------------------------------------------------------------------------------------------------

function main() {

    install_packages

    install_musl

    output_version

    echo "Done"
}

main "$@"