#!/usr/bin/env bash
# ==============================================================
#  pi_port_proxy.sh  v2.0
#  监听 31400-31409，把 http://<IP>:3140X 反代到 Pi 测试网 API
#
#  v2.0 修掉的问题：
#   1) request_queue_size 默认只有 5 → 改成 512（端口"假死"的根因）
#   2) 只查 PID 判断"已在运行" → 改成实测端口能否应答
#   3) 客户端无读超时 → 慢连接永久占线程；现为 15 秒
#   4) 无限开线程 → 并发上限 128，超限快速 503
#   5) 无守护、重启 VPS 不自启 → systemd 托管，崩溃 2 秒拉起
#   6) 用"每 10 分钟盲重启"止血 → 每分钟实测，只在真不通时重启
#
#  用法:
#    bash pi_port_proxy.sh             安装 + 开机自启 + 健康自愈（推荐）
#    bash pi_port_proxy.sh status      查看状态（每个端口实测）
#    bash pi_port_proxy.sh health      立即体检一次
#    bash pi_port_proxy.sh restart     重启
#    bash pi_port_proxy.sh logs        看最近日志
#    bash pi_port_proxy.sh run         前台运行（调试，Ctrl+C 停）
#    bash pi_port_proxy.sh uninstall   卸载
#
#  可覆盖的环境变量:
#    PI_PORTS=31400-31409     监听端口范围
#    PI_TARGET=https://...    上游地址
#    PI_TIMEOUT=8             上游超时（秒）
#    PI_MAX_CONN=128          单端口最大并发
# ==============================================================
set -uo pipefail

VERSION="2.0"
SVC="pi-port-proxy"
BIN_PY="/usr/local/bin/pi_proxy_server.py"
BIN_CTL="/usr/local/bin/pi_proxy_ctl"
UNIT="/etc/systemd/system/${SVC}.service"
CHECK_LOG="/var/log/pi_port_proxy_check.log"
CRON_TAG="# >>> pi-port-proxy >>>"

PI_PORTS="${PI_PORTS:-31400-31409}"
PI_TARGET="${PI_TARGET:-https://api.testnet2.minepi.com/}"
PI_TIMEOUT="${PI_TIMEOUT:-8}"
PI_MAX_CONN="${PI_MAX_CONN:-128}"

C_OK=$'\033[32m'; C_W=$'\033[33m'; C_E=$'\033[31m'; C_0=$'\033[0m'
say()  { printf '%s[·]%s %s\n' "$C_OK" "$C_0" "$*"; }
warn() { printf '%s[!]%s %s\n' "$C_W" "$C_0" "$*"; }
err()  { printf '%s[x]%s %s\n' "$C_E" "$C_0" "$*" >&2; }
die()  { err "$*"; exit 1; }

# 31400-31409 / 31400,31401 / 31400-31402,8080 → "31400 31401 ..."
expand_ports() {
  local spec="$1" out="" part a b i
  spec=$(printf '%s' "$spec" | tr ',' ' ')
  for part in $spec; do
    case "$part" in
      *-*)
        a=${part%%-*}; b=${part##*-}
        [[ "$a" =~ ^[0-9]+$ && "$b" =~ ^[0-9]+$ ]] || continue
        [ "$a" -le "$b" ] || { i=$a; a=$b; b=$i; }
        for ((i=a; i<=b; i++)); do out="$out $i"; done ;;
      *)
        [[ "$part" =~ ^[0-9]+$ ]] && out="$out $part" ;;
    esac
  done
  printf '%s' "${out# }"
}
PORT_LIST=$(expand_ports "$PI_PORTS")
[ -n "$PORT_LIST" ] || die "端口范围解析失败：$PI_PORTS"
PORT_COUNT=$(printf '%s\n' $PORT_LIST | wc -l)

# ==============================================================
#  一、Python 服务本体
# ==============================================================
write_server() {
  cat > "$BIN_PY" <<'PYEOF'
#!/usr/bin/env python3
"""Pi 测试网 API 端口反代 —— 监听多个端口，把请求转发到上游 HTTPS。"""
import http.server
import os
import signal
import socket
import socketserver
import ssl
import sys
import threading
import urllib.error
import urllib.request

TARGET  = os.environ.get("PI_TARGET", "https://api.testnet2.minepi.com/").rstrip("/")
PORTS   = [int(x) for x in os.environ.get("PI_PORT_LIST", "31400").split()]
TIMEOUT = float(os.environ.get("PI_TIMEOUT", "8"))
MAXCONN = int(os.environ.get("PI_MAX_CONN", "128"))
BACKLOG = 512                 # 关键：socketserver 默认只有 5，突发连接会被内核丢弃
CLIENT_TIMEOUT = 15           # 慢客户端不再永久占线程
MAXBODY = 8 * 1024 * 1024

CTX = ssl.create_default_context()
CTX.check_hostname = False
CTX.verify_mode = ssl.CERT_NONE

SEM = threading.BoundedSemaphore(MAXCONN)
STOP = threading.Event()


class Handler(http.server.BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.0"
    server_version = "pi-port-proxy/2.0"
    timeout = CLIENT_TIMEOUT

    def log_message(self, fmt, *args):
        # 默认不记每个请求，避免日志刷爆磁盘；PI_VERBOSE=1 时才输出
        if os.environ.get("PI_VERBOSE") == "1":
            sys.stderr.write("[%s] %s\n" % (self.server.server_address[1], fmt % args))
            sys.stderr.flush()

    def _reply(self, code, body, ctype="text/plain; charset=utf-8"):
        try:
            self.send_response(code)
            self.send_header("Content-Type", ctype)
            self.send_header("Content-Length", str(len(body)))
            self.send_header("Connection", "close")
            self.end_headers()
            if self.command != "HEAD":
                self.wfile.write(body)
        except (BrokenPipeError, ConnectionResetError, OSError):
            pass

    def _proxy(self):
        if not SEM.acquire(blocking=False):
            self._reply(503, b"busy: too many concurrent requests\n")
            return
        try:
            try:
                length = int(self.headers.get("Content-Length") or 0)
            except ValueError:
                length = 0
            if length > MAXBODY:
                self._reply(413, b"request body too large\n")
                return
            data = self.rfile.read(length) if length else None

            headers = {"User-Agent": "pi-port-proxy/2.0", "Accept": "*/*"}
            ctype = self.headers.get("Content-Type")
            if ctype:
                headers["Content-Type"] = ctype

            req = urllib.request.Request(TARGET + self.path, data=data,
                                         headers=headers, method=self.command)
            try:
                resp = urllib.request.urlopen(req, timeout=TIMEOUT, context=CTX)
                try:
                    body = resp.read(MAXBODY)
                    code = resp.status
                    rct = resp.headers.get("Content-Type", "text/plain; charset=utf-8")
                finally:
                    resp.close()
                self._reply(code, body, rct)
            except urllib.error.HTTPError as e:
                body = e.read(65536) or b""
                rct = e.headers.get("Content-Type", "text/plain; charset=utf-8") if e.headers else "text/plain"
                self._reply(e.code, body, rct)
            except Exception as e:
                self._reply(502, ("Proxy error: %s\n" % e).encode("utf-8", "replace"))
        finally:
            SEM.release()

    def do_GET(self):
        self._proxy()

    def do_HEAD(self):
        self._proxy()

    def do_POST(self):
        self._proxy()

    def do_PUT(self):
        self._proxy()

    def do_DELETE(self):
        self._proxy()

    def do_OPTIONS(self):
        self._proxy()


class Server(socketserver.ThreadingMixIn, socketserver.TCPServer):
    allow_reuse_address = True
    daemon_threads = True
    block_on_close = False
    request_queue_size = BACKLOG


class Server6(Server):
    """IPv6 socket，但关掉 V6ONLY，一个 socket 同时收 IPv4 和 IPv6 连接"""
    address_family = socket.AF_INET6

    def server_bind(self):
        try:
            self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
        except OSError:
            pass
        super().server_bind()


def make_server(port):
    """双栈优先；内核没开 IPv6 时退回纯 IPv4，不影响可用性"""
    if socket.has_ipv6:
        try:
            return Server6(("::", port), Handler), "dual"
        except OSError:
            pass
    return Server(("0.0.0.0", port), Handler), "v4"


servers = []
for port in PORTS:
    try:
        srv, mode = make_server(port)
        th = threading.Thread(target=srv.serve_forever, kwargs={"poll_interval": 0.5}, daemon=True)
        th.start()
        servers.append((port, srv, th))
        print("  OK   listen %d (%s)" % (port, mode), flush=True)
    except OSError as e:
        print("  FAIL listen %d: %s" % (port, e), flush=True)

if not servers:
    print("没有任何端口监听成功，退出", flush=True)
    sys.exit(1)

print("运行中：%s -> %s（%d 个端口，并发上限 %d）" %
      (" ".join(str(p) for p, _, _ in servers), TARGET, len(servers), MAXCONN), flush=True)


def shutdown(signum=None, frame=None):
    STOP.set()
    for _, srv, _ in servers:
        try:
            srv.shutdown()
        except Exception:
            pass
    print("已停止", flush=True)
    sys.exit(0)


signal.signal(signal.SIGTERM, shutdown)
signal.signal(signal.SIGINT, shutdown)

# 守护：任一端口线程死掉就退出，交给 systemd 秒级拉起（比每 10 分钟盲重启精准）
while not STOP.wait(30):
    for port, srv, th in servers:
        if not th.is_alive():
            print("端口 %d 的监听线程已死，退出等待 systemd 重启" % port, flush=True)
            os._exit(1)
PYEOF
  chmod 755 "$BIN_PY"
}

# ==============================================================
#  二、管理 / 健康检查脚本（cron 每分钟调用）
# ==============================================================
write_ctl() {
  cat > "$BIN_CTL" <<CTLEOF
#!/usr/bin/env bash
SVC="$SVC"
PORTS="$PORT_LIST"
LOG="$CHECK_LOG"
STATE="/run/pi_proxy_badcnt"
LAST="/run/pi_proxy_lastrestart"
CTLEOF
  cat >> "$BIN_CTL" <<'CTLEOF'
C_OK=$'\033[32m'; C_W=$'\033[33m'; C_E=$'\033[31m'; C_0=$'\033[0m'

# 返回 HTTP 状态码；连接失败时 curl 自己就输出 000
probe() {
  local c
  c=$(curl -s -o /dev/null -m 5 -w '%{http_code}' "http://127.0.0.1:$1/" 2>/dev/null)
  printf '%s' "${c:-000}"
}

# 端口到底有没有在 LISTEN —— 用来区分"被占用/没启动"和"启动了但不响应"
listening() {
  [ "$(ss -Hlnt "sport = :$1" 2>/dev/null | wc -l)" -gt 0 ]
}

log() {
  echo "$(date '+%F %T') $*" >> "$LOG"
  [ -f "$LOG" ] && [ "$(stat -c%s "$LOG" 2>/dev/null || echo 0)" -gt 1048576 ] && mv -f "$LOG" "$LOG.1"
  return 0
}

case "${1:-status}" in
  status)
    printf '服务: %s\n' "$(systemctl is-active "$SVC" 2>/dev/null)"
    printf '启动: %s\n' "$(systemctl show -p ActiveEnterTimestamp --value "$SVC" 2>/dev/null)"
    printf '重启次数: %s   内存: %s\n' \
      "$(systemctl show -p NRestarts --value "$SVC" 2>/dev/null)" \
      "$(systemctl show -p MemoryCurrent --value "$SVC" 2>/dev/null | awk '{printf "%.1f MB", $1/1048576}')"
    echo '--- 端口实测 ---'
    bad=0; notlisten=0
    for p in $PORTS; do
      c=$(probe "$p")
      if [ "$c" != "000" ]; then
        printf '  %-6s %s通%s  HTTP %s\n' "$p" "$C_OK" "$C_0" "$c"
        continue
      fi
      bad=$((bad + 1))
      if listening "$p"; then
        printf '  %-6s %s不通%s  已监听但无响应（上游慢或线程卡住）\n' "$p" "$C_E" "$C_0"
      else
        printf '  %-6s %s不通%s  %s没在监听%s（端口被占用 / 启动失败）\n' \
          "$p" "$C_E" "$C_0" "$C_W" "$C_0"
        notlisten=$((notlisten + 1))
      fi
    done
    if [ "$notlisten" -gt 0 ]; then
      printf '\n%s注意：%d 个端口根本没在监听，重启没用，先查谁占着：%s\n' \
        "$C_W" "$notlisten" "$C_0"
      printf '  ss -lntp | grep -E ":(3140[0-9])"\n'
      printf '  journalctl -u %s -n 30 --no-pager | grep "FAIL listen"\n' "$SVC"
    fi
    if [ "$bad" -gt 0 ]; then
      printf '\n%s%d 个端口不通。手动重启: pi_proxy_ctl restart%s\n' "$C_W" "$bad" "$C_0"
    fi
    ;;
  health|check)
    bad=0; total=0
    for p in $PORTS; do
      total=$((total + 1))
      [ "$(probe "$p")" = "000" ] && bad=$((bad + 1))
    done
    if [ "$bad" -eq 0 ]; then
      echo 0 > "$STATE" 2>/dev/null || true
      exit 0
    fi
    n=$(( $(cat "$STATE" 2>/dev/null || echo 0) + 1 ))
    echo "$n" > "$STATE" 2>/dev/null || true
    log "不通 $bad/$total 个端口（连续第 $n 次）"
    # 连续 2 次异常才动手；5 分钟内不重复重启，避免抖动
    if [ "$n" -ge 2 ]; then
      now=$(date +%s); last=$(cat "$LAST" 2>/dev/null || echo 0)
      if [ $((now - last)) -ge 300 ]; then
        log "连续异常，重启 $SVC"
        systemctl restart "$SVC"
        echo "$now" > "$LAST" 2>/dev/null || true
        sleep 3
        if [ "$(probe "${PORTS%% *}")" = "000" ]; then
          log "重启后仍不通，检查端口占用 / 上游可达性"
        else
          log "重启后已恢复"
        fi
      else
        log "距上次重启不足 5 分钟，跳过（避免反复重启）"
      fi
      echo 0 > "$STATE" 2>/dev/null || true
    fi
    ;;
  restart|start|stop)
    systemctl "$1" "$SVC"
    printf '%s %s\n' "$1" "$SVC"
    ;;
  logs)
    journalctl -u "$SVC" -n "${2:-50}" --no-pager
    ;;
  *)
    echo "用法: $0 [status|health|restart|start|stop|logs]"
    exit 1
    ;;
esac
CTLEOF
  chmod 755 "$BIN_CTL"
}

# ==============================================================
#  三、安装 / 卸载
# ==============================================================
write_unit() {
  cat > "$UNIT" <<UNITEOF
[Unit]
Description=Pi port proxy (${PI_PORTS} -> ${PI_TARGET})
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
# 注意：必须用引号包住。systemd 的 Environment= 按空格切分成多个赋值，
# 不加引号时 "PI_PORT_LIST=31400 31401 ..." 只有第一个生效，其余全部被忽略，
# 表现为「只有 31400 在监听，其余端口不通」。
Environment="PI_PORT_LIST=${PORT_LIST}"
Environment="PI_TARGET=${PI_TARGET}"
Environment="PI_TIMEOUT=${PI_TIMEOUT}"
Environment="PI_MAX_CONN=${PI_MAX_CONN}"
ExecStart=$(command -v python3 || echo /usr/bin/python3) ${BIN_PY}
Restart=always
RestartSec=2
LimitNOFILE=65535
KillSignal=SIGTERM

[Install]
WantedBy=multi-user.target
UNITEOF
}

install_cron() {
  local tmp; tmp=$(mktemp)
  crontab -l 2>/dev/null | awk -v t="$CRON_TAG" '$0==t{skip=1;next} skip==1{skip=0;next} {print}' > "$tmp"
  {
    echo "$CRON_TAG"
    echo "* * * * * /bin/bash $BIN_CTL health >/dev/null 2>&1"
  } >> "$tmp"
  crontab "$tmp" && rm -f "$tmp"
}

do_install() {
  [ "$(id -u)" = 0 ] || die "请用 root 执行"
  command -v python3 >/dev/null 2>&1 || die "没装 python3，请先 apt install -y python3"
  command -v systemctl >/dev/null 2>&1 || die "没有 systemd，请用 run 模式配自己的守护"

  say "安装 v${VERSION}：${PI_PORTS} → ${PI_TARGET}"
  write_server && say "已写 $BIN_PY"
  write_ctl    && say "已写 $BIN_CTL"
  write_unit   && say "已写 $UNIT"
  if install_cron; then say "已加健康检查（每分钟实测，连续 2 次不通才重启）"; fi

  systemctl daemon-reload
  systemctl enable "$SVC" >/dev/null 2>&1 || true
  # 注意：enable --now 对已在运行的服务是空操作，升级重装时新代码不会生效，
  #       这里必须显式 restart，否则重跑安装脚本等于什么都没换。
  systemctl restart "$SVC" >/dev/null 2>&1 || systemctl start "$SVC" >/dev/null 2>&1 || true
  sleep 2

  if systemctl is-active --quiet "$SVC"; then
    printf '\n'
    bash "$BIN_CTL" status
    # 自检：实际 LISTEN 的端口数必须等于期望值，否则直接说清楚缺了哪些
    live=0; missing=""
    for p in $PORT_LIST; do
      if [ "$(ss -Hlnt "sport = :$p" 2>/dev/null | wc -l)" -gt 0 ]; then
        live=$((live + 1))
      else
        missing="$missing $p"
      fi
    done
    if [ "$live" -lt "$PORT_COUNT" ]; then
      printf '\n'
      warn "只监听了 $live/$PORT_COUNT 个端口，缺：$missing"
      warn "不是端口占用的话，多半是 unit 里 Environment 被 systemd 截断："
      warn "  journalctl -u $SVC -n 30 | grep 'Invalid environment assignment'"
    fi
  else
    err "启动失败，日志："
    journalctl -u "$SVC" -n 25 --no-pager
    exit 1
  fi
}

do_uninstall() {
  [ "$(id -u)" = 0 ] || die "请用 root 执行"
  systemctl disable --now "$SVC" >/dev/null 2>&1
  rm -f "$UNIT" "$BIN_PY" "$BIN_CTL"
  systemctl daemon-reload >/dev/null 2>&1
  local tmp; tmp=$(mktemp)
  crontab -l 2>/dev/null | awk -v t="$CRON_TAG" '$0==t{skip=1;next} skip==1{skip=0;next} {print}' > "$tmp"
  crontab "$tmp" 2>/dev/null; rm -f "$tmp"
  say "已卸载（单元、cron、服务文件都清掉了，端口已释放）"
}

# ==============================================================
#  四、入口
# ==============================================================

# 用 bash <(curl ...) 执行时 $0 是 /dev/fd/NN（管道，读一次就没了），
# 所以帮助文本写死在脚本里，不再 sed 读自身。
usage() {
  cat <<USAGE
pi_port_proxy.sh  v${VERSION}
监听 31400-31409，把 http://<IP>:3140X 反代到 Pi 测试网 API

用法:
  bash pi_port_proxy.sh             安装 + 开机自启 + 健康自愈（推荐）
  bash pi_port_proxy.sh status      查看状态（每个端口实测）
  bash pi_port_proxy.sh health      立即体检一次
  bash pi_port_proxy.sh restart     重启
  bash pi_port_proxy.sh logs        看最近日志
  bash pi_port_proxy.sh run         前台运行（调试，Ctrl+C 停）
  bash pi_port_proxy.sh uninstall   卸载

可覆盖的环境变量:
  PI_PORTS=31400-31409     监听端口范围
  PI_TARGET=https://...    上游地址
  PI_TIMEOUT=8             上游超时（秒）
  PI_MAX_CONN=128          单端口最大并发

安装后日常管理（已安装时用这个更省事）:
  pi_proxy_ctl status | health | restart | logs
USAGE
}

# 在 bash <(curl ...) 场景下 $0 不是真实文件，提示里给个能用的替代路径
self_hint() {
  if [ -f "$0" ] && [ -r "$0" ]; then printf '%s' "$0"; else printf '/tmp/pi.sh'; fi
}

case "${1:-install}" in
  install|"")
    do_install ;;
  uninstall|remove)
    do_uninstall ;;
  run)
    export PI_PORT_LIST="$PORT_LIST" PI_TARGET PI_TIMEOUT PI_MAX_CONN
    if [ -f "$BIN_PY" ]; then
      exec python3 "$BIN_PY"
    else
      tmp_py=$(mktemp --suffix=.py)
      save_py="$BIN_PY"; BIN_PY="$tmp_py"
      write_server; BIN_PY="$save_py"
      exec python3 "$tmp_py"
    fi ;;
  status|health|check|restart|start|stop|logs)
    [ -x "$BIN_CTL" ] || die "还没安装，先执行：bash $(self_hint) install"
    exec bash "$BIN_CTL" "$@" ;;
  -v|--version|version)
    echo "$VERSION" ;;
  -h|--help|help|*)
    usage ;;
esac
