#!/bin/sh
# modem-man watchdog daemon
# Следит за WAN-соединениями модемов и восстанавливает связь.
#
# Проверка связи (connectivity_ok), по порядку и до первого успеха:
#   1) свежий handshake WireGuard — только если маршрут до endpoint идёт через
#      интерфейс модема (бесплатно, не тратит трафик SIM);
#   2) HTTP(S)-пробы через интерфейс модема (несколько адресов);
#   3) ping.
#
# Восстановление зависит от того, ЧТО сломалось:
#   - SIM нет / заблокирована (PIN, PUK) — чинить нечего: ждём, не эскалируем;
#   - в слоте eSIM без включённого профиля — то же: сети не будет, пока профиль
#     не скачан и не включён, переподключения и сброс модема ничего не дадут;
#   - модем отвечает (AT или QMI), но сети/данных нет (нет покрытия, APN, тариф,
#     белые списки) — «мягкий» режим: переподключение с растущей паузой
#     (recover_wait → ×2 → … → backoff_max), сброс модема не чаще
#     reset_min_interval;
#   - модем не отвечает — «жёсткий» режим, лестница: reconnect ×2 → сброс
#     модема (uqmi reset / AT+CFUN=1,1) → переподключение USB → перезагрузка
#     роутера (allow_reboot=1) или снова сброс.
# Запускается через procd, читает /etc/config/modem-man.

. /lib/functions.sh
. /usr/share/libubox/jshn.sh
. /usr/share/modem-man/actions.sh

MM_CONFIG="modem-man"
MM_REBOOT_MARK="/etc/modem-man.lastreboot"
DEFAULT_PROBE_URLS="http://connectivitycheck.gstatic.com/generate_204 http://detectportal.firefox.com/success.txt https://enroll.uavpcb.ru/health"

mkdir -p "$MM_RUNDIR"
# Снять pause, оставшийся от сброса модема, прерванного рестартом/падением демона
# (иначе paused() держит сторож на паузе навсегда).
rm -f "$MM_RUNDIR/pause"

# ---------------------------------------------------------------- статус
save_status() {
	# save_status cfg iface ifname type up message level fails last_ok last_action last_action_ts probe
	local cfg="$1" iface="$2" ifname="$3" type="$4" up="$5" msg="$6" level="$7" fails="$8" last_ok="$9"
	shift 9
	local last_action="$1" last_action_ts="$2" probe="$3"
	json_init
	json_add_string  config "$cfg"
	json_add_string  interface "$iface"
	json_add_string  ifname "$ifname"
	json_add_string  type "$type"
	json_add_boolean up "$([ "$up" = true ] && echo 1 || echo 0)"
	json_add_string  message "$msg"
	json_add_int     timestamp "$(date +%s)"
	json_add_int     level "${level:-0}"
	json_add_int     fails "${fails:-0}"
	json_add_int     last_ok "${last_ok:-0}"
	json_add_string  last_action "$last_action"
	json_add_int     last_action_ts "${last_action_ts:-0}"
	json_add_string  probe "$probe"
	json_dump > "$MM_RUNDIR/${cfg}.json.tmp" && mv "$MM_RUNDIR/${cfg}.json.tmp" "$MM_RUNDIR/${cfg}.json"
	json_cleanup
}

get_real_ifname() {
	ubus call network.interface."$1" status 2>/dev/null \
		| jsonfilter -e "@['l3_device']" 2>/dev/null | head -1
}

# Ждать, пока netifd поднимет интерфейс (после reconnect/сброса), не дольше max_sec.
wait_iface_up() {
	# wait_iface_up netifd_iface max_sec
	local t=0
	while [ "$t" -lt "$2" ]; do
		[ "$(ubus call network.interface."$1" status 2>/dev/null | jsonfilter -e '@.up' 2>/dev/null)" = "true" ] && return 0
		sleep 2; t=$((t + 2))
	done
	return 1
}

iface_pending() {
	[ "$(ubus call network.interface."$1" status 2>/dev/null | jsonfilter -e '@.pending' 2>/dev/null)" = "true" ]
}

# Устройство модема из /etc/config/network задано и его нет в /dev — модем не
# подключён (роутер без модема, USB пропал, модем перезагружается).
modem_absent() {
	local dev
	dev="$(uci -q get "network.$1.device")"
	[ -n "$dev" ] || return 1
	[ -e "$dev" ] && return 1
	MODEM_DEV="$dev"
	return 0
}

# Флаг паузы считается действующим, если он моложе pause_max_age секунд.
# Устаревший флаг (его владелец — rpcd-плагин eSIM, rc-shell — умер, не сняв)
# удаляется с записью в лог: иначе сторож стоял бы на паузе до перезагрузки.
flag_active() {
	# flag_active file max_age_sec
	local f="$1" max_min=$(( ${2:-300} / 60 ))
	[ -f "$f" ] || return 1
	[ "$max_min" -gt 0 ] && [ -n "$(find "$f" -mmin +"$max_min" 2>/dev/null)" ] && {
		log "stale pause flag $f (older than ${2}s) removed"
		rm -f "$f"
		return 1
	}
	return 0
}

paused() {
	# Паузы: смена SIM (rc-actions/eSIM: флаг в нашем каталоге; старый путь rc-shell — переходный), сброс модема (наш же шаг),
	# скан сот всех операторов (mainmodem cellscan: ~30 с без передачи данных)
	flag_active /var/run/modem-man/sim_checking "$1" && return 0
	flag_active /var/run/rc-shell/sim_checking "$1" && return 0
	flag_active "$MM_RUNDIR/pause" "$1" && return 0
	flag_active "$MM_RUNDIR/cellscan" "$1" && return 0
	return 1
}

# ---------------------------------------------------------------- проверки
# PROBE_RESULT — чем подтверждена связь: wg:… / url / ping:host
PROBE_RESULT=""

check_http() {
	local ifname="$1" timeout="$2" urls="$3" u code
	command -v curl >/dev/null 2>&1 || return 1
	for u in $urls; do
		code=$(curl -s -o /dev/null -m "$timeout" --interface "$ifname" -w '%{http_code}' "$u" 2>/dev/null)
		case "$code" in
			2??|3??) PROBE_RESULT="$u"; return 0 ;;
		esac
	done
	return 1
}

# Свежий handshake WireGuard подтверждает связь ЧЕРЕЗ МОДЕМ только если пакеты
# к endpoint идут через него. Когда интернет с провода, handshake свежий по
# проводу, а LTE может быть мёртв — тогда проверку пропускаем.
check_wg() {
	local wgif="$1" fresh="$2" ifname="$3" now hs age best=999999 ep via
	[ -n "$wgif" ] || return 1
	command -v wg >/dev/null 2>&1 || return 1
	ep=$(wg show "$wgif" endpoints 2>/dev/null | awk 'NF>1{print $2}' | head -1)
	case "$ep" in
		\[*\]:*) ep="${ep#\[}"; ep="${ep%%\]*}" ;;   # [v6]:port
		*:*:*)   ;;                                   # голый v6 без порта — как есть
		*:*)     ep="${ep%:*}" ;;                     # v4:port
	esac
	if [ -n "$ep" ] && [ "$ep" != "(none)" ]; then
		via=$(ip route get "$ep" 2>/dev/null | sed -n 's/.* dev \([^ ]*\).*/\1/p' | head -1)
		[ -n "$via" ] && [ "$via" != "$ifname" ] && return 1
	fi
	now=$(date +%s)
	for hs in $(wg show "$wgif" latest-handshakes 2>/dev/null | awk '{print $2}'); do
		[ "$hs" -gt 0 ] 2>/dev/null || continue
		age=$((now - hs))
		[ "$age" -lt "$best" ] && best=$age
	done
	[ "$best" -lt "$fresh" ] && { PROBE_RESULT="wg:${wgif}:${best}s"; return 0; }
	return 1
}

check_ping() {
	local hosts="$1" ifname="$2" h
	for h in $hosts; do
		ping -c 2 -W 2 -I "$ifname" "$h" > /dev/null 2>&1 && { PROBE_RESULT="ping:$h"; return 0; }
	done
	return 1
}

connectivity_ok() {
	# connectivity_ok ifname timeout urls wgif wg_fresh ping_hosts
	PROBE_RESULT=""
	check_wg "$4" "$5" "$1" && return 0
	check_http "$1" "$2" "$3" && return 0
	check_ping "$6" "$1" && return 0
	return 1
}

# ---------------------------------------------------------------- состояние модема
# MODEM_SIM   — статус SIM по демону модема (READY / NOT INSERTED / SIM PIN / …)
# MODEM_REG   — регистрация по QMI (registered / searching / not_registered / …)
# MODEM_ALIVE — 1, если модем ответил хотя бы по одному каналу (AT или QMI)
MODEM_SIM=""; MODEM_REG=""; MODEM_ALIVE=0
modem_state() {
	# modem_state cfg type netifd_iface
	local cfg="$1" type="$2" iface="$3" obj js dev
	MODEM_SIM=""; MODEM_REG=""; MODEM_ALIVE=0
	obj="$(mm_ubus_obj "$cfg")"
	if [ -n "$obj" ]; then
		js=$(ubus -t 3 call "$obj" info 2>/dev/null)
		[ "$(echo "$js" | jsonfilter -e '@.connected' 2>/dev/null)" = "true" ] && MODEM_ALIVE=1
		MODEM_SIM=$(ubus -t 3 call "$obj" sim_info 2>/dev/null | jsonfilter -e '@.status' 2>/dev/null)
	fi
	# QMI-запрос только когда netifd не настраивает интерфейс: два uqmi на одном
	# /dev/cdc-wdm0 могут перехватывать ответы друг друга.
	if [ "$type" = qmi ] && ! iface_pending "$iface"; then
		dev="$(mm_dev "$iface")"
		if [ -n "$dev" ] && [ -c "$dev" ] && command -v uqmi >/dev/null 2>&1; then
			MODEM_REG=$(uqmi -s -d "$dev" -t 3000 --get-serving-system 2>/dev/null | jsonfilter -e '@.registration' 2>/dev/null)
			[ -n "$MODEM_REG" ] && MODEM_ALIVE=1
		fi
	fi
}

# eSIM (eUICC) без включённого профиля: карта READY, но подписки на ней нет — модем
# вечно ищет сеть или получает отказ в регистрации. Спрашиваем у luci-app-uavpcb-esim
# (getStatus: chip info + profile list через AT-мост активного слота); пакета нет или
# карта не eUICC — ответ «нет», сторож работает как раньше.
# AIR_11, 2026-11-15: с пустым eUICC сторож каждые полчаса сбрасывал модем.
esim_no_profile() {
	# esim_no_profile cfg
	local js
	[ "$(mm_ubus_obj "$1")" = mainmodem ] || return 1
	ubus list luci.uavpcb-esim >/dev/null 2>&1 || return 1
	js=$(ubus -t 25 call luci.uavpcb-esim getStatus 2>/dev/null) || return 1
	[ "$(echo "$js" | jsonfilter -e '@.euicc_ok' 2>/dev/null)" = "true" ] || return 1
	[ -z "$(echo "$js" | jsonfilter -e '@.profiles[@.profileState="enabled"].iccid' 2>/dev/null)" ]
}

router_reboot() {
	# router_reboot cfg min_uptime min_interval
	local cfg="$1" min_uptime="$2" min_interval="$3" up now last=0
	up=$(cut -d. -f1 /proc/uptime)
	now=$(date +%s)
	[ -f "$MM_REBOOT_MARK" ] && last=$(cat "$MM_REBOOT_MARK" 2>/dev/null)
	if [ "$up" -lt "$min_uptime" ]; then
		log "[$cfg] reboot skipped: uptime ${up}s < ${min_uptime}s"; return 1
	fi
	if [ -n "$last" ] && [ "$last" -gt 0 ] 2>/dev/null && [ $((now - last)) -lt "$min_interval" ]; then
		log "[$cfg] reboot skipped: last watchdog reboot $((now - last))s ago < ${min_interval}s"; return 1
	fi
	echo "$now" > "$MM_REBOOT_MARK"
	log "[$cfg] action: REBOOT (no connectivity after all recovery steps)"
	sync; sleep 2; reboot
	return 0
}

last_reset_ts() {
	cat "$MM_RUNDIR/$1.last_reset" 2>/dev/null || echo 0
}

# ---------------------------------------------------------------- цикл
watch_one() {
	local cfg="$1"
	local enabled type netifd_iface ping_host ping_interval stable_interval watchdog
	local probe_urls probe_timeout wg_iface wg_fresh fail_threshold recover_wait
	local allow_reboot reboot_min_uptime reboot_min_interval max_level
	local backoff_max reset_min_interval pause_max_age

	config_get enabled       "$cfg" enabled       "0"
	config_get type          "$cfg" type          "qmi"
	config_get netifd_iface  "$cfg" netifd_iface  ""
	config_get ping_host     "$cfg" ping_host     "8.8.8.8 77.88.8.8"
	config_get ping_interval "$cfg" ping_interval "30"
	config_get stable_interval "$cfg" stable_interval "60"
	config_get watchdog      "$cfg" watchdog      "1"
	config_get probe_urls    "$cfg" probe_urls    "$DEFAULT_PROBE_URLS"
	config_get probe_timeout "$cfg" probe_timeout "4"
	config_get wg_iface      "$cfg" wg_iface      "wg0"
	config_get wg_fresh      "$cfg" wg_fresh      "180"
	config_get fail_threshold "$cfg" fail_threshold "2"
	config_get recover_wait  "$cfg" recover_wait  "90"
	config_get backoff_max   "$cfg" backoff_max   "1800"
	config_get reset_min_interval "$cfg" reset_min_interval "1800"
	config_get pause_max_age "$cfg" pause_max_age "300"
	config_get allow_reboot  "$cfg" allow_reboot  "0"
	config_get reboot_min_uptime "$cfg" reboot_min_uptime "900"
	config_get reboot_min_interval "$cfg" reboot_min_interval "3600"
	config_get max_level     "$cfg" max_level     "5"

	[ "$enabled" = "1" ] || return
	[ "$watchdog" = "1" ] || return
	[ -n "$netifd_iface" ] || return
	[ "$stable_interval" -ge "$ping_interval" ] 2>/dev/null || stable_interval="$ping_interval"

	log "[$cfg] watchdog started (iface=$netifd_iface, type=$type, interval=${ping_interval}/${stable_interval}s, probes: wg:$wg_iface + $(echo $probe_urls | wc -w) url + ping)"

	local fails=0 level=0 last_ok=0 last_action="" last_action_ts=0 ifname no_modem=0
	local hold="$recover_wait" hold_reason="" interval now mode msg

	# После действия: дождаться up и проверить связь. Успех — сбросить состояние
	# восстановления (переменные цикла) и вернуть 0.
	confirm_after_action() {
		# confirm_after_action netifd_iface max_wait
		wait_iface_up "$1" "$2" || return 1
		sleep 5
		ifname="$(get_real_ifname "$1")"
		[ -n "$ifname" ] || return 1
		connectivity_ok "$ifname" "$probe_timeout" "$probe_urls" "$wg_iface" "$wg_fresh" "$ping_host" || return 1
		log "[$cfg] connectivity OK via $ifname ($PROBE_RESULT) after $last_action — recovered (level was $level${hold_reason:+, was: $hold_reason})"
		fails=0; level=0; hold="$recover_wait"; hold_reason=""; last_ok=$(date +%s)
		save_status "$cfg" "$1" "$ifname" "$type" "true" "ok" 0 0 "$last_ok" "$last_action" "$last_action_ts" "$PROBE_RESULT"
		return 0
	}

	while true; do
		[ -f "$MM_RUNDIR/stop" ] && exit 0
		# Пока всё хорошо — опрашиваем реже (экономим трафик SIM и ресурс модема)
		if [ "$fails" = 0 ] && [ "$level" = 0 ] && [ -z "$hold_reason" ]; then
			interval="$stable_interval"
		else
			interval="$ping_interval"
		fi
		sleep "$interval"
		[ -f "$MM_RUNDIR/stop" ] && exit 0

		if [ -f "$MM_RUNDIR/hotplug_${netifd_iface}" ]; then
			log "[$cfg] hotplug reconnect in progress, waiting 60s"
			rm -f "$MM_RUNDIR/hotplug_${netifd_iface}"
			fails=0
			sleep 60
			continue
		fi
		if paused "$pause_max_age"; then
			fails=0
			continue
		fi

		ifname="$(get_real_ifname "$netifd_iface")"
		# Модема нет — сторожу нечего чинить: не считаем сбои, не эскалируем.
		# Появление устройства ловит hotplug usbmisc/tty → ifup.
		if [ -z "$ifname" ] && modem_absent "$netifd_iface"; then
			if [ "$no_modem" != 1 ]; then
				log "[$cfg] modem device $MODEM_DEV absent — watchdog idle until hotplug"
				no_modem=1
			fi
			fails=0; level=0; hold="$recover_wait"; hold_reason=""
			save_status "$cfg" "$netifd_iface" "" "$type" "false" "no modem" 0 0 "$last_ok" "$last_action" "$last_action_ts" ""
			continue
		fi
		if [ "$no_modem" = 1 ]; then
			log "[$cfg] modem device present again — watchdog resumed"
			no_modem=0
		fi
		if [ -n "$ifname" ] && connectivity_ok "$ifname" "$probe_timeout" "$probe_urls" "$wg_iface" "$wg_fresh" "$ping_host"; then
			if [ "$fails" -gt 0 ] || [ "$level" -gt 0 ] || [ -n "$hold_reason" ]; then
				log "[$cfg] connectivity OK via $ifname ($PROBE_RESULT) — recovered (level was $level${hold_reason:+, was waiting: $hold_reason})"
			fi
			fails=0; level=0; hold="$recover_wait"; hold_reason=""; last_ok=$(date +%s)
			save_status "$cfg" "$netifd_iface" "$ifname" "$type" "true" "ok" 0 0 "$last_ok" "$last_action" "$last_action_ts" "$PROBE_RESULT"
			continue
		fi

		fails=$((fails + 1))
		if [ -z "$ifname" ]; then
			log "[$cfg] $netifd_iface has no l3 device (fail $fails, level $level)"
			save_status "$cfg" "$netifd_iface" "" "$type" "false" "no l3 device" "$level" "$fails" "$last_ok" "$last_action" "$last_action_ts" ""
		else
			log "[$cfg] no connectivity via $ifname (fail $fails, level $level)"
			save_status "$cfg" "$netifd_iface" "$ifname" "$type" "false" "no connectivity" "$level" "$fails" "$last_ok" "$last_action" "$last_action_ts" ""
		fi
		[ "$fails" -ge "$fail_threshold" ] || continue

		# ---- Что именно сломалось
		modem_state "$cfg" "$type" "$netifd_iface"
		case "$MODEM_SIM" in
			"NOT INSERTED"|"SIM PIN"|"SIM PUK"|"BUSY"|"ERROR")
				# Чинить нечего — ждём SIM/PIN. Сторож продолжает наблюдать:
				# как только SIM станет READY, пойдёт обычное восстановление.
				[ "$hold_reason" = "sim:$MODEM_SIM" ] || \
					log "[$cfg] SIM status '$MODEM_SIM' — nothing to recover, waiting (no escalation)"
				hold_reason="sim:$MODEM_SIM"
				fails=0; level=0; hold="$recover_wait"
				save_status "$cfg" "$netifd_iface" "$ifname" "$type" "false" "no sim ($MODEM_SIM)" 0 0 "$last_ok" "$last_action" "$last_action_ts" ""
				continue
				;;
		esac

		# eSIM без включённого профиля — чинить тоже нечего. Проверяем только когда модем жив
		# и не зарегистрирован: с рабочим профилем сюда не заходим, лишних обращений к карте нет.
		if [ "$MODEM_ALIVE" = 1 ] && [ "$MODEM_REG" != registered ] && esim_no_profile "$cfg"; then
			[ "$hold_reason" = "esim:no profile" ] || \
				log "[$cfg] eSIM has no enabled profile — nothing to recover, waiting (no escalation)"
			hold_reason="esim:no profile"
			fails=0; level=0; hold="$recover_wait"
			save_status "$cfg" "$netifd_iface" "$ifname" "$type" "false" "no esim profile" 0 0 "$last_ok" "$last_action" "$last_action_ts" ""
			continue
		fi

		now=$(date +%s)
		fails=0
		last_action_ts=$now
		if [ "$MODEM_ALIVE" = 1 ]; then
			# ---- Мягкий режим: модем жив, проблема в сети/SIM/тарифе
			case "$MODEM_REG" in
				registered) mode="registered, no data (APN/tariff/whitelist?)" ;;
				"")         mode="modem answers, no connectivity" ;;
				*)          mode="no network ($MODEM_REG)" ;;
			esac
			hold_reason="$mode"
			# сброс модема — только после двух переподключений и не чаще reset_min_interval
			if [ "$level" -ge 2 ] && [ $((now - $(last_reset_ts "$cfg"))) -ge "$reset_min_interval" ]; then
				level=3; last_action="modem_reset"
				log "[$cfg] $mode — modem reset (not more often than every ${reset_min_interval}s)"
				modem_reset "$cfg" "$netifd_iface" "$type"
			else
				level=$((level + 1)); [ "$level" -gt 2 ] && level=2
				last_action="reconnect"
				log "[$cfg] $mode — reconnect, next check in ${hold}s"
				reconnect_iface "$netifd_iface" "$cfg"
			fi
			save_status "$cfg" "$netifd_iface" "$ifname" "$type" "false" "recovering: $mode" "$level" 0 "$last_ok" "$last_action" "$last_action_ts" ""
			# Не спать вслепую: дождаться up (QMI поднимается за 2–5 с) и сразу проверить.
			# Помогло — выходим из восстановления; нет — выдерживаем растущую паузу.
			if confirm_after_action "$netifd_iface" "$hold"; then
				continue
			fi
			sleep "$hold"
			hold=$((hold * 2)); [ "$hold" -gt "$backoff_max" ] && hold="$backoff_max"
			continue
		fi

		# ---- Жёсткий режим: модем не отвечает ни по AT, ни по QMI — лестница
		hold_reason="modem not responding"
		level=$((level + 1))
		if [ "$level" -gt "$max_level" ]; then
			# дальше циклим: сброс модема/USB (если разрешены лестницей), иначе reconnect
			[ "$max_level" -ge 3 ] && level=3 || level=1
		fi
		case "$level" in
			1|2) last_action="reconnect";   reconnect_iface "$netifd_iface" "$cfg" ;;
			3)   last_action="modem_reset"; modem_reset "$cfg" "$netifd_iface" "$type" ;;
			4)   last_action="usb_rebind";  usb_rebind "$cfg" "$netifd_iface" "$ifname" || { last_action="modem_reset"; modem_reset "$cfg" "$netifd_iface" "$type"; } ;;
			*)   if [ "$allow_reboot" = "1" ]; then
					last_action="reboot"
					router_reboot "$cfg" "$reboot_min_uptime" "$reboot_min_interval" || { last_action="modem_reset"; modem_reset "$cfg" "$netifd_iface" "$type"; }
				else
					last_action="modem_reset"; modem_reset "$cfg" "$netifd_iface" "$type"
				fi ;;
		esac
		save_status "$cfg" "$netifd_iface" "$ifname" "$type" "false" "recovering: $hold_reason" "$level" 0 "$last_ok" "$last_action" "$last_action_ts" ""
		# ждём подъёма интерфейса (QMI + SIM + регистрация + connect) не дольше
		# recover_wait и сразу проверяем связь; иначе — следующий уровень после
		# fail_threshold неудач обычного цикла
		confirm_after_action "$netifd_iface" "$recover_wait" || true
	done &
}

config_load "$MM_CONFIG"
config_foreach watch_one modem

trap 'kill $(jobs -p) 2>/dev/null; exit 0' TERM INT
wait
