#!/usr/bin/env bash
set -euo pipefail

REPO="argotorg/fe"
FE_HOME="${FE_HOME:-$HOME/.fe}"
FE_BIN_DIR="$FE_HOME/bin"
MODIFY_PATH=true
REQUESTED_VERSION=""

# --- Colors ---

setup_colors() {
    if [ -t 1 ]; then
        BOLD="\033[1m"
        GREEN="\033[0;32m"
        YELLOW="\033[0;33m"
        RED="\033[0;31m"
        CYAN="\033[0;36m"
        RESET="\033[0m"
    else
        BOLD=""
        GREEN=""
        YELLOW=""
        RED=""
        CYAN=""
        RESET=""
    fi
}

say() {
    printf "%b\n" "${GREEN}${BOLD}feup${RESET}: $1"
}

warn() {
    printf "%b\n" "${YELLOW}${BOLD}warning${RESET}: $1" >&2
}

err() {
    printf "%b\n" "${RED}${BOLD}error${RESET}: $1" >&2
    exit 1
}

# --- Dependency checks ---

need_cmd() {
    if ! command -v "$1" > /dev/null 2>&1; then
        err "need '$1' (command not found)"
    fi
}

# --- Usage ---

usage() {
    cat <<EOF
feup — The Fe toolchain installer

Usage:
    feup [OPTIONS]

Options:
    -h, --help              Print this message
    -v, --version VERSION   Install a specific version (e.g. v26.0.0-alpha.5)
    --no-modify-path        Don't modify shell profile for PATH
EOF
}

# --- Argument parsing ---

parse_args() {
    while [ $# -gt 0 ]; do
        case "$1" in
            -h|--help)
                usage
                exit 0
                ;;
            -v|--version)
                if [ -z "${2:-}" ]; then
                    err "--version requires a value (e.g. --version v26.0.0-alpha.5)"
                fi
                REQUESTED_VERSION="$2"
                shift
                ;;
            --no-modify-path)
                MODIFY_PATH=false
                ;;
            *)
                warn "unknown option: $1"
                usage
                exit 1
                ;;
        esac
        shift
    done
}

# --- Platform detection ---

detect_platform() {
    local os arch

    os="$(uname -s)"
    case "$os" in
        Linux*)  OS="linux" ;;
        Darwin*) OS="mac" ;;
        *)       err "unsupported operating system: $os" ;;
    esac

    arch="$(uname -m)"
    case "$arch" in
        x86_64|amd64)
            # On Apple Silicon under Rosetta, uname reports x86_64.
            if [ "$OS" = "mac" ] && sysctl -n sysctl.proc_translated 2>/dev/null | grep -q 1; then
                warn "running under Rosetta 2 — installing native arm64 binary"
                ARCH="arm64"
            else
                ARCH="amd64"
            fi
            ;;
        aarch64|arm64)
            ARCH="arm64"
            ;;
        *)  err "unsupported architecture: $arch" ;;
    esac
}

# --- Version resolution ---

resolve_version() {
    if [ -n "$REQUESTED_VERSION" ]; then
        # Ensure version starts with 'v'
        case "$REQUESTED_VERSION" in
            v*) VERSION="$REQUESTED_VERSION" ;;
            *)  VERSION="v${REQUESTED_VERSION}" ;;
        esac
        return
    fi

    say "fetching latest release..."

    local curl_args=(-sL --fail)
    if [ -n "${GITHUB_TOKEN:-}" ]; then
        curl_args+=(-H "Authorization: token $GITHUB_TOKEN")
    fi

    # Get the most recent release (including pre-releases) via the API
    local api_response
    api_response=$(curl "${curl_args[@]}" "https://api.github.com/repos/${REPO}/releases?per_page=1") || {
        err "failed to fetch release info from GitHub. If rate-limited, set GITHUB_TOKEN"
    }

    if command -v jq >/dev/null 2>&1; then
        VERSION=$(printf '%s' "$api_response" | jq -r 'map(select(.draft == false))[0].tag_name // empty')
    else
        VERSION=$(printf '%s' "$api_response" | grep -o '"tag_name":[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"tag_name":[[:space:]]*"//;s/"//')
    fi

    if [ -z "$VERSION" ]; then
        err "could not determine latest version from GitHub API"
    fi
}

# --- Download ---

download_fe() {
    local asset_name="fe_${OS}_${ARCH}"
    local url="https://github.com/${REPO}/releases/download/${VERSION}/${asset_name}"

    say "installing Fe ${CYAN}${VERSION}${RESET}"
    say "  platform: ${CYAN}${OS}_${ARCH}${RESET}"
    say "  url: ${CYAN}${url}${RESET}"

    mkdir -p "$FE_BIN_DIR"

    local tmp_file
    tmp_file=$(mktemp)
    trap 'rm -f "$tmp_file"' EXIT

    local curl_args=(-L --fail --progress-bar -o "$tmp_file")
    if [ -n "${GITHUB_TOKEN:-}" ]; then
        curl_args+=(-H "Authorization: token $GITHUB_TOKEN")
    fi

    curl "${curl_args[@]}" "$url" || {
        rm -f "$tmp_file"
        err "download failed — check that version '${VERSION}' exists and has an asset for ${OS}_${ARCH}
  url: ${url}"
    }

    chmod +x "$tmp_file"

    # macOS quarantines binaries downloaded via curl; remove the flag so the
    # binary can execute without Gatekeeper killing it (Abort trap: 6).
    if [ "$OS" = "mac" ]; then
        xattr -d com.apple.quarantine "$tmp_file" 2>/dev/null || true
    fi

    mv "$tmp_file" "$FE_BIN_DIR/fe"
    trap - EXIT

    say "  installed to: ${CYAN}${FE_BIN_DIR}/fe${RESET}"
}

# --- Install feup itself ---

install_feup() {
    # Place this script into FE_BIN_DIR so `feup` is available for future updates.
    local target="$FE_BIN_DIR/feup"
    local self
    local script_ref="${VERSION}"
    local script_url
    local fallback_url
    self="$(cd "$(dirname "$0")" 2>/dev/null && pwd)/$(basename "$0")"

    if [ -f "$self" ]; then
        # Running from a file — copy it (unless it IS the target already).
        local self_abs target_abs
        self_abs="$(cd "$(dirname "$self")" && pwd -P)/$(basename "$self")"
        target_abs="$(cd "$(dirname "$target")" 2>/dev/null && pwd -P)/$(basename "$target")" 2>/dev/null || true
        if [ "$self_abs" = "$target_abs" ]; then
            return
        fi
        cp "$self" "$target"
    else
        # Running via pipe (curl | bash) — prefer matching version, then fall back to master.
        script_url="https://raw.githubusercontent.com/${REPO}/${script_ref}/feup/feup.sh"
        fallback_url="https://raw.githubusercontent.com/${REPO}/master/feup/feup.sh"
        say "downloading feup script (${script_ref})..."
        local curl_args=(-fsSL -o "$target")
        if [ -n "${GITHUB_TOKEN:-}" ]; then
            curl_args+=(-H "Authorization: token $GITHUB_TOKEN")
        fi
        if ! curl "${curl_args[@]}" "$script_url"; then
            warn "could not download feup script from ${script_url}"
            if [ "$script_ref" != "main" ]; then
                say "falling back to feup script (master)..."
                if ! curl "${curl_args[@]}" "$fallback_url"; then
                    rm -f "$target"
                    warn "could not download feup script from ${fallback_url} — 'feup' command won't be available"
                    return 0
                fi
            else
                rm -f "$target"
                warn "'feup' command won't be available"
                return 0
            fi
        fi
    fi

    chmod +x "$target"
}

# --- PATH configuration ---

create_env_file() {
    local env_file="$FE_HOME/env"

    cat > "$env_file" <<ENVEOF
# Fe toolchain PATH setup (managed by feup)
case ":\${PATH}:" in
    *":${FE_BIN_DIR}:"*) ;;
    *) export PATH="${FE_BIN_DIR}:\$PATH" ;;
esac
ENVEOF
}

modify_shell_profile() {
    if [ "$MODIFY_PATH" != true ]; then
        return
    fi

    local source_line=". \"$FE_HOME/env\""
    local modified=false
    local shell_name

    shell_name="$(basename "${SHELL:-/bin/sh}")"

    # Determine which profile files to modify
    local profiles=()
    case "$shell_name" in
        zsh)
            profiles+=("$HOME/.zshenv")
            ;;
        bash)
            # Cover both login and interactive shells when these files exist.
            if [ -f "$HOME/.bash_profile" ]; then
                profiles+=("$HOME/.bash_profile")
            fi
            if [ -f "$HOME/.bashrc" ]; then
                profiles+=("$HOME/.bashrc")
            fi
            if [ "${#profiles[@]}" -eq 0 ]; then
                if [ -f "$HOME/.profile" ]; then
                    profiles+=("$HOME/.profile")
                else
                    # No existing profile — create .bashrc
                    profiles+=("$HOME/.bashrc")
                fi
            fi
            ;;
        fish)
            # Fish uses a different syntax
            local fish_conf_dir="$HOME/.config/fish/conf.d"
            mkdir -p "$fish_conf_dir"
            local fish_conf="$fish_conf_dir/fe.fish"
            if [ ! -f "$fish_conf" ] || ! grep -qF "$FE_BIN_DIR" "$fish_conf" 2>/dev/null; then
                cat > "$fish_conf" <<FISHEOF
# Fe toolchain PATH setup (managed by feup)
if not contains "$FE_BIN_DIR" \$PATH
    set -gx PATH "$FE_BIN_DIR" \$PATH
end
FISHEOF
                modified=true
                say "  modified: ${CYAN}${fish_conf}${RESET}"
            fi
            return
            ;;
        *)
            profiles+=("$HOME/.profile")
            ;;
    esac

    # Remove duplicates
    local unique_profiles=()
    local seen=""
    for p in "${profiles[@]}"; do
        case "$seen" in
            *"|$p|"*) ;;
            *)
                seen="${seen}|$p|"
                unique_profiles+=("$p")
                ;;
        esac
    done

    for profile in "${unique_profiles[@]}"; do
        if [ -f "$profile" ] && grep -qF "$FE_HOME/env" "$profile" 2>/dev/null; then
            continue
        fi
        printf '\n# Fe toolchain\n%s\n' "$source_line" >> "$profile"
        modified=true
        say "  modified: ${CYAN}${profile}${RESET}"
    done

    if [ "$modified" = true ]; then
        say ""
        say "restart your shell or run:"
        say "  ${CYAN}source \"$FE_HOME/env\"${RESET}"
    fi
}

# --- Main ---

main() {
    setup_colors
    parse_args "$@"

    need_cmd curl
    need_cmd chmod
    need_cmd mkdir
    need_cmd uname

    printf "\n"
    say "${BOLD}feup${RESET} — the Fe toolchain installer"
    printf "\n"

    detect_platform
    resolve_version
    download_fe
    install_feup
    create_env_file
    modify_shell_profile

    printf "\n"
    say "${GREEN}done!${RESET} Fe ${CYAN}${VERSION}${RESET} is installed at ${CYAN}${FE_BIN_DIR}/fe${RESET}"

    # Verify the installation
    if "$FE_BIN_DIR/fe" --version > /dev/null 2>&1; then
        local installed_version
        installed_version=$("$FE_BIN_DIR/fe" --version 2>&1 || true)
        say "  ${installed_version}"
    fi

    printf "\n"
}

main "$@"