#!/usr/bin/env bash
# Unified deploy script (dev/prod) driven by deploy.json.
#
# Usage:
#   ./scripts/deploy.sh <env> [branch]
#     env: dev | prod
#     branch: optional override; otherwise uses deploy.json defaultBranch (if set),
#             else current local git branch.
#
# Config file (not committed): deploy.json (see deploy.json.example)
# {
#   "dev":  { "target": "user@dev.host",  "path": "/var/www/alarm-dev",               "defaultBranch": "feature/foo", "lock": "composer.lock.83", "envFile": ".env.dev" },
#   "prod": { "target": "user@prod.host", "path": "/var/www/alarm.minifinder.com/www","defaultBranch": "master",      "lock": "composer.lock.74" }
# }
#
# Notes:
# - If envFile is set and exists locally, it is uploaded to <path>/.env before git pull.
# - Composer is executed on the remote host.
set -euo pipefail
cd "$(dirname "$0")/.."

ENVIRONMENT="${1:-}"
BRANCH_OVERRIDE="${2:-}"

if [ -z "$ENVIRONMENT" ]; then
  echo "Usage: $0 <env> [branch]"
  echo "  env: dev | prod"
  exit 1
fi

CONFIG_FILE="${DEPLOY_CONFIG_PATH:-./deploy.json}"
if [ ! -f "$CONFIG_FILE" ]; then
  echo "Missing $CONFIG_FILE. Create it from deploy.json.example"
  exit 1
fi

json_get() {
  local key="$1"
  python3 - "$CONFIG_FILE" "$key" <<'PY'
import json, sys
path = sys.argv[1]
key  = sys.argv[2]
with open(path, "r", encoding="utf-8") as f:
    data = json.load(f)
cur = data
for part in key.split("."):
    if isinstance(cur, dict) and part in cur:
        cur = cur[part]
    else:
        cur = None
        break
if cur is None:
    sys.exit(2)
if isinstance(cur, (dict, list)):
    print(json.dumps(cur))
else:
    print(str(cur))
PY
}

TARGET="$(json_get "$ENVIRONMENT.target" 2>/dev/null || true)"
REMOTE_PATH="$(json_get "$ENVIRONMENT.path" 2>/dev/null || true)"
DEFAULT_BRANCH="$(json_get "$ENVIRONMENT.defaultBranch" 2>/dev/null || true)"
LOCK_FILE="$(json_get "$ENVIRONMENT.lock" 2>/dev/null || true)"
ENV_FILE="$(json_get "$ENVIRONMENT.envFile" 2>/dev/null || true)"

if [ -z "$TARGET" ] || [ -z "$REMOTE_PATH" ]; then
  echo "deploy.json must contain $ENVIRONMENT.target and $ENVIRONMENT.path"
  exit 1
fi

if [ -n "$BRANCH_OVERRIDE" ]; then
  BRANCH="$BRANCH_OVERRIDE"
elif [ -n "$DEFAULT_BRANCH" ]; then
  BRANCH="$DEFAULT_BRANCH"
else
  BRANCH="$(git branch --show-current)"
fi

if [ -z "$BRANCH" ]; then
  echo "Could not determine branch (pass as 2nd argument or set $ENVIRONMENT.defaultBranch)"
  exit 1
fi

if [ -z "$LOCK_FILE" ]; then
  # Default lock file for dev/prod if omitted
  if [ "$ENVIRONMENT" = "prod" ]; then
    LOCK_FILE="composer.lock.74"
  else
    LOCK_FILE="composer.lock.83"
  fi
fi

echo "Deploying $ENVIRONMENT: branch=$BRANCH target=$TARGET path=$REMOTE_PATH lock=$LOCK_FILE"

if [ -n "$ENV_FILE" ] && [ -f "$ENV_FILE" ]; then
  echo "Uploading $ENV_FILE as .env..."
  scp "$ENV_FILE" "$TARGET:$REMOTE_PATH/.env"
fi

# First update code on remote (keep repo clean before touching composer files)
ssh "$TARGET" "cd $REMOTE_PATH && git fetch origin && git checkout \"$BRANCH\" && git pull origin \"$BRANCH\""

# Then upload composer files for PHP 8.3 (or legacy lock as fallback)
if [ -f composer.json.83 ] && [ -f composer.lock.83 ]; then
  echo "Uploading composer.json/composer.lock (PHP 8.3 versions)..."
  scp composer.json.83 "$TARGET:$REMOTE_PATH/composer.json"
  scp composer.lock.83 "$TARGET:$REMOTE_PATH/composer.lock"
elif [ -n "$LOCK_FILE" ] && [ -f "$LOCK_FILE" ]; then
  echo "Uploading legacy lock file $LOCK_FILE as composer.lock..."
  scp "$LOCK_FILE" "$TARGET:$REMOTE_PATH/composer.lock"
fi

# Finally install dependencies on remote using uploaded composer files
# Force Composer to run under PHP 8.3 on the remote host
ssh "$TARGET" "cd $REMOTE_PATH && php8.3 \$(command -v composer) install --no-dev --no-interaction"
echo "Done."