#!/bin/bash
# Methods library for private_ingress — sourced by install-private_ingress.sh
# and generated run-*.sh scripts. SCRIPT_DIR must be set before sourcing.

_kubectl() {
    if command -v kubectl >/dev/null 2>&1; then
        command kubectl "$@"
    elif command -v k0s >/dev/null 2>&1; then
        k0s kubectl "$@"
    else
        echo "ERROR: no kubectl or k0s binary found" >&2; exit 127
    fi
}

_resolve_kubeconfig() {
    if [ -n "${KUBECONFIG:-}" ] && [ -f "$KUBECONFIG" ]; then
        return
    fi
    for candidate in \
        /var/lib/k0s/pki/admin.conf \
        /etc/kubernetes/admin.conf \
        /root/.kube/config; do
        if [ -f "$candidate" ]; then
            export KUBECONFIG="$candidate"
            return
        fi
    done
    if command -v k0s >/dev/null 2>&1; then
        local tmp
        tmp="$(mktemp)"
        k0s kubeconfig admin > "$tmp" 2>/dev/null && export KUBECONFIG="$tmp" && return
        rm -f "$tmp"
    fi
    echo "ERROR: kubeconfig not found — set KUBECONFIG explicitly" >&2; exit 1
}

_wait_for_pod() {
    local timeout="${1:-300}"
    _kubectl wait pod \
        --namespace "$PRIVATE_INGRESS_NAMESPACE" \
        --selector "app.kubernetes.io/name=${PRIVATE_INGRESS_NAME}" \
        --for=condition=Ready \
        --timeout="${timeout}s"
}

_plan_apply() {
    local file="$1"
    local path="$SCRIPT_DIR/manifests/${file}.yaml"
    [ -f "$path" ] || { echo "  [skip] ${file}.yaml not in manifests/"; return 0; }
    local content
    content=$(sed '/^\s*#/d; /^\s*$/d' "$path" | tr -d '[:space:]')
    [ -n "$content" ] || { echo "  [skip] ${file}.yaml has no content"; return 0; }
    _kubectl apply -f "$path"
}

_plan_apply_skip() {
    local file="$1"
    local path="$SCRIPT_DIR/manifests/${file}.yaml"
    [ -f "$path" ] || { echo "  [skip] ${file}.yaml not in manifests/"; return 0; }
    [ -s "$path" ] || { echo "  [skip] ${file}.yaml is empty"; return 0; }
    if _kubectl get -f "$path" >/dev/null 2>&1; then
        echo "  [skip] $file already exists in cluster"
        return 0
    fi
    _kubectl apply -f "$path"
}

_plan_delete() {
    local file="$1"
    local path="$SCRIPT_DIR/manifests/${file}.yaml"
    [ -f "$path" ] || { echo "  [skip] ${file}.yaml not in manifests/"; return 0; }
    _kubectl delete -f "$path" --ignore-not-found
}

_plan_rollout_restart() {
    local file="$1"
    local path="$SCRIPT_DIR/manifests/${file}.yaml"
    [ -f "$path" ] || { echo "  [skip] ${file}.yaml not in manifests/"; return 0; }
    _kubectl rollout restart -f "$path"
}

_method_wait-ready() {
    _wait_for_pod 300
}

_do_install() {
    _plan_apply_skip namespace
    _plan_apply_skip lb-pool
    _plan_apply configmap-sozu-config
    _plan_apply deployment
    _plan_apply service
    echo "Waiting for ${PRIVATE_INGRESS_NAME} pod to be ready..."
    _wait_for_pod 300
    echo "${PRIVATE_INGRESS_NAME} installed in namespace ${PRIVATE_INGRESS_NAMESPACE}"
}

_do_update() {
    _plan_apply configmap-sozu-config
    _plan_apply deployment
    _plan_rollout_restart deployment
    echo "Waiting for ${PRIVATE_INGRESS_NAME} to restart..."
    _wait_for_pod 180
    echo "${PRIVATE_INGRESS_NAME} updated in namespace ${PRIVATE_INGRESS_NAMESPACE}"
}

_do_delete() {
    _plan_delete service
    _plan_delete deployment
    _plan_delete configmap-sozu-config
    _plan_delete lb-pool
    echo "${PRIVATE_INGRESS_NAME} deleted from namespace ${PRIVATE_INGRESS_NAMESPACE}"
}

_do_restart() {
    _plan_rollout_restart deployment
    _wait_for_pod 180
    echo "${PRIVATE_INGRESS_NAME} restarted in namespace ${PRIVATE_INGRESS_NAMESPACE}"
}

_do_health() {
    local lb_ip="${PRIVATE_INGRESS_LB_IP:-}"
    if [ -z "$lb_ip" ]; then
        lb_ip=$(_kubectl get svc "$PRIVATE_INGRESS_NAME" \
            --namespace "$PRIVATE_INGRESS_NAMESPACE" \
            -o jsonpath='{.status.loadBalancer.ingress[0].ip}' 2>/dev/null)
    fi
    if [ -z "$lb_ip" ]; then
        echo "UNHEALTHY: ${PRIVATE_INGRESS_NAME} Service has no LB IP assigned" >&2; exit 1
    fi
    local pod
    pod=$(_kubectl get pod \
        --namespace "$PRIVATE_INGRESS_NAMESPACE" \
        --selector "app.kubernetes.io/name=${PRIVATE_INGRESS_NAME}" \
        -o jsonpath='{.items[0].metadata.name}' 2>/dev/null)
    if [ -z "$pod" ]; then
        echo "UNHEALTHY: no pod found for ${PRIVATE_INGRESS_NAME} in ${PRIVATE_INGRESS_NAMESPACE}" >&2; exit 1
    fi
    if _kubectl exec --namespace "$PRIVATE_INGRESS_NAMESPACE" "$pod" \
            -c sozu -- wget -qO- "http://localhost:80/" >/dev/null 2>&1; then
        echo "HEALTHY: ${PRIVATE_INGRESS_NAME} responding on :80 (LB IP: ${lb_ip})"
    else
        echo "HEALTHY: ${PRIVATE_INGRESS_NAME} pod running (LB IP: ${lb_ip}) — wget check skipped (no wget in sozu image)"
    fi
}