zpi/zrep

#!/usr/bin/zsh

setopt extendedglob

VERSION="0.0.7" # Fri-2024-04-05
ZREP="Zsh Repository Tool"
# Define the default path to .zreprc
ZREP_CONFIG="${HOME}/.zreprc"

function zrep_fpath() {
    local base_dir="${1}"
    local mode="${2:-generic}"  # Default mode is 'generic'

    # Ensure globbing finds dotfiles and nullglob avoids empty directory issues
    setopt local_options dotglob nullglob

    # Check if the base directory exists
    if [[ ! -d "${base_dir}" ]]; then
        echo "Error: Base directory '${base_dir}' does not exist."
        return 1
    fi

    if [[ "${mode}" == "zrep_load" ]]; then
        # Specific mode for first_letter/author/script structure
        for one_char_dir in ${base_dir}/?; do
            [[ -d "${one_char_dir}" ]] || continue

            for script_dir in ${one_char_dir}/*/*(/); do
                local script_name=$(basename "${script_dir}")
                local matching_files=("${script_dir}/${script_name}".*)

                if (( ${#matching_files} )); then
                    fpath+=("${script_dir}")
                fi
            done
        done
    else
        # Generic mode for any directory containing at least one file
        for dir in ${base_dir}/**/*(/N); do
            if [[ -n $(ls -A "${dir}/") ]]; then
                fpath+=("${dir}")
            fi
        done
    fi
}

if [[ ${1} != "init" ]]; then
        zrep_fpath ${HOME}/.zrep/functions
        autoload -Uz zini
fi

# Define a list of colors available to use in themes
typeset -A base_colors=(
    [green]="\033[0;32m"
    [yellow]="\033[1;33m"
    [red]="\033[0;31m"
    [bold_yellow]="\033[1;33m"
    [magenta]="\033[0;35m"
    [white]="\033[1;37m"
    [green_bg]="\033[42m"
    [white_on_green]="\033[1;37m\033[42m" # Combined color
    [end]="\033[0m"
    [black]="\033[0;30m"
    [blue]="\033[0;34m"
    [cyan]="\033[0;36m"
    [bold_black]="\033[1;30m"
    [bold_red]="\033[1;31m"
    [bold_green]="\033[1;32m"
    [bold_blue]="\033[1;34m"
    [bold_magenta]="\033[1;35m"
    [bold_cyan]="\033[1;36m"
    [bold_white]="\033[1;37m"
    [black_bg]="\033[40m"
    [red_bg]="\033[41m"
    [yellow_bg]="\033[43m"
    [blue_bg]="\033[44m"
    [magenta_bg]="\033[45m"
    [cyan_bg]="\033[46m"
    [white_bg]="\033[47m"
    [underline]="\033[4m"
    [italic]="\033[3m"
)

# Define the global associative array to hold the current theme
declare -A current_theme

zrep_load_theme() {
  local theme_name="$1"
  local theme_file="${config[main_zrep_install_dir]}/themes/${theme_name}"

  if [[ ! -f "$theme_file" ]]; then
    echo "Error: Theme file for '${theme_name}' not found. Falling back to the 'classic' theme."
    theme_file="${config[main_zrep_install_dir]}/themes/classic"
  fi

  # Source the theme file, which should define 'theme_colors'
  source "$theme_file"

  # Copy 'theme_colors' to 'current_theme'
  for key value in ${(kv)theme_colors}; do
    current_theme[$key]="$value"
  done
}

function zrep_main_version_string() {
  echo "${base_colors[bold_black]}${base_colors[white_bg]} ${ZREP} ${base_colors[end]}${base_colors[bold_white]}${base_colors[black_bg]} ${VERSION} ${base_colors[end]}"
}

function zrep_version() {
  zrep_msg info "\nCreated by kekePower - 2024"
  zrep_msg info "License: MIT"
  zrep_msg info "https://git.kekepower.com/kekePower/zrep/"
  zrep_msg info "Please see '${base_colors[${current_theme[help]}]}${ZSH_SCRIPT:t} help${base_colors[end]}${base_colors[${current_theme[info]}]}' for more info${base_colors[end]}"
  exit
}

# This function is used to display messages and use colors
# from the loaded theme.
function zrep_msg() {
    local msg_type="$1"
    local message="$2"
    local color="${base_colors[end]}" # Default color is NONE

    # Retrieve the color key from the current theme
    local theme_color_key="${current_theme[$msg_type]}"

    # Check if a valid color was found based on the key
    if [[ -n "${base_colors[$theme_color_key]}" ]]; then
        color="${base_colors[$theme_color_key]}"
    else
        # Handle invalid theme color key if needed
        echo "Warning: Theme color key '$theme_color_key' not found. Using default." >&2
    fi

    printf "%b\n" "${color}${message}${base_colors[end]}"
}

#################################################################################################
# Function to URL-encode strings in Zsh
zrep_search_url_encode() {
    local string="${1}"
    local strlen=${#string}
    local encoded=""

    for (( pos=0 ; pos<strlen ; pos++ )); do
        c=${string:$pos:1}
        case "$c" in
            [-_.~a-zA-Z0-9] ) o="${c}" ;;
            * )               printf -v o '%%%02x' "'$c"
        esac
        encoded+="${o}"
    done

    echo "${encoded}"
    # This will output the URL-encoded string
}

# Function to perform a search query and process JSON response
zrep_search() {
    local searchTerm="${@}"

    local encodedSearch=$(zrep_search_url_encode "${searchTerm}")

    # Use the global_repo_url from the config associative array
    local response=$(curl -s -A "zrep ${VERSION} (curl)" "${config[global_repo_url]}/find.php?s=${encodedSearch}")

    # Determine if the JSON response is an object indicating "No scripts found"
    local jsonType=$(echo "$response" | jq -r 'type')

    zrep_msg std "\nSearch results:"
    if [[ "$jsonType" == "object" ]]; then
        # Assuming an object type indicates a message field exists
        local message=$(echo "$response" | jq -r '.message')
        echo "$message"
        return 0
    elif [[ "$jsonType" == "array" ]]; then
        # It's an array, process each item
        echo "$response" | jq -c '.[]' | while IFS= read -r line; do
            local script=$(echo "$line" | jq -r '.script')
            local description=$(echo "$line" | jq -r '.description')
            local url=$(echo "$line" | jq -r '.url')

            # You can process these variables further as needed
            zrep_msg other " * $script"
            zrep_msg sub " - Description: $description"
            zrep_msg sub " - $url"
            # echo "-------------------------------------"
        done
    else
        echo "Unexpected JSON format."
        return 1
    fi
}

############################################################################################

# Function to check if a given string exists in ~/.zshrc
function zrep_find_string() {
  local searchString="$1"
  local found=0

  while IFS= read -r line || [[ -n $line ]]; do
    if [[ "$line" == *"$searchString"* ]]; then
      found=1
      break
    fi
  done < "${HOME}/.zshrc"

  echo $found
}

function zrep_check_for_deps() {
    # Array of required external programs
    local required_programs=('jq' "${config[global_downloader]}")

    # Iterate over the array
    for program in "${required_programs[@]}"; do
        # Check if the program is available in the system's PATH
        if ! command -v "$program" &> /dev/null; then
            # Program not found, display a message
            echo "Required program not found: $program"
        fi
    done
}

# The first step after downloading zrep.
# Here we create the default file and directory structure
function zrep_init() {
    local zshrc_file="${HOME}/.zshrc"
    local zrep_addons="${HOME}/.zrep_addons"
    local install_dir

    # Check if .zreprc exists
    if [[ ! -f ${ZREP_CONFIG} ]]; then
        echo "${ZREP_CONFIG} not found. Creating it..."
        # Prompt user for install directory
        read "install_dir?Enter zrep installation directory [${HOME}/.zrep]: "
        install_dir=${install_dir:-"${HOME}/.zrep"}
        mkdir -p ${install_dir}
        read "downloader?Choose command to download packages [curl, wget, wget2]: "
        if [[ ${downloader} != curl && ${downloader} != wget && ${downloader} != wget2 ]]; then
            echo "Invalid choice: '$downloader'. Try again."
            read "downloader?Choose command to download packages [curl, wget, wget2] "
            if [[ ${downloader} != curl && ${downloader} != wget && ${downloader} != wget2 ]]; then
                echo "Invalid choice: '$downloader'. Exiting."
                exit
            fi
        fi

        # Write to .zreprc
        cat > "${ZREP_CONFIG}" <<EOF
[main]
zrep_install_dir = ${install_dir}

[global]
repo_url = https://zrep.kekepower.com
theme = classic
downloader = ${downloader}
EOF
    echo "The file '${ZREP_CONFIG}' has been created."
    else
        zrep_fpath ${HOME}/.zrep/functions
        autoload -Uz zini
        echo "Loading configuration from ${ZREP_CONFIG}"
        zini ${ZREP_CONFIG}
        # install_dir=${config[main_zrep_install_dir]}
    fi

    if [[ $(zrep_find_string zini) -eq 0 ]]; then
        mkdir -p "${install_dir}/functions/zini"
        zrep_global_downloader https://raw.githubusercontent.com/kekePower/zini/main/zini -o "${install_dir}/functions/zini/zini"
        echo "Adding 'zini' path to fpath in ${zshrc_file}"
        echo "fpath=(${install_dir}/functions/zini \$fpath)" >> ${zshrc_file}
        autoload -Uz zini
    fi

    # Check if .zshrc already sources .zrep_addons, if not, add it
    if [[ $(zrep_find_string "source ${zrep_addons}") -eq 0 ]]; then
        echo "Adding source command for .zrep_addons to .zshrc..."
        echo "source ${zrep_addons}" >> "${zshrc_file}"
    fi

    # Create or update the .zrep_addons file
    if [[ ! -f ${zrep_addons} ]]; then
        echo "Creating file ${zrep_addons}..."
        touch ${install_dir}/.addons
        cat > "${zrep_addons}" <<EOF
# Source the .addons file from the zrep installation directory
source "${install_dir}/.addons"

# If addons array is defined and not empty, add its elements to fpath
if [[ -n \${addons[@]} ]]; then
    for addon in "\${addons[@]}"; do
        if [[ -d \${addon} ]] && [[ ! " \${fpath[*]} " =~ " \${addon} " ]]; then
            fpath=(\${addon} "\${fpath[@]}")  # Prepend the new addon to fpath
        fi
    autoload -Uz \$(basename \${addon})
    done
else
    echo "zrep: No addons enabled."
fi
EOF
        echo "File .zrep_addons created and configured."
    else
        echo "File .zrep_addons already exists. Review manually if update is needed."
    fi

    if [[ ! -d ${install_dir}/themes ]]; then
        echo "Installing the Classic theme to ${install_dir}/themes"
        mkdir -p ${install_dir}/themes
        zrep_global_downloader https://git.kekepower.com/kekePower/zrep/raw/branch/main/themes/classic -o ${install_dir}/themes/classic
    fi
    echo "zrep initialization complete."
    echo "You should copy 'zrep' to a path in you 'PATH' so that it's accessible."
    echo "For example '${HOME}/bin'"
    echo "Remember to 'source ${zshrc_file}' to load the 'zrep' settings."
}

function zrep_installed_json() {

    # Check if installed.json exists
    if [[ ! -f "${config[main_zrep_install_dir]}/installed.json" ]]; then
        touch ${config[main_zrep_install_dir]}/installed.json
        zrep_msg debug "\nError: installed.json not found."
        return 1
    else
        installed_json="${config[main_zrep_install_dir]}/installed.json"
        export installed_json=${installed_json}
    fi

}

# Function to parse remote JSON data and extract author, script, and version
# and return the correct download url
function zrep_parse_remote() {
    local url="${1}"
    local package="${2}"
    local author_name="${package%%/*}"
    local script_name="${package#*/}"
    local json_data

    # Fetch JSON data from the URL
    json_data=$(zrep_global_downloader "${url}")

    # Directly extract the details based on author_name and script_name
    version=$(echo "${json_data}" | jq -r --arg author_name "$author_name" --arg script_name "$script_name" '.authors[] | select(.name==$author_name) | .scripts[] | select(.name==$script_name) | .version')

    # Check if the dlurl and version are found
    if [[ -n "$version" ]]; then
        # Set the details as global
        #export author="$author_name"
        #export script="$script_name"
        export version
        #export dlurl
    else
        zrep_msg debug "\nPackage ${package} not found.\n"
        exit 1
    fi
}

# Function to write to installed.json after successful install
function zrep_update_installed_json() {
    local author="${1}"
    local script="${2}"
    local version="${3}"
    zrep_installed_json

    # Ensure the JSON file exists and is not empty, creating an empty object if necessary
    if [[ ! -f "${installed_json}" ]] || [[ ! -s "${installed_json}" ]]; then
        echo "{}" > "${installed_json}"
    fi

    # Update or add the script entry
    jq --arg author "$author" --arg script "$script" --arg version "$version" \
'if has($author) then
    .[$author] |= map(if .script == $script then .version = $version else . end) |
    if .[$author] | all(.script != $script) then .[$author] += [{"script": $script, "version": $version}] else . end
else
    .[$author] = [{"script": $script, "version": $version}]
end' "$installed_json" > "$installed_json.tmp" && mv "$installed_json.tmp" "$installed_json"

    zrep_msg info " - Package '$script' by '$author' version $version installed/updated successfully."
}

# Function to list installed packages from installed.json
function zrep_list_installed_packages() {
    zrep_installed_json

    # Check if installed.json exists and is not empty
    if [[ ! -s "${installed_json}" ]]; then
        zrep_msg info "\nNo packages installed."
        return
    fi

    # Parse installed.json and list packages
    zrep_msg sub "\nInstalled packages:"

    # Check if the JSON file is effectively empty ({} or [])
    if jq -e 'if type == "object" then . == {} elif type == "array" then . == [] else false end' "${installed_json}" >/dev/null; then
        zrep_msg info "\nNo packages installed."
        return
    fi

    # Iterate through each author and their packages
    jq -r 'to_entries | .[] | .key as $author | .value[] | "\($author)/\(.script) (\(.version))"' "${installed_json}" | while IFS= read -r package_info; do
        local package_name=$(echo "${package_info}" | cut -d ' ' -f1)  # Extract package name before the version
        local is_active="${base_colors[white]}(${base_colors[end]}${base_colors[bold_red]}Inactive${base_colors[end]}${base_colors[white]})${base_colors[end]}"  # Set default to Inactive

        zmodload zsh/regex
        # Check if the package is active (only modify if active)
        if [[ $(<${config[main_zrep_install_dir]}/.addons) =~ "\b${package_name}\b" ]]; then
            is_active="${base_colors[white]}(${base_colors[end]}${base_colors[bold_green]}Active${base_colors[end]}${base_colors[white]})${base_colors[end]}"
        fi

        zrep_msg info " |> ${package_info} ${is_active}"
    done
}

function zrep_list_package() {
    zrep_installed_json
    local package_names=""

    # Parse installed.json and concatenate package names
    jq -r 'to_entries[] | .key as $author | .value[] | "\($author)/\(.script) (\(.version))"' "${installed_json}" | while IFS= read -r package_info; do
        package_names+="${package_info} "
    done

    # Assuming you want to print out the concatenated package names
    if [[ -n "${package_names}" ]]; then
        zrep_msg info "\nInstalled packages: ${package_names}"
    else
        zrep_msg debug "\nNo packages found."
    fi
}

function zrep_load_config() {

    if [[ ! -x $(which jq) ]]; then
        echo "Error: 'jq' is not installed. Please install jq to continue."
        exit 1
    fi

    if [[ -f "${ZREP_CONFIG}" ]]; then
        zini "${ZREP_CONFIG}"
        zrep_fpath ${config[main_zrep_install_dir]} zrep_load
    else
        echo "${ZREP_CONFIG} not found. Run 'zrep init' to set up."
        exit 1
    fi

}

function zrep_remove_package() {
    local package_name="${1}"
    zrep_installed_json

    local author="${package_name%%/*}"
    local script="${package_name#*/}"

    # Verify if the package is installed and get its version (if any)
    local installed_version=$(jq -r --arg author "$author" --arg script "$script" \
        '.[$author][] | select(.script == $script) | .version' "$installed_json")

    if [[ -z "$installed_version" || "$installed_version" == "null" ]]; then
        zrep_msg debug "\nError: Package '${package_name}' is not installed."
        zrep_msg info "Please see 'zrep list' for installed packages."
        return 1
    fi

    local first_letter="${author:0:1:l}"
    local package_dir="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"

    zrep_msg std "\nFound installed package: $package_name, version: $installed_version"

    # Ask user for confirmation with default response "Y"
    zrep_msg info "Are you sure you want to remove this package? (y/n) [Y]: \c"
    read REPLY
    REPLY=${REPLY:-Y}
    echo

    if [[ "${REPLY}" =~ ^[Yy]$ ]]; then
        # Remove the package directory from disk
        if [[ -d "${package_dir}" ]]; then
            rm -rf "${package_dir}"
        else
            zrep_msg debug "Warning: Package directory '${package_dir}' not found."
        fi

        # Remove the package from installed.json
        jq --arg author "$author" --arg script "$script" \
          '(.[$author] |= map(select(.script != $script))) |
           if .[$author] == [] then del(.[$author]) else . end' \
          "$installed_json" > "$installed_json.tmp" && mv "$installed_json.tmp" "$installed_json"

        zrep_msg sub "Package '${package_name}' successfully removed."
    else
        zrep_msg info "Removal canceled."
    fi
}

function zrep_check_if_installed() {
    local package="${1}"
    zrep_installed_json

    local author_name="${package%%/*}"
    local script_name="${package#*/}"

    # Initialize version to an empty string
    typeset -g installed_version=""

    # Check if the package is already installed and retrieve its version
    installed_version=$(jq -r --arg author "$author_name" --arg script "$script_name" \
        '.[$author][] | select(.script == $script) | .version' "$installed_json")

    if [[ -n "${installed_version}" && "${installed_version}" != "null" ]]; then
        # Package is installed, and version is stored in installed_version
        return 0  # Package is installed
    else
        return 1  # Package is not installed
    fi
}

function zrep_global_downloader() {
    case ${config[global_downloader]} in
        curl)
            dloader="curl -s -A \"zrep ${VERSION} (curl)\""
            ;;
        wget)
            dloader="wget -q -U \"zrep ${VERSION} (wget)\""
            ;;
        wget2)
            dloader="wget2 -q -U \"zrep ${VERSION} (wget2)\""
            ;;
        *)
            echo "Invalid Downloader."
            exit
            ;;
    esac

    eval ${dloader} "${1}"
}

typeset -A updatesAvailable
function zrep_check_for_updates() {

    # Now using a zrep API to fetch the JSON for checking for updates. This _may_ change in the
    # future if the load on the DB gets too high.
    local remoteFile="${config[global_repo_url]}/getver.php"
    # local localFile="${config[main_zrep_install_dir]}/installed.json"
    zrep_installed_json
    local remotePackages=$(zrep_global_downloader "${remoteFile}")

    # Reset global variables
    updatesAvailable=()
    typeset -g updates=false # Global declaration, initializes to false

    # Process updates
    local authorsScripts=$(jq -r '. | to_entries[] | .key as $author | .value[] | "\($author)/\(.script):\(.version)"' "$installed_json")

    for entry in ${(f)authorsScripts}; do
        local author="${entry%%/*}"
        local rest="${entry#*/}"
        local script="${rest%%:*}"
        local installed_version="${rest##*:}"

        local remote_version=$(jq -r --arg author "$author" --arg script "$script" \
                               '.authors[] | select(.name==$author) | .scripts[] | select(.name==$script) | .version' <<<"$remotePackages")

        if [[ "${remote_version}" > "${installed_version}" ]]; then
            updatesAvailable[${author}/${script}]="${remote_version}"
            zrep_msg info "\n${author}/${script} can be updated from ${installed_version} to ${remote_version}"
            updates=true # Mark that updates are available
        fi
    done

    if [[ ${updates} == "false" ]]; then
        zrep_msg info "\nNo updates found."
    fi

}

function zrep_update_package() {
    local specificPackage=${1}
    zrep_check_for_updates

    if [[ -n "${specificPackage}" ]]; then
        # Logic for updating a specific package
        # Assuming specificPackage format is "author/script"
        local version=${updatesAvailable[${specificPackage}]}
        if [[ -n "$version" ]]; then
            local author="${specificPackage%%/*}"
            local script="${specificPackage#*/}"
            local install_pkg="${author}/${script}"
            zrep_install_package u ${install_pkg}
        else
            zrep_msg info "\nNo update available for ${specificPackage}."
        fi
    else
        if [[ ${updates} == "true" ]]; then
            # Prompt the user only if updates are available
            echo "New updates are available. Do you want to proceed with updating? (Y/n): "
            read -q "response?"
            echo # Move to a new line

            # Set the default response to 'Y' if no input is entered
            response=${response:-Y}

            # Proceed with update if the response is 'Y' or 'y'
            if [[ $response =~ ^[Yy]$ ]]; then
                # General update mode: update all packages listed in updatesAvailable
                for package in ${(k)updatesAvailable}; do
                    local author=${package%%/*}
                    local script=${package#*/}
                    local version=${updatesAvailable[${package}]}
                    local install_pkg="${author}/${script}"
                    zrep_install_package u ${install_pkg}
                done
            else
                zrep_msg info "Update canceled."
            fi
        fi
    fi
}

# Enhanced zrep_downloader function with error handling and retry logic.
# It attempts to download a file from a given URL to a specified zip file using curl, wget, or wget2 based on the global configuration.
# This function supports retries and delays between attempts for robust error handling.
#
# Usage: zrep_download_package ZipFile DownloadURL
#
# Parameters:
#   DownloadURL: The URL from which to download the file.
#   ZipFile: The name of the file to save the downloaded content to.

function zrep_download_package() {
  local ZipFile="${1}"
  local DownloadURL="${2}"
  local retries=5
  local delay=5
  local attempt=1
  local downloader=""
  local http_status
  local cmd
  local exit_status

  case "${config[global_downloader]}" in
    curl)
      downloader="curl"
      cmd="curl -L -A \"zrep ${VERSION} (curl)\" -s -o \"$ZipFile\" \"$DownloadURL\" -w \"%{http_code}\""
      ;;
    wget)
      downloader="wget"
      cmd="wget -L -U \"zrep ${VERSION} (wget)\" -q -O \"$ZipFile\" \"$DownloadURL\""
      ;;
    wget2)
      downloader="wget2"
      cmd="wget2 -L -U \"zrep ${VERSION} (wget2)\" -q -O \"$ZipFile\" \"$DownloadURL\""
      ;;
    *)
      zrep_msg debug "Unsupported or unspecified downloader: '${config[global_downloader]}'."
      return 1
      ;;
  esac

  while (( attempt <= retries )); do
    # zrep_msg sub "Attempt $attempt of $retries: Downloading using $downloader..."

    if [[ $downloader == "curl" ]]; then
      http_status=$(eval $cmd)
      exit_status=$?
      # For curl, check HTTP status is 200 and exit status is 0
      if [[ $exit_status -eq 0 && $http_status -eq 200 ]]; then
        # zrep_msg sub "a.Download successful."
        return 0
      fi
    else # wget or wget2
      eval $cmd
      exit_status=$?
      # For wget/wget2, just check exit status is 0
      if [[ $exit_status -eq 0 ]]; then
        # zrep_msg sub "b.Download successful."
        return 0
      fi
    fi
    sleep $delay
    ((attempt++))
  done

  zrep_msg debug "Error: The download failed after $retries attempts."
  return 1
}

# Function to install a package by unzipping it to ${config[main_zrep_install_dir]}
function zrep_install_package() {

    if [[ ${1} == "u" ]]; then
        updates=true
        local package=${2}
        #echo "zrep_install_package: package=$package"
    else
        updates=false
        local package="${1}"
        # Ensure package name is in 'author/package' format
        if [[ ! "${package}" =~ ^.+/[^/]+$ ]]; then
            zrep_msg debug "\nError: Package name must be in 'author/package' format."
            return 1
        fi
        # Call zrep_check_if_installed to check if the package is already installed
        if zrep_check_if_installed "${package}"; then
            zrep_msg debug "\nPackage ${package} is already installed."
            zrep_msg info "Use 'zrep list' to see installed packages."
            return 0
        fi
    fi

    # If not installed, proceed with fetching the package information
    # Using the new zrep API to get the package version
    zrep_parse_remote "${config[global_repo_url]}/getver.php\?p\=${package}" ${package}

    local tmpDir="${config[main_zrep_install_dir]}/tmp"

    mkdir -p "${tmpDir}"

    local zipFile="${tmpDir}/${author}-${script}-${version}.zip"
    dlurl="${config[global_repo_url]}/download/${package}/${version}"
    zrep_download_package "${zipFile}" "${dlurl}"

    unzip -q -o "${zipFile}" -d "${config[main_zrep_install_dir]}"

    if [[ $? -ne 0 ]]; then
        zrep_msg debug "\nError: Failed to unzip the package."
        return 1
    else
        zrep_update_installed_json "${author}" "${script}" "${version}"
    fi

    rm "${zipFile}"
}

# Function to parse installed.json
function zrep_parse_installed_json() {

  zrep_installed_json
  jq -c '.' "${installed_json}"

}

function zrep_parse_package_name() {
    package_name="${1}"
    zrep_installed_json
    author="${package_name%/*}"
    script="${package_name#*/}"
    local first_letter="${author:0:1:l}"
    addon_path="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"

    # Check if the package is installed
    if ! jq -e --arg author "$author" --arg script "$script" '.[$author] | any(.script == $script)' "${installed_json}" &>/dev/null; then
        zrep_msg debug "\nError: Package '${package_name}' is not installed."
        return 1
    fi
}

function zrep_enable() {
    local package_name="${1}"
    zrep_parse_package_name "${package_name}"

    # Initialize addons array if .zrep_addons does not exist
    if [ ! -f "${config[main_zrep_install_dir]}/.addons" ]; then
        addons=()
    else
        # Load existing addons from ${config[main_zrep_install_dir]}/.addons
        source "${config[main_zrep_install_dir]}/.addons"
    fi

    # Check if the addon is already enabled
    local addon_exists=0
    for addon in "${addons[@]}"; do
        if [[ "${addon}" == "${addon_path}" ]]; then
            addon_exists=1
            break
        fi
    done

    if ((addon_exists)); then
        echo "Package '${package_name}' is already enabled."
        return 0
    fi

    # Add addon path to the array
    addons+=("${addon_path}")

    # Reconstruct .zrep_addons file with the updated addons array
    {
        echo "addons=("
        for addon in "${addons[@]}"; do
            echo "  '${addon}'"
        done
        echo ")"
    } > "${config[main_zrep_install_dir]}/.addons"

    zrep_msg info "\nPackage '${package_name}' has been enabled and added to fpath."
    zrep_msg info "You may have to run 'source ~/.zrep_addons' to get access to it."
}

function zrep_disable() {
    local package_name="${1}"
    zrep_parse_package_name "${package_name}"

    # Initialize addons array if .zrep_addons does not exist
    if [ ! -f "${config[main_zrep_install_dir]}/.addons" ]; then
        addons=()
    else
        # Load existing addons from ${config[main_zrep_install_dir]}/.addons
        source "${config[main_zrep_install_dir]}/.addons"
    fi

    # Initialize a new array for addons
    local new_addons=()

    # Flag to check if addon was found and removed
    local found=0

    # Iterate through existing addons
    for addon in "${addons[@]}"; do
        if [[ "${addon}" == "${addon_path}" ]]; then
            found=1
        else
            new_addons+=("${addon}")
        fi
    done

    if ((found == 0)); then
        zrep_msg debug "\nPackage '${package_name}' is not currently enabled."
        return 0
    fi

    # Reconstruct .zrep_addons file with the new addons array
    {
        echo "addons=("
        for addon in "${new_addons[@]}"; do
            echo "  '${addon}'"
        done
        echo ")"
    } > ${config[main_zrep_install_dir]}/.addons

    zrep_msg info "\nPackage '${package_name} (${script})' has been disabled and removed from fpath."
    zrep_msg info "You may have to run 'source ~/.zrep_addons' to remove it from your shell."
}

# Help function to display available options
function zrep_help() {

  zrep_msg sub "\nUsage: zrep <command> [arguments]"
  zrep_msg info "Available commands:"
    if [[ ! -f ${ZREP_CONFIG} ]]; then
        zrep_msg info "  init: Initialize zrep"
    fi
  zrep_msg info "  install (i) <author/package>:\t\t\tInstall a package"
  zrep_msg info "  remove (rm, delete, del) <author/package>:\tRemove a package"
  zrep_msg info "  update (u) <author/package>:\t\t\tUpdate zrep package"
  zrep_msg info "  enable <author/package>:\t\t\tEnable zrep package"
  zrep_msg info "  disable <author/package>:\t\t\tDisable zrep package"
  zrep_msg info "  search 'search term':\t\t\t\tSearch for authors, packages or description"
  zrep_msg info "  version:\t\t\t\t\tDisplay zrep version"
  zrep_msg info "  list:\t\t\t\t\t\tList installed packages"
  zrep_msg info "  <author/package> help:\t\t\tDisplay help for package (if available)"

}

function zrep_package_info() {
  local package_name="${1}"
  zrep_installed_json # Ensure installed.json is loaded and available

  # Parse the package name to extract author and script
  local author="${package_name%/*}"
  local script="${package_name#*/}"
  local first_letter="${author:0:1:l}" # Get the first letter of the author's name to construct the URL

  # Check if the package is installed and get its version
  if zrep_check_if_installed "${package_name}"; then
    local installed_version="${installed_version}" # This variable is set by zrep_check_if_installed
    local package_dir="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}"
    local zrep_url="${config[global_repo_url]}/${first_letter}/${author}/${script}"

    # Display package information
    zrep_msg info "\nAuthor/Package:\t\t${author}/${script}"
    zrep_msg info "Version installed:\t${installed_version}"
    zrep_msg info "Location on disk:\t${package_dir}"
    zrep_msg info "zrep URL:\t\t${zrep_url}"
  else
    zrep_msg debug "\nPackage '${package_name}' is not installed."
  fi
}

function zrep_read_usage() {
    local package_name="${1}"
    # Parse the package name to extract author and script
    local author="${package_name%/*}"
    local script="${package_name#*/}"
    local first_letter="${author:0:1:l}"

    # Construct the path to the USAGE file
    local usage_file="${config[main_zrep_install_dir]}/${first_letter}/${author}/${script}/USAGE"

    # Check if the USAGE file exists
    if [[ -f "${usage_file}" ]]; then
        # Display the content of the USAGE file
        zrep_msg sub "\n${package_name}:"
        local usage_buffer=$(<${usage_file})
        zrep_msg info "${usage_buffer}"
    else
        zrep_msg debug "No USAGE file found for package '${package_name}'."
    fi
}

function main() {

    zrep_main_version_string

    if [[ ${1} != "init" ]]; then
        zrep_load_config ${1}
        zrep_load_theme ${config[global_theme]}
    fi

    # Check if the second argument is "help" and the first argument is not empty
    if [[ "${2}" == "help" && -n "${1}" ]]; then
        zrep_read_usage "${1}"
        exit
    fi

    # Example command handling structure
    case "${1}" in
        init)
    	    zrep_init
            zrep_check_for_deps
    	    exit
            ;;
        search | s | find)
            zrep_search "${@:2}"
            ;;
        install | i)
            zrep_install_package ${2}
            ;;
        remove | delete | rm | del)
            # Parse the command argument to extract the package name
            zrep_remove_package_name="${2:-}"
            if [[ -z "${zrep_remove_package_name}" ]]; then
                zrep_msg info "\nUsage: zrep ${1} author/package"
            else
                zrep_remove_package "${zrep_remove_package_name}"
            fi
            ;;
        update | u)
            zrep_update_package ${2}
            ;;
        version | -v | --version)
            zrep_version
            ;;
        list)
            zrep_list_installed_packages
            ;;
        help | -h | --help)
            zrep_help
            ;;
        enable)
            zrep_enable ${2}
            ;;
        disable)
            zrep_disable ${2}
            ;;
        info)
            zrep_package_info ${2}
            ;;
        *)
            zrep_help
            ;;
    esac
}

# Call main with all passed arguments
main "$@"