#!/bin/bash
# -----------------------------------------------------------------------------------------------
# ----------------- UNRAID OPS COMMON LIBRARY (CORE FRAMEWORK v1) -------------------------------
# -----------------------------------------------------------------------------------------------

# ----------------------------- ICON LAYER -----------------------------
ICON_INFO="ℹ️"
ICON_WARN="⚠️"
ICON_ERROR="❌"
ICON_SUCCESS="✅"
ICON_RUN="🚀"
ICON_STOP="🛑"
ICON_RETRY="🔁"
ICON_SYNC="🔄"
ICON_GEAR="⚙️"

# ----------------------------- Output Helpers -----------------------------
info() {
    echo "$ICON_INFO [INFO] $*"
}

warn() {
    echo "$ICON_WARN [WARN] $*"
}

error() {
    echo "$ICON_ERROR [ERROR] $*"
}

success() {
    echo "$ICON_SUCCESS [OK] $*"
}

log() {
    [[ "$ENABLE_LOGGING" == true ]] && echo "[LOG] $*"
}

# ----------------------------- Argument Parsing -----------------------------
parse_args() {
    DRY_RUN=${DRY_RUN:-false}
    ENABLE_LOGGING=${ENABLE_LOGGING:-false}

    for ARG in "$@"; do
        if [[ "$ARG" == *=* ]]; then
            VAR_NAME="${ARG%%=*}"
            VAR_VALUE="${ARG#*=}"

            case "$VAR_NAME" in
                LOG)
                    if [[ "$VAR_VALUE" == "true" ]]; then
                        ENABLE_LOGGING=true
                        info "Verbose logging enabled"
                    elif [[ "$VAR_VALUE" == "false" ]]; then
                        ENABLE_LOGGING=false
                    else
                        warn "Invalid LOG value: $VAR_VALUE"
                    fi
                    ;;
                *)
                    if declare -p "$VAR_NAME" &>/dev/null; then
                        printf -v "$VAR_NAME" '%s' "$VAR_VALUE"
                        log "Overriding $VAR_NAME -> $VAR_VALUE"
                    else
                        warn "Unknown variable $VAR_NAME"
                    fi
                    ;;
            esac

        else
            case "$ARG" in
                --dry-run|-n)
                    DRY_RUN=true
                    info "Dry-run enabled"
                    ;;
                --log)
                    ENABLE_LOGGING=true
                    info "Logging enabled"
                    ;;
                --no-log)
                    ENABLE_LOGGING=false
                    ;;
                --status|--summary)
                    SHOW_STATUS=true
                    ;;
                --help|-h)
                    echo "Usage: script <dir> [--dry-run|-n] [--log] [VAR=value ...]"
                    exit 0
                    ;;
                *)
                    warn "Unknown argument: $ARG"
                    ;;
            esac
        fi
    done
}

# ----------------------------- Validation -----------------------------
require_var() {
    local var="$1"
    [[ -z "${!var:-}" ]] && error "Missing required variable: $var" && exit 1
}

validate_int() {
    local name="$1"
    local value="$2"

    [[ ! "${value:-}" =~ ^[0-9]+$ ]] && error "$name must be integer" && exit 1
}

# ----------------------------- HOST DETECTION -----------------------------
detect_hosts() {
    LOCAL_HOSTNAME="$(hostname)"

    if [[ "$LOCAL_HOSTNAME" == "$HOST1" ]]; then
        LOCAL_SERVER_NAME="$HOST1"
        REMOTE_SERVER_NAME="$HOST2"
    elif [[ "$LOCAL_HOSTNAME" == "$HOST2" ]]; then
        LOCAL_SERVER_NAME="$HOST2"
        REMOTE_SERVER_NAME="$HOST1"
    else
        error "Unknown host: $LOCAL_HOSTNAME"
    fi

    declare -A SSH_KEYS
    SSH_KEYS["$HOST1|$HOST2"]="$HOST1_SSH_KEY"
    SSH_KEYS["$HOST2|$HOST1"]="$HOST2_SSH_KEY"

    SSH_KEY="${SSH_KEYS[$LOCAL_SERVER_NAME|$REMOTE_SERVER_NAME]}"

    [[ -z "$SSH_KEY" ]] && error "Missing SSH key mapping"
    info "Host: $LOCAL_SERVER_NAME → $REMOTE_SERVER_NAME"
}

# ----------------------------- REMOTE -----------------------------
resolve_remote_ip() {
    log "Resolving remote IP..."
    REMOTE_SERVER=$(tailscale ip -4 "$REMOTE_SERVER_NAME" 2>/dev/null)

    [[ -z "$REMOTE_SERVER" ]] && error "Failed to resolve remote IP"
    info "Remote IP: $REMOTE_SERVER"
}

check_remote_online() {
    ping -c 1 "$REMOTE_SERVER" &>/dev/null
}

# ----------------------------- CONTAINERS -----------------------------
declare -a RUNNING_CONTAINERS=()

stop_containers() {
    [[ ${#CRITICAL_CONTAINER_NAMES[@]} -eq 0 ]] && return

    info "Stopping containers..."
    RUNNING_CONTAINERS=()

    for c in "${CRITICAL_CONTAINER_NAMES[@]}"; do
        STATUS=$(ssh -i "$SSH_KEY" root@"$REMOTE_SERVER" \
            "docker inspect -f '{{.State.Running}}' $c 2>/dev/null" || echo "false")

        if [[ "$STATUS" == "true" ]]; then
            warn "Stopping $c"
            RUNNING_CONTAINERS+=("$c")
            ssh -i "$SSH_KEY" root@"$REMOTE_SERVER" "docker stop $c"
        fi
    done
}

start_containers() {
    [[ ${#RUNNING_CONTAINERS[@]} -eq 0 ]] && return

    info "Starting containers..."

    for c in "${RUNNING_CONTAINERS[@]}"; do
        info "Starting $c"
        ssh -i "$SSH_KEY" root@"$REMOTE_SERVER" "docker start $c"
    done
}

# ----------------------------- RSYNC -----------------------------
get_rsync_opts() {
    if [[ -n "${PROFILE_RSYNC_OPTS[$PROFILE_NAME]:-}" ]]; then
        read -r -a RSYNC_OPTS <<< "${PROFILE_RSYNC_OPTS[$PROFILE_NAME]}"
        log "Profile rsync opts loaded"
    else
        RSYNC_OPTS=("${DEFAULT_RSYNC_OPTS[@]}")
        log "Default rsync opts loaded"
    fi
}

# ----------------------------- STATUS -----------------------------
show_status() {
    echo
    echo "================= STATUS ================="
    echo "Local:     $LOCAL_SERVER_NAME"
    echo "Remote:    $REMOTE_SERVER_NAME"
    echo "IP:        $REMOTE_SERVER"
    echo "Profile:   $PROFILE_NAME"
    echo "Dry Run:   $DRY_RUN"
    echo "Logging:   $ENABLE_LOGGING"
    echo "Containers:${CRITICAL_CONTAINER_NAMES[*]:-(none)}"
    echo "========================================="
}