#!/bin/sh
set -eu

if [ -z "${PROXY_PATH:-}" ]; then
  PROXY_PATH="/"
fi
case "${PROXY_PATH}" in
  /*) ;;
  *) PROXY_PATH="/${PROXY_PATH}" ;;
esac

CONFIG_PATH="${CONFIG_PATH:-/data/config.yaml}"
AUTH_DIR="${AUTH_DIR:-/data/auth}"

mkdir -p "$(dirname "${CONFIG_PATH}")" "${AUTH_DIR}"
if [ -n "${CONFIG_CONTENT_B64:-}" ]; then
  echo "Writing config from CONFIG_CONTENT_B64 to ${CONFIG_PATH}"
  echo "${CONFIG_CONTENT_B64}" | base64 -d > "${CONFIG_PATH}"
elif [ -n "${CONFIG_CONTENT:-}" ]; then
  echo "Writing config from CONFIG_CONTENT to ${CONFIG_PATH}"
  printf '%s\n' "${CONFIG_CONTENT}" > "${CONFIG_PATH}"
fi

if [ ! -f "${CONFIG_PATH}" ]; then
  for candidate in \
    /app/config.yaml \
    /app/config.yml \
    /CLIProxyAPI/config.yaml \
    /CLIProxyAPI/config.yml \
    /CLIProxyAPI/config.example.yaml \
    /CLIProxyAPI/config.example.yml \
    /CLIProxyAPI/config.sample.yaml \
    /CLIProxyAPI/config.sample.yml \
    /CLIProxyAPI/config.template.yaml \
    /CLIProxyAPI/config.template.yml; do
    if [ -f "${candidate}" ]; then
      echo "Copying default config from ${candidate} to ${CONFIG_PATH}"
      cp "${candidate}" "${CONFIG_PATH}"
      break
    fi
  done
fi

if [ -n "${CLI_PROXY_KEY:-}" ]; then
  if [ -z "${MANAGEMENT_KEY:-}" ]; then
    MANAGEMENT_KEY="${CLI_PROXY_KEY}"
  fi
  if [ -z "${API_KEYS:-}" ]; then
    API_KEYS="${CLI_PROXY_KEY}"
  fi
fi

if [ -f "${CONFIG_PATH}" ]; then
  if [ -n "${MANAGEMENT_KEY:-}" ]; then
    MGMT_ESCAPED="$(printf '%s' "${MANAGEMENT_KEY}" | sed 's/[\\/&]/\\&/g')"
    if grep -q '^[[:space:]]*secret-key:' "${CONFIG_PATH}"; then
      sed -i "s|^\([[:space:]]*secret-key:\).*|\1 \"${MGMT_ESCAPED}\"|" "${CONFIG_PATH}"
    fi
  fi
  if [ -n "${API_KEYS:-}" ]; then
    TMP_CONFIG="${CONFIG_PATH}.tmp"
    awk -v keys="${API_KEYS}" '
      BEGIN {
        n=split(keys, arr, /[ ,]+/);
        in_api=0;
        found=0;
      }
      function emit_keys() {
        print "api-keys:";
        for (i=1; i<=n; i++) {
          if (length(arr[i]) > 0) {
            print "  - \"" arr[i] "\"";
          }
        }
      }
      {
        if (in_api) {
          if ($0 ~ /^[[:space:]]*-/) {
            next;
          } else {
            in_api=0;
          }
        }
        if ($0 ~ /^api-keys:[[:space:]]*$/) {
          emit_keys();
          in_api=1;
          found=1;
          next;
        }
        print $0;
      }
      END {
        if (!found) {
          emit_keys();
        }
      }
    ' "${CONFIG_PATH}" > "${TMP_CONFIG}" && mv "${TMP_CONFIG}" "${CONFIG_PATH}"
  fi
fi

if [ -f "${CONFIG_PATH}" ]; then
  ln -sf "${CONFIG_PATH}" /CLIProxyAPI/config.yaml
elif [ -f "/CLIProxyAPI/config.yaml" ]; then
  echo "Using existing /CLIProxyAPI/config.yaml"
else
  echo "No config file found. Set CONFIG_CONTENT or mount CONFIG_PATH."
fi
if [ -e /root/.cli-proxy-api ] && [ ! -L /root/.cli-proxy-api ]; then
  rm -rf /root/.cli-proxy-api
fi
ln -sfn "${AUTH_DIR}" /root/.cli-proxy-api

NGINX_CONF_DIR="/etc/nginx/conf.d"
if [ -d "/etc/nginx/http.d" ]; then
  NGINX_CONF_DIR="/etc/nginx/http.d"
fi

if [ -z "${MANAGEMENT_KEY:-}" ] && [ -f "${CONFIG_PATH}" ]; then
  MGMT_KEY_LINE="$(sed -n 's/^[[:space:]]*secret-key[[:space:]]*:[[:space:]]*//p' "${CONFIG_PATH}" | head -n 1)"
  MGMT_KEY_LINE="$(printf '%s' "${MGMT_KEY_LINE}" | sed 's/[[:space:]]*$//')"
  MANAGEMENT_KEY="${MGMT_KEY_LINE#\"}"
  MANAGEMENT_KEY="${MANAGEMENT_KEY%\"}"
  MANAGEMENT_KEY="${MANAGEMENT_KEY#\'}"
  MANAGEMENT_KEY="${MANAGEMENT_KEY%\'}"
  export MANAGEMENT_KEY
fi

export PROXY_PATH CLI_PROXY_HOST CLI_PROXY_PORT PORT MANAGEMENT_KEY
envsubst '${PORT} ${CLI_PROXY_HOST} ${CLI_PROXY_PORT} ${MANAGEMENT_KEY}' \
  < /etc/nginx/templates/default.conf.template \
  > "${NGINX_CONF_DIR}/default.conf"

detect_cmd() {
  if [ -n "${CLI_PROXY_CMD:-}" ]; then
    echo "${CLI_PROXY_CMD}"
    return 0
  fi
  if [ -x "/docker-entrypoint.sh" ]; then
    echo "/docker-entrypoint.sh"
    return 0
  fi
  if [ -x "/entrypoint.sh" ]; then
    echo "/entrypoint.sh"
    return 0
  fi
  if [ -x "/CLIProxyAPI/cli-proxy-api" ]; then
    echo "/CLIProxyAPI/cli-proxy-api"
    return 0
  fi
  if [ -x "/CLIProxyAPI/start.sh" ]; then
    echo "/CLIProxyAPI/start.sh"
    return 0
  fi
  if [ -x "/CLIProxyAPI/run.sh" ]; then
    echo "/CLIProxyAPI/run.sh"
    return 0
  fi
  if [ -x "/CLIProxyAPI/CLIProxyAPI" ]; then
    echo "/CLIProxyAPI/CLIProxyAPI"
    return 0
  fi
  if [ -f "/CLIProxyAPI/main.py" ]; then
    echo "python /CLIProxyAPI/main.py"
    return 0
  fi
  if [ -f "/CLIProxyAPI/app.py" ]; then
    echo "python /CLIProxyAPI/app.py"
    return 0
  fi
  if [ -f "/CLIProxyAPI/server.py" ]; then
    echo "python /CLIProxyAPI/server.py"
    return 0
  fi
  if [ -f "/CLIProxyAPI/index.js" ]; then
    echo "node /CLIProxyAPI/index.js"
    return 0
  fi
  if [ -f "/CLIProxyAPI/package.json" ]; then
    echo "npm start --prefix /CLIProxyAPI"
    return 0
  fi
  return 1
}

if [ "$#" -gt 0 ]; then
  echo "Starting CLIProxyAPI from base CMD: $*"
  "$@" &
else
  CLI_CMD="$(detect_cmd || true)"
  if [ -z "${CLI_CMD}" ]; then
    echo "Cannot detect how to start CLIProxyAPI."
    echo "Set CLI_PROXY_CMD in Space Variables to the correct launch command."
    exit 1
  fi

  echo "Starting CLIProxyAPI: ${CLI_CMD}"
  sh -c "${CLI_CMD}" &
fi

echo "Starting nginx on port ${PORT}, proxy path ${PROXY_PATH}"
exec nginx -g 'daemon off;'