#!/bin/sh

VERSION="1.0.0"
FORMAT="owrt-full-backup-v1"
DEFAULT_OUTPUT_DIR="/tmp"
WORKDIR=""

log() {
	printf '%s\n' "$*" >&2
}

warn() {
	printf 'ВНИМАНИЕ: %s\n' "$*" >&2
}

die() {
	printf 'ОШИБКА: %s\n' "$*" >&2
	exit 1
}

cleanup() {
	if [ -n "$WORKDIR" ] && [ -d "$WORKDIR" ]; then
		rm -rf "$WORKDIR"
	fi
}

trap cleanup EXIT INT TERM

usage() {
	cat <<'EOF'
Использование:
  owrt-full-backup create [options]
  owrt-full-backup restore <archive.tar.gz> [options]
  owrt-full-backup inspect <archive.tar.gz>
  owrt-full-backup help

Опции создания:
  -o, --output-dir DIR       Папка для итогового архива
  -n, --name NAME            Имя архива без .tar.gz
      --no-overlay           Не добавлять снимок /overlay/upper
      --include-rom          Добавить read-only снимок /rom
      --firmware-image FILE  Скопировать sysupgrade-образ в архив
      --include-raw-mtd      Добавить dump разделов /dev/mtd*

Опции восстановления:
      --yes                  Не спрашивать подтверждение
      --no-configs           Не восстанавливать sysupgrade config backup
      --no-packages          Не переустанавливать пакеты из списка
      --overlay              Восстановить снимок /overlay/upper в /
      --flash-firmware       Прошить firmware image из архива через sysupgrade

Примеры:
  owrt-full-backup create -o /mnt/usb
  owrt-full-backup create -o /mnt/usb --firmware-image /tmp/openwrt.bin
  owrt-full-backup restore /mnt/usb/router-backup.tar.gz --yes
EOF
}

need_cmd() {
	command -v "$1" >/dev/null 2>&1 || die "нужная команда не найдена: $1"
}

make_workdir() {
	local base
	base="${1:-${TMPDIR:-/tmp}}"
	[ -d "$base" ] || base="${TMPDIR:-/tmp}"
	WORKDIR="$(mktemp -d "$base/owrt-full-backup.XXXXXX" 2>/dev/null || true)"
	if [ -z "$WORKDIR" ] || [ ! -d "$WORKDIR" ]; then
		WORKDIR="$base/owrt-full-backup.$$"
		mkdir -p "$WORKDIR" || die "не удалось создать временную папку: $WORKDIR"
	fi
}

abs_path() {
	local path
	path="$1"
	if command -v readlink >/dev/null 2>&1; then
		readlink -f "$path" 2>/dev/null && return
	fi
	(cd "$path" 2>/dev/null && pwd -P) || printf '%s\n' "$path"
}

is_tmp_path() {
	local path
	path="$(abs_path "$1")"
	case "$path" in
		/tmp|/tmp/*) return 0 ;;
		*) return 1 ;;
	esac
}

uci_get() {
	local key default value
	key="$1"
	default="$2"
	if command -v uci >/dev/null 2>&1; then
		value="$(uci -q get "fullbackup.main.$key" 2>/dev/null || true)"
		if [ -n "$value" ]; then
			printf '%s' "$value"
			return
		fi
	fi
	printf '%s' "$default"
}

copy_if_exists() {
	local src dst
	src="$1"
	dst="$2"
	if [ -e "$src" ]; then
		cp -p "$src" "$dst" 2>/dev/null || cp "$src" "$dst" 2>/dev/null || true
	fi
}

sanitize() {
	printf '%s' "$1" | tr -cs 'A-Za-z0-9._-' '_'
}

hostname_safe() {
	local name
	name="$(hostname 2>/dev/null || printf 'openwrt')"
	sanitize "$name"
}

board_name() {
	if [ -r /tmp/sysinfo/board_name ]; then
		cat /tmp/sysinfo/board_name
		return
	fi

	if [ -r /etc/openwrt_release ]; then
		(
			. /etc/openwrt_release 2>/dev/null
			printf '%s' "${DISTRIB_TARGET:-openwrt}"
		)
		return
	fi

	printf 'openwrt'
}

release_text() {
	if [ -r /etc/openwrt_release ]; then
		(
			. /etc/openwrt_release 2>/dev/null
			printf '%s %s' "${DISTRIB_ID:-OpenWrt}" "${DISTRIB_RELEASE:-unknown}"
		)
		return
	fi

	printf 'OpenWrt unknown'
}

write_command_output() {
	local out
	out="$1"
	shift
	"$@" >"$out" 2>"$out.err" || true
	if [ ! -s "$out.err" ]; then
		rm -f "$out.err"
	fi
}

validate_tar_paths() {
	local archive label
	archive="$1"
	label="$2"

	if tar -tzf "$archive" | grep -Eq '(^/|(^|/)\.\.(/|$))'; then
		die "$label содержит небезопасные пути"
	fi
}

create_metadata() {
	local meta packages firmware
	meta="$WORKDIR/meta"
	packages="$WORKDIR/packages"
	firmware="$WORKDIR/firmware"
	mkdir -p "$meta" "$packages" "$firmware"

	cat >"$WORKDIR/MANIFEST" <<EOF
format=$FORMAT
tool_version=$VERSION
created_at_utc=$(date -u '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null || date)
hostname=$(hostname 2>/dev/null || printf 'openwrt')
board=$(board_name)
release=$(release_text)
kernel=$(uname -a 2>/dev/null || true)
EOF

	copy_if_exists /etc/openwrt_release "$meta/openwrt_release"
	copy_if_exists /etc/openwrt_version "$meta/openwrt_version"
	copy_if_exists /etc/board.json "$meta/board.json"
	copy_if_exists /etc/sysupgrade.conf "$meta/sysupgrade.conf"
	copy_if_exists /proc/mtd "$meta/proc-mtd.txt"
	copy_if_exists /proc/partitions "$meta/proc-partitions.txt"

	write_command_output "$meta/uname.txt" uname -a
	write_command_output "$meta/mounts.txt" mount
	write_command_output "$meta/df-h.txt" df -h

	if command -v ubus >/dev/null 2>&1; then
		write_command_output "$meta/system-board.json" ubus call system board
	fi

	if command -v uci >/dev/null 2>&1; then
		write_command_output "$meta/uci-show.txt" uci show
	fi

	if command -v opkg >/dev/null 2>&1; then
		write_command_output "$packages/installed.txt" opkg list-installed
		write_command_output "$packages/print-architecture.txt" opkg print-architecture
		write_command_output "$packages/changed-conffiles.txt" opkg list-changed-conffiles
		copy_if_exists /usr/lib/opkg/status "$packages/opkg-status"
	else
		printf 'opkg недоступен на этой системе.\n' >"$packages/installed.txt"
	fi

	cat >"$firmware/README.txt" <<'EOF'
OpenWrt обычно не хранит исходный sysupgrade-образ на роутере.
Используй --firmware-image /path/to/openwrt-sysupgrade.bin при создании
бэкапа, если хочешь добавить в архив прошиваемый firmware image.

Raw MTD dumps можно добавить через --include-raw-mtd, но они завязаны на
конкретное железо и разметку flash. Прошивка таких dump на другом устройстве
или другой разметке может окончательно сломать роутер.
EOF
}

create_sysupgrade_backup() {
	if command -v sysupgrade >/dev/null 2>&1; then
		if sysupgrade -b "$WORKDIR/config-backup.tar.gz" >/dev/null 2>"$WORKDIR/meta/sysupgrade-backup.err"; then
			rm -f "$WORKDIR/meta/sysupgrade-backup.err"
		else
			warn "sysupgrade config backup не сработал; делаю fallback-снимок /etc"
			tar -czf "$WORKDIR/config-backup.tar.gz" -C / etc 2>"$WORKDIR/meta/etc-backup.err" || die "не удалось создать config backup"
		fi
		sysupgrade -l >"$WORKDIR/meta/sysupgrade-file-list.txt" 2>/dev/null || true
	else
		warn "команда sysupgrade не найдена; делаю tar-снимок /etc"
		tar -czf "$WORKDIR/config-backup.tar.gz" -C / etc 2>"$WORKDIR/meta/etc-backup.err" || die "не удалось создать config backup"
	fi
}

create_overlay_snapshot() {
	if [ ! -d /overlay/upper ]; then
		printf 'Папка /overlay/upper на этой системе не найдена.\n' >"$WORKDIR/overlay-upper.README.txt"
		return
	fi

	if tar -czf "$WORKDIR/overlay-upper.tar.gz" -C /overlay/upper . 2>"$WORKDIR/meta/overlay-upper.err"; then
		rm -f "$WORKDIR/meta/overlay-upper.err"
	else
		warn "снимок overlay не получился; бэкап продолжится без него"
		rm -f "$WORKDIR/overlay-upper.tar.gz"
	fi
}

create_rom_snapshot() {
	if [ ! -d /rom ]; then
		printf 'Папка /rom на этой системе не найдена.\n' >"$WORKDIR/rom-rootfs.README.txt"
		return
	fi

	if tar -czf "$WORKDIR/rom-rootfs.tar.gz" -C /rom . 2>"$WORKDIR/meta/rom-rootfs.err"; then
		rm -f "$WORKDIR/meta/rom-rootfs.err"
	else
		warn "снимок ROM rootfs не получился; бэкап продолжится без него"
		rm -f "$WORKDIR/rom-rootfs.tar.gz"
	fi
}

copy_firmware_image() {
	local image base
	image="$1"
	[ -n "$image" ] || return
	[ -r "$image" ] || die "firmware image недоступен для чтения: $image"

	base="$(basename "$image")"
	mkdir -p "$WORKDIR/firmware"
	cp "$image" "$WORKDIR/firmware/$base" || die "не удалось скопировать firmware image"
	if command -v sha256sum >/dev/null 2>&1; then
		(
			cd "$WORKDIR/firmware" && sha256sum "$base" >"$base.sha256"
		) || true
	fi
	printf '%s\n' "$base" >"$WORKDIR/firmware/IMAGE"
}

dump_raw_mtd() {
	local raw line dev name safe out
	if [ ! -r /proc/mtd ]; then
		warn "/proc/mtd недоступен; raw MTD dump пропущен"
		return
	fi

	raw="$WORKDIR/raw-mtd"
	mkdir -p "$raw"
	cp /proc/mtd "$raw/proc-mtd.txt" 2>/dev/null || true

	while IFS= read -r line; do
		case "$line" in
			mtd*:*)
				dev="${line%%:*}"
				name="$(printf '%s\n' "$line" | sed 's/.*"\(.*\)".*/\1/')"
				safe="$(sanitize "$name")"
				if [ -e "/dev/$dev" ]; then
					log "Сохраняю /dev/$dev ($name)"
					out="$raw/$dev-$safe.bin"
					if dd if="/dev/$dev" of="$out" bs=64k 2>"$raw/$dev-$safe.dd.log"; then
						:
					else
						rm -f "$out"
						warn "не удалось сохранить /dev/$dev"
					fi
				fi
				;;
		esac
	done </proc/mtd
}

prune_old_backups() {
	local output_dir keep_days
	output_dir="$1"
	keep_days="$2"

	case "$keep_days" in
		''|0) return ;;
	esac

	case "$keep_days" in
		*[!0-9]*)
			warn "keep_days должен быть числом; очистка пропущена"
			return
			;;
	esac

	find "$output_dir" -type f -name '*-owrt-full-backup.tar.gz' -mtime "+$keep_days" -exec rm -f {} \; 2>/dev/null || true
	find "$output_dir" -type f -name '*-owrt-full-backup.tar.gz.sha256' -mtime "+$keep_days" -exec rm -f {} \; 2>/dev/null || true
}

cmd_create() {
	local output_dir name include_overlay include_rom include_raw_mtd firmware_image timestamp host board archive keep_days
	output_dir="$(uci_get output_dir "$DEFAULT_OUTPUT_DIR")"
	include_overlay="$(uci_get include_overlay 1)"
	include_rom="$(uci_get include_rom 0)"
	include_raw_mtd="$(uci_get include_raw_mtd 0)"
	keep_days="$(uci_get keep_days 0)"
	name=""
	firmware_image=""

	while [ $# -gt 0 ]; do
		case "$1" in
			-o|--output-dir)
				[ $# -ge 2 ] || die "$1 требует папку"
				output_dir="$2"
				shift 2
				;;
			-n|--name)
				[ $# -ge 2 ] || die "$1 требует имя"
				name="$2"
				shift 2
				;;
			--no-overlay)
				include_overlay=0
				shift
				;;
			--include-rom)
				include_rom=1
				shift
				;;
			--firmware-image)
				[ $# -ge 2 ] || die "$1 требует файл"
				firmware_image="$2"
				shift 2
				;;
			--include-raw-mtd)
				include_raw_mtd=1
				shift
				;;
			-h|--help)
				usage
				exit 0
				;;
			*)
				die "неизвестная опция create: $1"
				;;
		esac
	done

	need_cmd tar
	need_cmd gzip
	mkdir -p "$output_dir" || die "не удалось создать папку для архива: $output_dir"
	if [ "$include_raw_mtd" = "1" ] && is_tmp_path "$output_dir"; then
		die "raw MTD dump нельзя сохранять в /tmp: там обычно мало RAM. Укажи USB/диск, например /mnt/usb, или отключи raw MTD dump."
	fi
	make_workdir "$output_dir"

	timestamp="$(date '+%Y%m%d-%H%M%S' 2>/dev/null || date '+%s')"
	host="$(hostname_safe)"
	board="$(sanitize "$(board_name)")"
	if [ -z "$name" ]; then
		name="$host-$board-$timestamp-owrt-full-backup"
	fi
	archive="$output_dir/$name.tar.gz"

	log "Готовлю временную папку для бэкапа"
	create_metadata
	create_sysupgrade_backup

	if [ "$include_overlay" = "1" ]; then
		log "Добавляю снимок overlay"
		create_overlay_snapshot
	else
		printf 'Снимок overlay отключен опцией.\n' >"$WORKDIR/overlay-upper.README.txt"
	fi

	if [ "$include_rom" = "1" ]; then
		log "Добавляю снимок ROM rootfs"
		create_rom_snapshot
	else
		printf 'Снимок ROM rootfs отключен опцией.\n' >"$WORKDIR/rom-rootfs.README.txt"
	fi

	copy_firmware_image "$firmware_image"

	if [ "$include_raw_mtd" = "1" ]; then
		warn "raw MTD dumps завязаны на конкретное устройство и могут быть очень большими"
		dump_raw_mtd
	fi

	if tar -czf "$archive" -C "$WORKDIR" .; then
		:
	else
		die "не удалось создать архив: $archive"
	fi

	if command -v sha256sum >/dev/null 2>&1; then
		sha256sum "$archive" >"$archive.sha256" 2>/dev/null || true
	fi

	prune_old_backups "$output_dir" "$keep_days"
	log "Бэкап создан: $archive"
	if [ -f "$archive.sha256" ]; then
		log "Checksum создан: $archive.sha256"
	fi
}

extract_archive() {
	local archive
	archive="$1"
	[ -r "$archive" ] || die "архив недоступен для чтения: $archive"
	need_cmd tar
	need_cmd gzip
	validate_tar_paths "$archive" "archive"
	make_workdir
	tar -xzf "$archive" -C "$WORKDIR" || die "не удалось распаковать архив"
	[ -r "$WORKDIR/MANIFEST" ] || die "в архиве нет MANIFEST"
	grep -q "^format=$FORMAT" "$WORKDIR/MANIFEST" || die "неподдерживаемый формат бэкапа"
}

show_manifest_summary() {
	local count
	if [ -r "$WORKDIR/MANIFEST" ]; then
		sed -n '1,40p' "$WORKDIR/MANIFEST"
	fi

	if [ -r "$WORKDIR/packages/installed.txt" ]; then
		count="$(grep -c ' - ' "$WORKDIR/packages/installed.txt" 2>/dev/null)"
		[ -n "$count" ] || count=0
		printf 'installed_packages_count=%s\n' "$count"
	fi

	if [ -r "$WORKDIR/firmware/IMAGE" ]; then
		printf 'firmware_image=%s\n' "$(cat "$WORKDIR/firmware/IMAGE")"
	else
		printf 'firmware_image=not_included\n'
	fi

	if [ -r "$WORKDIR/overlay-upper.tar.gz" ]; then
		printf 'overlay_snapshot=included\n'
	else
		printf 'overlay_snapshot=not_included\n'
	fi

	if [ -r "$WORKDIR/rom-rootfs.tar.gz" ]; then
		printf 'rom_rootfs_snapshot=included\n'
	else
		printf 'rom_rootfs_snapshot=not_included\n'
	fi

	if [ -d "$WORKDIR/raw-mtd" ]; then
		printf 'raw_mtd=included\n'
	else
		printf 'raw_mtd=not_included\n'
	fi
}

confirm_restore() {
	local yes answer
	yes="$1"
	if [ "$yes" = "1" ]; then
		return
	fi

	printf 'Это изменит файлы на OpenWrt-устройстве. Введи "yes" для продолжения: ' >&2
	read -r answer
	[ "$answer" = "yes" ] || die "восстановление отменено"
}

restore_configs() {
	if [ ! -r "$WORKDIR/config-backup.tar.gz" ]; then
		warn "config-backup.tar.gz не найден; восстановление настроек пропущено"
		return
	fi

	log "Восстанавливаю config backup"
	validate_tar_paths "$WORKDIR/config-backup.tar.gz" "config backup"
	tar -xzpf "$WORKDIR/config-backup.tar.gz" -C / || die "восстановление настроек не удалось"
}

restore_packages() {
	local installed line pkg failed
	installed="$WORKDIR/packages/installed.txt"
	[ -r "$installed" ] || {
		warn "список пакетов не найден; восстановление пакетов пропущено"
		return
	}

	if ! command -v opkg >/dev/null 2>&1; then
		warn "opkg не найден; восстановление пакетов пропущено"
		return
	fi

	log "Обновляю списки пакетов"
	opkg update || warn "opkg update не сработал; установка пакетов все равно будет попробована"

	failed=0
	while IFS= read -r line; do
		case "$line" in
			*' - '*)
				pkg="${line%% - *}"
				;;
			*)
				continue
				;;
		esac

		if opkg status "$pkg" 2>/dev/null | grep -q '^Status:.* installed'; then
			continue
		fi

		log "Устанавливаю пакет: $pkg"
		if ! opkg install "$pkg"; then
			warn "не удалось установить пакет: $pkg"
			failed=1
		fi
	done <"$installed"

	if [ "$failed" = "1" ]; then
		warn "часть пакетов не установилась; проверь совместимость feeds с этой версией OpenWrt"
	fi
}

restore_overlay() {
	if [ ! -r "$WORKDIR/overlay-upper.tar.gz" ]; then
		warn "снимок overlay не найден; восстановление overlay пропущено"
		return
	fi

	warn "overlay лучше восстанавливать на том же устройстве и той же версии OpenWrt"
	log "Восстанавливаю overlay snapshot в /"
	validate_tar_paths "$WORKDIR/overlay-upper.tar.gz" "overlay snapshot"
	tar -xzpf "$WORKDIR/overlay-upper.tar.gz" -C / || die "восстановление overlay не удалось"
}

flash_firmware() {
	local image_name image_path
	[ -r "$WORKDIR/firmware/IMAGE" ] || die "в архиве нет firmware image"
	image_name="$(cat "$WORKDIR/firmware/IMAGE")"
	case "$image_name" in
		*/*|../*|*/../*|..)
			die "имя firmware image небезопасно"
			;;
	esac
	image_path="$WORKDIR/firmware/$image_name"
	[ -r "$image_path" ] || die "firmware image указан в архиве, но файл отсутствует: $image_name"
	command -v sysupgrade >/dev/null 2>&1 || die "команда sysupgrade не найдена"

	warn "sysupgrade прошьет firmware и перезагрузит устройство"
	sysupgrade "$image_path"
}

cmd_restore() {
	local archive yes do_configs do_packages do_overlay do_flash
	[ $# -ge 1 ] || die "restore требует путь к архиву"
	archive="$1"
	shift

	yes=0
	do_configs=1
	do_packages=1
	do_overlay=0
	do_flash=0

	while [ $# -gt 0 ]; do
		case "$1" in
			--yes)
				yes=1
				shift
				;;
			--no-configs)
				do_configs=0
				shift
				;;
			--no-packages)
				do_packages=0
				shift
				;;
			--overlay)
				do_overlay=1
				shift
				;;
			--flash-firmware)
				do_flash=1
				shift
				;;
			-h|--help)
				usage
				exit 0
				;;
			*)
				die "неизвестная опция restore: $1"
				;;
		esac
	done

	extract_archive "$archive"
	show_manifest_summary >&2
	confirm_restore "$yes"

	if [ "$do_flash" = "1" ]; then
		flash_firmware
		return
	fi

	if [ "$do_configs" = "1" ]; then
		restore_configs
	fi

	if [ "$do_packages" = "1" ]; then
		restore_packages
	fi

	if [ "$do_overlay" = "1" ]; then
		restore_overlay
	fi

	log "Восстановление завершено. Рекомендуется перезагрузка."
}

cmd_inspect() {
	[ $# -ge 1 ] || die "inspect требует путь к архиву"
	extract_archive "$1"
	show_manifest_summary
}

main() {
	local cmd
	cmd="${1:-help}"
	case "$cmd" in
		create)
			shift
			cmd_create "$@"
			;;
		restore)
			shift
			cmd_restore "$@"
			;;
		inspect)
			shift
			cmd_inspect "$@"
			;;
		help|-h|--help)
			usage
			;;
		*)
			die "неизвестная команда: $cmd"
			;;
	esac
}

main "$@"
