#!/usr/bin/env bash
# ────────────────────────────────────────────────────────────────────────────────
#  osmose installer
#
#  Usage:
#    curl -fsSL https://get.osmose.sh/install.sh | bash
#    wget -qO- https://get.osmose.sh/install.sh | bash
#
#  Environment variables:
#    OSMOSE_VERSION      Specific version to install (default: latest)
#    OSMOSE_INSTALL_DIR  Installation directory (default: ~/.local/bin)
#    OSMOSE_NO_EDITOR    Skip editor plugin installation if set
#    NO_COLOR              Disable colored output if set
# ────────────────────────────────────────────────────────────────────────────────

set -euo pipefail

GET_BASE="${OSMOSE_GET_BASE:-https://get.osmose.sh}"
CANONICAL_RELEASE_BASE="https://cdn.osmose.sh/release/"
RELEASE_BASE="${OSMOSE_CDN_BASE:-https://cdn.osmose.sh}/release"
BINARY_NAME="osmose"
REPO_URL="https://github.com/zacariec/osmose.git"
DEFAULT_INSTALL_DIR="$HOME/.local/bin"
INSTALL_DIR="${OSMOSE_INSTALL_DIR:-$DEFAULT_INSTALL_DIR}"

USE_COLOR=0
INTERACTIVE=0
TERM_COLS=80
TERM_LINES=24
GRID_W=55
GRID_H=11
ORBIT_RX=18
ORBIT_RY=4
RING_RX=7.5
RING_RY=2.4
STAR_COUNT=35
TOTAL_FRAME_LINES=0
FRAME_RESERVED=0
ANIM_FRAME=0

TEMP_DIR=""
TEMP_BINARY=""
TEMP_VSIX=""
PLATFORM=""
VERSION=""
BINARY_SUFFIX=""
TARGET_BINARY=""
PATH_NOTICE=""

declare -a STEP_LABELS=()
declare -a STEP_STATUS=()
declare -a STEP_RESULTS=()
declare -a BANNER=()
declare -a SPIN=()

RST=""
BOLD=""
DIM=""
RED=""
GREEN=""
YELLOW=""
BLUE=""
MAGENTA=""
CYAN=""
WHITE=""
BWHT=""
DMAG=""
DWHT=""
CYN=""
DCYN=""
GRN=""
DGRN=""
CL=""
UP=""
HIDE=""
SHOW=""

LAST_STEP_STATUS=""
LAST_STEP_MESSAGE=""

init_palette() {
  if [[ -t 1 ]] && [[ -z "${NO_COLOR:-}" ]]; then
    USE_COLOR=1
  fi

  if [[ "$USE_COLOR" -eq 1 ]]; then
    local E=$'\033'
    RST="${E}[0m"
    BOLD="${E}[1m"
    DIM="${E}[2m"
    RED="${E}[31m"
    GREEN="${E}[32m"
    YELLOW="${E}[33m"
    BLUE="${E}[34m"
    MAGENTA="${E}[35m"
    CYAN="${E}[36m"
    WHITE="${E}[97m"
    BWHT="${E}[1;97m"
    DMAG="${E}[2;35m"
    DWHT="${E}[2;37m"
    CYN="${E}[1;36m"
    DCYN="${E}[2;36m"
    GRN="${E}[32m"
    DGRN="${E}[2;32m"
    CL="${E}[2K"
    UP="${E}[A"
    HIDE="${E}[?25l"
    SHOW="${E}[?25h"
  fi

  if [[ "$USE_COLOR" -eq 1 ]] && [[ -t 1 ]] && [[ "${TERM:-}" != "dumb" ]]; then
    INTERACTIVE=1
  fi
}

init_banner() {
  BANNER=(
    "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░"
    "░░░██████╗░░██████╗███╗░░░███╗░██████╗░██████╗███████╗░░"
    "░░██╔═══██╗██╔════╝████╗░████║██╔═══██╗██╔══██╗██╔════╝░"
    "░░██║░░░██║╚█████╗░██╔████╔██║██║░░░██║██████╔╝█████╗░░░"
    "░░██║░░░██║░╚═══██╗██║╚██╔╝██║██║░░░██║██╔══██╗██╔══╝░░░"
    "░░╚██████╔╝██████╔╝██║░╚═╝░██║╚██████╔╝██║░░██║███████╗░"
    "░░░╚═════╝░╚═════╝░╚═╝░░░░░╚═╝░╚═════╝░╚═╝░░╚═╝╚══════╝░"
  )
  SPIN=(⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏)
}

init_steps() {
  STEP_LABELS=(
    "Detecting platform"
    "Checking dependencies"
    "Resolving version"
    "Downloading binary"
    "Verifying checksum"
    "Installing to ${INSTALL_DIR}"
    "Installing VSCode extension"
    "Installing Neovim plugin"
    "Verifying installation"
  )

  STEP_STATUS=()
  STEP_RESULTS=()
  local i
  for ((i = 0; i < ${#STEP_LABELS[@]}; i++)); do
    STEP_STATUS+=("pending")
    STEP_RESULTS+=("${STEP_LABELS[$i]}")
  done
}

up() {
  printf '%s[%dA' $'\033' "$1"
}

init_terminal_metrics() {
  TERM_COLS=$(tput cols 2>/dev/null || echo 80)
  TERM_LINES=$(tput lines 2>/dev/null || echo 24)

  local max_gw=$((TERM_COLS - 8))
  (( max_gw > 55 )) && max_gw=55
  (( max_gw < 20 )) && max_gw=20
  GRID_W=$max_gw

  local max_gh=$((TERM_LINES - (${#STEP_LABELS[@]} + 8)))
  (( max_gh > 11 )) && max_gh=11
  (( max_gh < 5 )) && max_gh=5
  GRID_H=$max_gh

  ORBIT_RX=$(awk "BEGIN{printf \"%.1f\", $GRID_W * 18 / 55}")
  ORBIT_RY=$(awk "BEGIN{printf \"%.1f\", $GRID_H * 4 / 11}")
  RING_RX=$(awk "BEGIN{printf \"%.1f\", $GRID_W * 7.5 / 55}")
  RING_RY=$(awk "BEGIN{printf \"%.1f\", $GRID_H * 2.4 / 11}")
  STAR_COUNT=$(( GRID_W * GRID_H * 35 / (55 * 11) ))
  (( STAR_COUNT < 8 )) && STAR_COUNT=8

  TOTAL_FRAME_LINES=$((GRID_H + ${#STEP_LABELS[@]} + 8))
}

log_done()  { printf "%s  %s[✓]%s %s\n" "$CL" "$GREEN" "$RST" "$1"; }
log_info()  { printf "%s  %s[i]%s %s\n" "$CL" "$BLUE" "$RST" "$1"; }
log_warn()  { printf "%s  %s[!]%s %s\n" "$CL" "$YELLOW" "$RST" "$1"; }
log_error() { printf "%s  %s[✗]%s %s\n" "$CL" "$RED" "$RST" "$1" >&2; }

prepare_temp_dir() {
  TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/osmose-install.XXXXXX")
  TEMP_BINARY="${TEMP_DIR}/${BINARY_NAME}"
  TEMP_VSIX="${TEMP_DIR}/osmose-liquid.vsix"
}

cleanup() {
  printf '%s' "$SHOW"
  tput cnorm 2>/dev/null || true
  [[ -n "$TEMP_DIR" ]] && rm -rf "$TEMP_DIR"
}
trap cleanup EXIT

render_frame() {
  local tick=$1 mode=${2:-normal}
  awk -v tick="$tick" -v mode="$mode" \
      -v W="$GRID_W" -v H="$GRID_H" \
      -v ORX="$ORBIT_RX" -v ORY="$ORBIT_RY" \
      -v RRX="$RING_RX" -v RRY="$RING_RY" \
      -v NSTARS="$STAR_COUNT" \
      -v C_RST="$RST" -v C_DMAG="$DMAG" -v C_MAG="$MAGENTA" \
      -v C_CYN="$CYN" -v C_DCYN="$DCYN" -v C_BWHT="$BWHT" \
      -v C_GRN="$GRN" -v C_DGRN="$DGRN" -v CLR="$CL" '
  BEGIN {
    cx = int(W / 2); cy = int(H / 2)
    PI = atan2(0, -1)

    for (i = 0; i < NSTARS; i++) {
      star_x[i] = int(fhash(i * 7 + 1) * W)
      star_y[i] = int(fhash(i * 13 + 3) * H)
      star_ph[i] = fhash(i * 17 + 5) * PI * 2
      star_sp[i] = 0.04 + fhash(i * 23 + 7) * 0.06
    }

    for (y = 0; y < H; y++)
      for (x = 0; x < W; x++) {
        g[y, x] = " "
        tp[y, x] = 0
      }

    if (mode == "success") success(); else normal()

    for (y = 0; y < H; y++) {
      line = CLR "    "
      prev = -1
      for (x = 0; x < W; x++) {
        ct = tp[y, x]
        if (ct != prev) { line = line color(ct); prev = ct }
        line = line g[y, x]
      }
      print line C_RST
    }
  }

  function fhash(n,    x) {
    x = sin(n * 127.1 + 311.7) * 43758.5453
    return x - int(x) + (x < int(x) ? 1 : 0)
  }
  function rnd(v) { return int(v + (v < 0 ? -0.5 : 0.5)) }

  function color(t) {
    if (mode == "success") {
      if (t == 5) return C_GRN
      if (t == 2) return C_DGRN
      if (t == 1) return C_DMAG
      return C_RST
    }
    if (t == 1) return C_DMAG
    if (t == 2) return C_MAG
    if (t == 3) return C_CYN
    if (t == 4) return C_DCYN
    if (t == 5) return C_BWHT
    return C_RST
  }

  function normal(    i, b, sx, sy, angle, tr, ta, tx, ty, px, py, pulse, ci, a, rx, ry) {
    for (i = 0; i < NSTARS; i++) {
      b = sin(tick * star_sp[i] + star_ph[i])
      if (b > 0.2) {
        sx = star_x[i]; sy = star_y[i]
        if (sx >= 0 && sx < W && sy >= 0 && sy < H) {
          if (b > 0.7)      { g[sy,sx] = "✦"; tp[sy,sx] = 2 }
          else if (b > 0.4) { g[sy,sx] = "·"; tp[sy,sx] = 1 }
          else              { g[sy,sx] = "∙"; tp[sy,sx] = 1 }
        }
      }
    }
    for (i = 0; i < 3; i++) {
      angle = tick * 0.06 + i * PI * 2 / 3
      for (tr = 1; tr <= 3; tr++) {
        ta = angle - tr * 0.18
        tx = rnd(cx + cos(ta) * ORX)
        ty = rnd(cy + sin(ta) * ORY)
        if (tx >= 0 && tx < W && ty >= 0 && ty < H) {
          if (tr == 1)      g[ty,tx] = "∘"
          else if (tr == 2) g[ty,tx] = "·"
          else              g[ty,tx] = "∙"
          tp[ty,tx] = 4
        }
      }
      px = rnd(cx + cos(angle) * ORX)
      py = rnd(cy + sin(angle) * ORY)
      if (px >= 0 && px < W && py >= 0 && py < H) {
        g[py,px] = "●"; tp[py,px] = 3
      }
    }
    pulse = sin(tick * 0.12)
    ci = int(((sin(tick * 0.08) + 1) / 2) * 4) % 4
    if (ci == 0)      g[cy,cx] = "◇"
    else if (ci == 1) g[cy,cx] = "◈"
    else if (ci == 2) g[cy,cx] = "◆"
    else              g[cy,cx] = "◈"
    tp[cy,cx] = 5
    if (pulse > 0) {
      for (i = 0; i < 8; i++) {
        a = i * PI * 2 / 8 + tick * 0.02
        rx = rnd(cx + cos(a) * RRX)
        ry = rnd(cy + sin(a) * RRY)
        if (rx >= 0 && rx < W && ry >= 0 && ry < H && tp[ry,rx] == 0) {
          g[ry,rx] = (pulse > 0.5) ? "·" : "∙"
          tp[ry,rx] = 1
        }
      }
    }
  }

  function success(    i, b, sx, sy, r, rp, radius, opacity, d, a, rx, ry) {
    for (i = 0; i < NSTARS; i++) {
      b = sin(tick * 0.03 + star_ph[i])
      if (b > 0.5) {
        sx = star_x[i]; sy = star_y[i]
        if (sx >= 0 && sx < W && sy >= 0 && sy < H) {
          g[sy,sx] = "·"; tp[sy,sx] = 1
        }
      }
    }
    for (r = 0; r < 3; r++) {
      rp = (tick * 0.08 + r * 2.1)
      rp = rp - int(rp / 6) * 6
      radius = rp * 3
      opacity = 1 - rp / 6
      if (opacity > 0.2) {
        for (d = 0; d < 12; d++) {
          a = d * PI * 2 / 12
          rx = rnd(cx + cos(a) * radius * 2.2 * W / 55)
          ry = rnd(cy + sin(a) * radius * 0.8 * H / 11)
          if (rx >= 0 && rx < W && ry >= 0 && ry < H) {
            if (opacity > 0.6) { g[ry,rx] = "✦"; tp[ry,rx] = 2 }
            else               { g[ry,rx] = "·"; tp[ry,rx] = 1 }
          }
        }
      }
    }
    g[cy,cx] = "✓"; tp[cy,cx] = 5
  }
  ' </dev/null
}

completed_step_count() {
  local completed=0
  local status
  for status in "${STEP_STATUS[@]}"; do
    case "$status" in
      success|warning|skipped|error) completed=$((completed + 1)) ;;
    esac
  done
  echo "$completed"
}

render_progress() {
  local completed
  completed=$(completed_step_count)
  local bar_w=30
  local percent=$((completed * 100 / ${#STEP_LABELS[@]}))
  local filled=$((percent * bar_w / 100))
  local empty=$((bar_w - filled))
  local bar_f="" bar_e=""
  local i

  for ((i = 0; i < filled; i++)); do bar_f+="█"; done
  for ((i = 0; i < empty; i++)); do bar_e+="░"; done

  printf '%s    %s%s%s%s%s  %s%d/%d%s' \
    "$CL" "$MAGENTA" "$bar_f" "$DWHT" "$bar_e" "$RST" "$DWHT" "$completed" "${#STEP_LABELS[@]}" "$RST"
}

draw_running() {
  local anim_tick=$1 spinner_frame=$2
  local n=0 i

  render_frame "$anim_tick" "normal"
  n=$GRID_H

  printf '%s\n' "$CL"
  n=$((n + 1))

  for ((i = 0; i < ${#STEP_LABELS[@]}; i++)); do
    case "${STEP_STATUS[$i]}" in
      pending)
        printf '%s    %s∙%s %s%s%s\n' "$CL" "$DWHT" "$RST" "$DWHT" "${STEP_LABELS[$i]}" "$RST"
        ;;
      running)
        printf '%s    %s%s%s %s%s...%s\n' "$CL" "$CYN" "${SPIN[$((spinner_frame % ${#SPIN[@]}))]}" "$RST" "$BWHT" "${STEP_LABELS[$i]}" "$RST"
        ;;
      success)
        printf '%s    %s✓%s %s%s%s\n' "$CL" "$GRN" "$RST" "$BWHT" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      warning)
        printf '%s    %s!%s %s%s%s\n' "$CL" "$YELLOW" "$RST" "$YELLOW" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      skipped)
        printf '%s    %s-%s %s%s%s\n' "$CL" "$DWHT" "$RST" "$DWHT" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      error)
        printf '%s    %s✗%s %s%s%s\n' "$CL" "$RED" "$RST" "$RED" "${STEP_RESULTS[$i]}" "$RST"
        ;;
    esac
    n=$((n + 1))
  done

  printf '%s\n' "$CL"
  render_progress
  printf '\n'
  n=$((n + 2))

  while (( n < TOTAL_FRAME_LINES )); do
    printf '%s\n' "$CL"
    n=$((n + 1))
  done
}

draw_success() {
  local anim_tick=$1
  local n=0 i

  render_frame "$anim_tick" "success"
  n=$GRID_H

  printf '%s\n' "$CL"
  n=$((n + 1))

  for ((i = 0; i < ${#STEP_LABELS[@]}; i++)); do
    case "${STEP_STATUS[$i]}" in
      success)
        printf '%s    %s✓%s %s%s%s\n' "$CL" "$GRN" "$RST" "$BWHT" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      warning)
        printf '%s    %s!%s %s%s%s\n' "$CL" "$YELLOW" "$RST" "$YELLOW" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      skipped)
        printf '%s    %s-%s %s%s%s\n' "$CL" "$DWHT" "$RST" "$DWHT" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      error)
        printf '%s    %s✗%s %s%s%s\n' "$CL" "$RED" "$RST" "$RED" "${STEP_RESULTS[$i]}" "$RST"
        ;;
      *)
        printf '%s    %s∙%s %s%s%s\n' "$CL" "$DWHT" "$RST" "$DWHT" "${STEP_LABELS[$i]}" "$RST"
        ;;
    esac
    n=$((n + 1))
  done

  printf '%s\n' "$CL"
  printf '%s    %s─────────────────────────────────────────%s\n' "$CL" "$DWHT" "$RST"
  printf '%s\n' "$CL"
  printf '%s    %sGet started:%s\n' "$CL" "$DWHT" "$RST"
  printf '%s      %s$ %s%sosmose --help%s     %s# Show help%s\n' "$CL" "$GRN" "$RST" "$WHITE" "$RST" "$DWHT" "$RST"
  printf '%s      %s$ %s%sosmose config%s     %s# Configure your project%s\n' "$CL" "$GRN" "$RST" "$WHITE" "$RST" "$DWHT" "$RST"
  printf '%s      %s$ %s%sosmose dev%s        %s# Start development mode%s\n' "$CL" "$GRN" "$RST" "$WHITE" "$RST" "$DWHT" "$RST"
  n=$((n + 7))

  while (( n < TOTAL_FRAME_LINES )); do
    printf '%s\n' "$CL"
    n=$((n + 1))
  done
}

render_intro() {
  local cmd="curl -fsSL https://get.osmose.sh/install.sh | bash"
  local i

  printf '%s' "$HIDE"
  for ((i = 0; i <= ${#cmd}; i++)); do
    printf '\r%s  %s$ %s%s%s▊%s' "$CL" "$GRN" "$RST$WHITE" "${cmd:0:$i}" "$GRN" "$RST"
    sleep 0.022
  done
  printf '\r%s  %s$ %s%s%s\n' "$CL" "$GRN" "$RST$WHITE" "$cmd" "$RST"
  sleep 0.3
}

render_banner() {
  local banner_fit=1
  local i last=$(( ${#BANNER[@]} - 1 ))

  (( TERM_COLS < 78 )) && banner_fit=0

  if (( banner_fit )); then
    for ((i = 0; i < ${#BANNER[@]}; i++)); do
      if (( i == 0 || i == last )); then
        printf '  %s%s%s\n' "$DMAG" "${BANNER[$i]}" "$RST"
      else
        printf '  %s%s%s\n' "$MAGENTA" "${BANNER[$i]}" "$RST"
      fi
      sleep 0.1
    done
  else
    printf '  %s═══ %sOSMOSE%s %s═══%s\n' "$DMAG" "$MAGENTA" "$DMAG" "$DMAG" "$RST"
  fi

  sleep 0.5
  printf '  %sMODERN  SHOPIFY  THEME  TOOLING%s\n' "$DWHT" "$RST"
  printf '\n'
}

render_static_banner() {
  printf '\n'
  printf '  %sOSMOSE%s %sModern Shopify Theme Tooling%s\n\n' "$MAGENTA" "$RST" "$DIM" "$RST"
}

reserve_frame_area() {
  local i
  if [[ "$FRAME_RESERVED" -eq 1 ]]; then
    return
  fi

  for ((i = 0; i < TOTAL_FRAME_LINES; i++)); do
    printf '\n'
  done
  FRAME_RESERVED=1
}

redraw_running() {
  local elapsed_ms=$((ANIM_FRAME * 60))
  local anim_tick=$((elapsed_ms / 80))
  local spinner_frame=$((elapsed_ms / 60))
  up "$TOTAL_FRAME_LINES"
  draw_running "$anim_tick" "$spinner_frame"
}

animate_success() {
  local frames=65
  local f
  for ((f = 0; f < frames; f++)); do
    up "$TOTAL_FRAME_LINES"
    draw_success "$((ANIM_FRAME + f))"
    sleep 0.08
  done
}

download_text() {
  local url=$1
  if command -v curl >/dev/null 2>&1; then
    curl -fsSL "$url"
  elif command -v wget >/dev/null 2>&1; then
    wget -qO- "$url"
  else
    return 1
  fi
}

download_file() {
  local url=$1 dest=$2
  if command -v curl >/dev/null 2>&1; then
    curl -fsSL "$url" -o "$dest"
  elif command -v wget >/dev/null 2>&1; then
    wget -q "$url" -O "$dest"
  else
    return 1
  fi
}

join_by() {
  local delimiter=$1
  shift
  local item
  local first=1
  for item in "$@"; do
    if [[ "$first" -eq 1 ]]; then
      printf '%s' "$item"
      first=0
    else
      printf '%s%s' "$delimiter" "$item"
    fi
  done
}

human_size() {
  local bytes=$1
  awk -v bytes="$bytes" 'BEGIN {
    split("B KB MB GB TB", units, " ")
    idx = 1
    while (bytes >= 1024 && idx < 5) {
      bytes = bytes / 1024
      idx++
    }
    if (bytes >= 10 || idx == 1) {
      printf "%.0f %s", bytes, units[idx]
    } else {
      printf "%.1f %s", bytes, units[idx]
    }
  }'
}

extract_last_message() {
  local file
  for file in "$@"; do
    if [[ -f "$file" ]] && [[ -s "$file" ]]; then
      awk 'NF { line = $0 } END { if (line != "") print line }' "$file"
      return 0
    fi
  done
  return 1
}

parse_step_outcome() {
  local outcome_line=$1
  LAST_STEP_STATUS="success"
  LAST_STEP_MESSAGE=""

  if [[ -z "$outcome_line" ]]; then
    return
  fi

  case "$outcome_line" in
    success:*)
      LAST_STEP_STATUS="success"
      LAST_STEP_MESSAGE=${outcome_line#success:}
      ;;
    warning:*)
      LAST_STEP_STATUS="warning"
      LAST_STEP_MESSAGE=${outcome_line#warning:}
      ;;
    skipped:*)
      LAST_STEP_STATUS="skipped"
      LAST_STEP_MESSAGE=${outcome_line#skipped:}
      ;;
    *)
      LAST_STEP_STATUS="success"
      LAST_STEP_MESSAGE="$outcome_line"
      ;;
  esac
}

print_simple_step_result() {
  local idx=$1
  case "${STEP_STATUS[$idx]}" in
    success) log_done "${STEP_RESULTS[$idx]}" ;;
    warning) log_warn "${STEP_RESULTS[$idx]}" ;;
    skipped) log_info "${STEP_RESULTS[$idx]}" ;;
    error) log_error "${STEP_RESULTS[$idx]}" ;;
  esac
}

run_step() {
  local idx=$1
  shift
  local fn=$1
  shift

  local out_file="${TEMP_DIR}/step-${idx}.out"
  local err_file="${TEMP_DIR}/step-${idx}.err"
  local step_exit=0
  local outcome_line=""
  local detail=""

  : > "$out_file"
  : > "$err_file"

  STEP_STATUS[$idx]="running"
  STEP_RESULTS[$idx]="${STEP_LABELS[$idx]}"

  if [[ "$INTERACTIVE" -eq 1 ]]; then
    redraw_running
    "$fn" "$@" >"$out_file" 2>"$err_file" &
    local pid=$!
    while kill -0 "$pid" 2>/dev/null; do
      sleep 0.06
      ANIM_FRAME=$((ANIM_FRAME + 1))
      redraw_running
    done
    wait "$pid" || step_exit=$?
  else
    "$fn" "$@" >"$out_file" 2>"$err_file" || step_exit=$?
  fi

  if [[ "$step_exit" -ne 0 ]]; then
    detail=$(extract_last_message "$err_file" "$out_file" || true)
    [[ -z "$detail" ]] && detail="${STEP_LABELS[$idx]} failed"
    STEP_STATUS[$idx]="error"
    STEP_RESULTS[$idx]="$detail"
    if [[ "$INTERACTIVE" -eq 1 ]]; then
      redraw_running
      printf '\n  %s[✗]%s %s\n' "$RED" "$RST" "$detail" >&2
    else
      print_simple_step_result "$idx"
    fi
    return "$step_exit"
  fi

  outcome_line=$(awk 'NF { print; exit }' "$out_file")
  parse_step_outcome "$outcome_line"
  STEP_STATUS[$idx]="$LAST_STEP_STATUS"
  STEP_RESULTS[$idx]="${LAST_STEP_MESSAGE:-${STEP_LABELS[$idx]}}"

  if [[ "$INTERACTIVE" -eq 1 ]]; then
    redraw_running
    sleep 0.25
  else
    print_simple_step_result "$idx"
  fi
}

detect_platform_raw() {
  local os arch

  case "$(uname -s)" in
    Darwin*) os="darwin" ;;
    Linux*) os="linux" ;;
    MINGW*|MSYS*|CYGWIN*) os="windows" ;;
    *) printf 'Unsupported operating system: %s\n' "$(uname -s)" >&2; return 1 ;;
  esac

  case "$(uname -m)" in
    x86_64|amd64) arch="amd64" ;;
    aarch64|arm64) arch="arm64" ;;
    armv7l|armhf) arch="arm" ;;
    i386|i686) arch="386" ;;
    *) printf 'Unsupported architecture: %s\n' "$(uname -m)" >&2; return 1 ;;
  esac

  printf '%s_%s\n' "$os" "$arch"
}

step_detect_platform() {
  local platform
  platform=$(detect_platform_raw)
  printf 'success:%s\n' "$platform"
}

step_check_deps() {
  local missing=()
  local found=()

  if command -v git >/dev/null 2>&1; then
    found+=("git")
  else
    missing+=("git")
  fi

  if command -v curl >/dev/null 2>&1; then
    found+=("curl")
  elif command -v wget >/dev/null 2>&1; then
    found+=("wget")
  else
    missing+=("curl or wget")
  fi

  if [[ ${#missing[@]} -gt 0 ]]; then
    printf 'Missing required tools: %s\n' "$(join_by ', ' "${missing[@]}")" >&2
    return 1
  fi

  printf 'success:%s found\n' "$(join_by ', ' "${found[@]}")"
}

step_resolve_version() {
  local version="${OSMOSE_VERSION:-}"

  if [[ -z "$version" ]]; then
    version=$(download_text "${GET_BASE}/latest" 2>/dev/null || true)
  fi

  if [[ -z "$version" ]]; then
    printf 'Failed to fetch latest version\n' >&2
    return 1
  fi

  printf 'success:%s\n' "$version"
}

step_download_binary() {
  local download_url="${RELEASE_BASE}/${VERSION}/${BINARY_NAME}_${PLATFORM}${BINARY_SUFFIX}"
  local size

  download_file "$download_url" "$TEMP_BINARY"
  size=$(wc -c < "$TEMP_BINARY" 2>/dev/null || echo 0)
  size=${size// /}
  printf 'success:Binary downloaded (%s)\n' "$(human_size "$size")"
}

step_verify_checksum() {
  local checksums_url="${RELEASE_BASE}/${VERSION}/checksums.txt"
  local expected_file="${BINARY_NAME}_${PLATFORM}${BINARY_SUFFIX}"
  local checksums expected_hash actual_hash

  checksums=$(download_text "$checksums_url" 2>/dev/null || true)
  if [[ -z "$checksums" ]]; then
    printf 'warning:Checksums not available, skipped verification\n'
    return 0
  fi

  expected_hash=$(printf '%s\n' "$checksums" | awk -v target="$expected_file" '$2 == target { print $1; exit }')
  if [[ -z "$expected_hash" ]]; then
    printf 'warning:No checksum entry for %s\n' "$expected_file"
    return 0
  fi

  if command -v sha256sum >/dev/null 2>&1; then
    actual_hash=$(sha256sum "$TEMP_BINARY" | awk '{print $1}')
  elif command -v shasum >/dev/null 2>&1; then
    actual_hash=$(shasum -a 256 "$TEMP_BINARY" | awk '{print $1}')
  else
    printf 'warning:No sha256 tool found, skipped verification\n'
    return 0
  fi

  if [[ "$actual_hash" != "$expected_hash" ]]; then
    printf 'Checksum mismatch for %s\nExpected: %s\nActual:   %s\n' "$expected_file" "$expected_hash" "$actual_hash" >&2
    return 1
  fi

  printf 'success:sha256 OK\n'
}

step_install_binary() {
  mkdir -p "$INSTALL_DIR"
  chmod +x "$TEMP_BINARY"
  TARGET_BINARY="${INSTALL_DIR}/${BINARY_NAME}${BINARY_SUFFIX}"
  mv "$TEMP_BINARY" "$TARGET_BINARY"
  printf 'success:Installed to %s\n' "$TARGET_BINARY"
}

step_install_vscode_extension() {
  if [[ -n "${OSMOSE_NO_EDITOR:-}" ]]; then
    printf 'skipped:VSCode extension skipped (OSMOSE_NO_EDITOR=1)\n'
    return 0
  fi

  if ! command -v code >/dev/null 2>&1; then
    printf 'skipped:VSCode CLI not found\n'
    return 0
  fi

  if code --list-extensions 2>/dev/null | grep -q "osmose.osmose-liquid"; then
    printf 'success:VSCode extension already installed\n'
    return 0
  fi

  local vsix_url="${RELEASE_BASE}/${VERSION}/osmose-liquid.vsix"
  if download_file "$vsix_url" "$TEMP_VSIX" >/dev/null 2>&1 && code --install-extension "$TEMP_VSIX" >/dev/null 2>&1; then
    rm -f "$TEMP_VSIX"
    printf 'success:VSCode extension installed\n'
  else
    printf 'warning:VSCode extension not available for this release\n'
  fi
}

sync_neovim_plugin_files() {
  local plugin_dir=$1
  local source_dir="${plugin_dir}/next/editors/nvim"

  if [[ ! -d "$source_dir" ]]; then
    printf 'Neovim plugin files not found in repository checkout\n' >&2
    return 1
  fi

  cp -R "${source_dir}/." "$plugin_dir/"
}

step_install_neovim_plugin() {
  local plugin_dir=""

  if [[ -n "${OSMOSE_NO_EDITOR:-}" ]]; then
    printf 'skipped:Neovim plugin skipped (OSMOSE_NO_EDITOR=1)\n'
    return 0
  fi

  if ! command -v nvim >/dev/null 2>&1; then
    printf 'skipped:Neovim not found\n'
    return 0
  fi

  if [[ -d "$HOME/.local/share/nvim/site/pack" ]]; then
    plugin_dir="$HOME/.local/share/nvim/site/pack/osmose/start/osmose.nvim"
  else
    plugin_dir="$HOME/.local/share/nvim/osmose-lsp"
  fi

  mkdir -p "$(dirname "$plugin_dir")"

  if [[ -d "$plugin_dir/.git" ]]; then
    git -C "$plugin_dir" pull --quiet
    sync_neovim_plugin_files "$plugin_dir" >/dev/null
    printf 'success:Neovim plugin updated\n'
    return 0
  fi

  rm -rf "$plugin_dir"
  git clone --quiet --depth 1 "$REPO_URL" "$plugin_dir"
  sync_neovim_plugin_files "$plugin_dir" >/dev/null
  printf 'success:Neovim plugin installed\n'
}

step_verify_installation() {
  local binary_path="${TARGET_BINARY:-${INSTALL_DIR}/${BINARY_NAME}${BINARY_SUFFIX}}"
  local installed_version

  if [[ ! -x "$binary_path" ]]; then
    printf 'Binary not found at %s\n' "$binary_path" >&2
    return 1
  fi

  installed_version=$("$binary_path" --version 2>/dev/null || true)
  [[ -z "$installed_version" ]] && installed_version="Verification passed"
  printf 'success:%s\n' "$installed_version"
}

build_path_notice() {
  if [[ ":$PATH:" == *":${INSTALL_DIR}:"* ]]; then
    PATH_NOTICE=""
    return
  fi

  local shell_name rc_file=""
  shell_name=$(basename "${SHELL:-bash}")
  case "$shell_name" in
    bash) rc_file="~/.bashrc" ;;
    zsh) rc_file="~/.zshrc" ;;
    fish) rc_file="~/.config/fish/config.fish" ;;
  esac

  PATH_NOTICE="${INSTALL_DIR} is not in your PATH"
  if [[ -n "$rc_file" ]]; then
    PATH_NOTICE="${PATH_NOTICE}"$'\n'"Add to ${rc_file}:"$'\n'"export PATH=\"${INSTALL_DIR}:\$PATH\""
  fi
}

print_path_notice() {
  [[ -z "$PATH_NOTICE" ]] && return

  printf '\n'
  printf '  %s[!]%s %s\n' "$YELLOW" "$RST" "${PATH_NOTICE%%$'\n'*}"

  local rest="${PATH_NOTICE#*$'\n'}"
  if [[ "$rest" != "$PATH_NOTICE" ]]; then
    local line
    while IFS= read -r line; do
      [[ -n "$line" ]] && printf '  %s%s%s\n' "$DWHT" "$line" "$RST"
    done <<< "$rest"
  fi
  printf '\n'
}

print_plain_summary() {
  printf '\n'
  printf '  %s%s━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━%s\n' "$DIM" "$MAGENTA" "$RST"
  printf '\n'
  printf '  %s%sosmose %s installed%s\n\n' "$BOLD" "$GREEN" "$VERSION" "$RST"
  printf '  %sGet started:%s\n' "$WHITE" "$RST"
  printf '    %s$%s osmose --help     %s# Show help%s\n' "$GREEN" "$RST" "$DIM" "$RST"
  printf '    %s$%s osmose config     %s# Configure your project%s\n' "$GREEN" "$RST" "$DIM" "$RST"
  printf '    %s$%s osmose dev        %s# Start dev server%s\n' "$GREEN" "$RST" "$DIM" "$RST"
  printf '\n'
  printf '  %s%s━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━%s\n' "$DIM" "$MAGENTA" "$RST"
  printf '\n'
}

run_install_flow() {
  run_step 0 step_detect_platform
  PLATFORM="$LAST_STEP_MESSAGE"
  [[ "$PLATFORM" == windows_* ]] && BINARY_SUFFIX=".exe"

  run_step 1 step_check_deps
  run_step 2 step_resolve_version
  VERSION="$LAST_STEP_MESSAGE"
  run_step 3 step_download_binary
  run_step 4 step_verify_checksum
  run_step 5 step_install_binary
  TARGET_BINARY="${INSTALL_DIR}/${BINARY_NAME}${BINARY_SUFFIX}"
  run_step 6 step_install_vscode_extension
  run_step 7 step_install_neovim_plugin
  run_step 8 step_verify_installation
}

main() {
  init_palette
  init_banner
  init_steps
  prepare_temp_dir

  if [[ "$INTERACTIVE" -eq 1 ]]; then
    init_terminal_metrics
    render_intro
    render_banner
    reserve_frame_area
    redraw_running
  else
    render_static_banner
  fi

  run_install_flow
  build_path_notice

  if [[ "$INTERACTIVE" -eq 1 ]]; then
    animate_success
    print_path_notice
  else
    print_plain_summary
    print_path_notice
  fi
}

main "$@"