#!/bin/bash
# lockdown-helper — root-side control for Lockdown.
# Installed at /usr/local/libexec/lockdown-helper (root:wheel 755).
#
# The app writes a user config at ~/Library/Application Support/Lockdown/config.conf.
# At start this helper snapshots it to /Library/Application Support/Lockdown/config.active
# and freezes the rules for the session. Ending early requires the sentence.

set -u

PATH=/usr/bin:/bin:/usr/sbin:/sbin

STATE_DIR="/Library/Application Support/Lockdown"
STATE="$STATE_DIR/state"
ACTIVE_CONFIG="$STATE_DIR/config.active"
LOG="$STATE_DIR/lockdown.log"
HOSTS=/etc/hosts
MARK_BEGIN="# BEGIN LOCKDOWN BLOCK"
MARK_END="# END LOCKDOWN BLOCK"
SENTENCE="i am choosing to abandon my study session and i will regret it tomorrow"
ESCAPE_DELAY=15

POLICY_DIR="/Library/Managed Preferences"
EDGE_POLICY="$POLICY_DIR/com.microsoft.Edge"
CHROME_POLICY="$POLICY_DIR/com.google.Chrome"

DEFAULT_ALLOW="com.apple.Safari com.apple.Notes com.apple.systempreferences"
DEFAULT_DOMAINS="youtube.com youtu.be googlevideo.com netflix.com twitch.tv instagram.com tiktok.com x.com twitter.com facebook.com reddit.com redd.it snapchat.com pinterest.com tumblr.com 9gag.com roblox.com steamcommunity.com steampowered.com store.steampowered.com epicgames.com discord.com discordapp.com web.whatsapp.com messages.google.com spotify.com open.spotify.com"

MODE="allowlist"
ACTIVE_ALLOW=""
ACTIVE_BLOCK=""
BLOCK_SITES="yes"
SESSION_DOMAINS=""
HOSTS_DOMAINS=""

# MARK: - Utilities

log() {
    mkdir -p "$STATE_DIR" 2>/dev/null
    printf '%s %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$*" >>"$LOG" 2>/dev/null
}

die() { echo "$*" >&2; exit 1; }

trim() {
    local value="$1"
    value="${value#"${value%%[![:space:]]*}"}"
    value="${value%"${value##*[![:space:]]}"}"
    printf '%s' "$value"
}

append_unique() {
    local var="$1" value="$2" current
    [ -n "$value" ] || return 0
    eval "current=\${$var}"
    case " $current " in
        *" $value "*) ;;
        *) eval "$var=\"\$current \$value\"" ;;
    esac
}

validate_bundle() {
    local value="$1"
    [ ${#value} -ge 3 ] && [ ${#value} -le 200 ] || return 1
    case "$value" in
        *[!A-Za-z0-9._-]*) return 1 ;;
    esac
    return 0
}

normalize_domain() {
    local d
    d=$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]' \
        | sed -e 's#^https\{0,1\}://##' -e 's#/.*$##' -e 's/^www\.//' -e 's/^\.*//' -e 's/\.*$//')
    [ -n "$d" ] || return 1
    case "$d" in
        *[!a-z0-9.-]*) return 1 ;;
    esac
    case "$d" in
        *.*) ;;
        *) return 1 ;;
    esac
    [ ${#d} -ge 4 ] && [ ${#d} -le 253 ] || return 1
    printf '%s' "$d"
}

flush_dns() {
    dscacheutil -flushcache 2>/dev/null
    killall -HUP mDNSResponder 2>/dev/null
    return 0
}

# MARK: - Config

parse_config() {
    local path="${1:-}"
    local saw_mode=0
    local line key value d

    MODE="allowlist"
    ACTIVE_ALLOW=""
    ACTIVE_BLOCK=""
    BLOCK_SITES="yes"
    SESSION_DOMAINS=""
    HOSTS_DOMAINS=""
    SENTENCE="i am choosing to abandon my study session and i will regret it tomorrow"
    ESCAPE_DELAY=15

    if [ -n "$path" ] && [ -f "$path" ] && [ -r "$path" ]; then
        while IFS= read -r line || [ -n "$line" ]; do
            line=$(trim "$line")
            case "$line" in
                ""|"#"*) continue ;;
            esac
            case "$line" in
                *=*) ;;
                *) continue ;;
            esac

            key=$(trim "${line%%=*}")
            value=$(trim "${line#*=}")
            key=$(printf '%s' "$key" | tr '[:upper:]' '[:lower:]')

            case "$key" in
                mode)
                    saw_mode=1
                    if [ "$value" = "blocklist" ]; then
                        MODE="blocklist"
                    else
                        MODE="allowlist"
                    fi
                    ;;
                allow)
                    validate_bundle "$value" && append_unique ACTIVE_ALLOW "$value"
                    ;;
                block)
                    validate_bundle "$value" && append_unique ACTIVE_BLOCK "$value"
                    ;;
                block_sites)
                    case "$value" in
                        no|0|false) BLOCK_SITES="no" ;;
                        *) BLOCK_SITES="yes" ;;
                    esac
                    ;;
                domain)
                    if d=$(normalize_domain "$value"); then
                        append_unique SESSION_DOMAINS "$d"
                    fi
                    ;;
                escape_sentence)
                    local cleaned
                    cleaned=$(printf '%s' "$value" | tr '\n\r' '  ')
                    if [ "${#cleaned}" -ge 8 ] && [ "${#cleaned}" -le 160 ]; then
                        SENTENCE="$cleaned"
                    fi
                    ;;
                escape_delay)
                    case "$value" in
                        ''|*[!0-9]*) ;;
                        *)
                            if [ "$value" -ge 0 ] && [ "$value" -le 300 ]; then
                                ESCAPE_DELAY="$value"
                            fi
                            ;;
                    esac
                    ;;
            esac
        done <"$path"
    fi

    if [ "$saw_mode" -eq 0 ]; then
        MODE="allowlist"
        ACTIVE_ALLOW="$DEFAULT_ALLOW"
        ACTIVE_BLOCK=""
        BLOCK_SITES="yes"
        SESSION_DOMAINS="$DEFAULT_DOMAINS"
    fi

    for d in $SESSION_DOMAINS; do
        append_unique HOSTS_DOMAINS "$d"
        case "$d" in
            www.*) ;;
            *) append_unique HOSTS_DOMAINS "www.$d" ;;
        esac
    done
}

write_active_config() {
    local tmp="$STATE_DIR/.config.active.new"
    local b d

    mkdir -p "$STATE_DIR"
    chown root:wheel "$STATE_DIR" 2>/dev/null
    chmod 755 "$STATE_DIR" 2>/dev/null

    {
        echo "mode=$MODE"
        for b in $ACTIVE_ALLOW; do echo "allow=$b"; done
        for b in $ACTIVE_BLOCK; do echo "block=$b"; done
        echo "block_sites=$BLOCK_SITES"
        for d in $SESSION_DOMAINS; do
            echo "domain=$d"
        done
        echo "escape_sentence=$SENTENCE"
        echo "escape_delay=$ESCAPE_DELAY"
    } >"$tmp" || return 1

    chown root:wheel "$tmp" 2>/dev/null
    chmod 644 "$tmp" 2>/dev/null
    mv -f "$tmp" "$ACTIVE_CONFIG" || return 1
    chown root:wheel "$ACTIVE_CONFIG" 2>/dev/null
    chmod 644 "$ACTIVE_CONFIG" 2>/dev/null
    return 0
}

# MARK: - Hosts

remove_hosts_block() {
    [ -f "$HOSTS" ] || return 0
    if ! grep -qF "$MARK_BEGIN" "$HOSTS"; then
        return 0
    fi
    cp -p "$HOSTS" "$STATE_DIR/hosts.bak" 2>/dev/null
    local tmp="$STATE_DIR/hosts.tmp"
    awk -v b="$MARK_BEGIN" -v e="$MARK_END" '
        $0 == b { skip = 1; next }
        $0 == e { skip = 0; next }
        skip != 1 { print }
    ' "$HOSTS" >"$tmp" || return 1
    cat "$tmp" >"$HOSTS"
    rm -f "$tmp"
    log "hosts block removed"
}

apply_hosts_block() {
    [ -f "$HOSTS" ] || return 1
    if [ -z "$HOSTS_DOMAINS" ]; then
        remove_hosts_block
        return 0
    fi
    # Replace whatever was there so a changed rule set can never go stale.
    if grep -qF "$MARK_BEGIN" "$HOSTS"; then
        remove_hosts_block
    fi
    cp -p "$HOSTS" "$STATE_DIR/hosts.bak" 2>/dev/null
    {
        echo ""
        echo "$MARK_BEGIN"
        for d in $HOSTS_DOMAINS; do
            echo "0.0.0.0 $d"
            echo "::1 $d"
        done
        echo "$MARK_END"
    } >>"$HOSTS" || return 1
    log "hosts block applied"
}

# MARK: - Browser policy

url_blocklist() {
    local d
    for d in $SESSION_DOMAINS; do
        echo "*://$d/*"
        echo "*://*.$d/*"
    done
}

write_policy() {
    local base="$1"
    local plist="$base.plist"
    local backup="$STATE_DIR/backup-$(basename "$base").plist"
    local tmp="$STATE_DIR/policy.tmp"

    mkdir -p "$POLICY_DIR"
    if [ -f "$plist" ] && [ ! -f "$backup" ]; then
        cp -p "$plist" "$backup"
    fi

    {
        cat <<'HEADER'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>DnsOverHttpsMode</key>
    <string>off</string>
    <key>IncognitoModeAvailability</key>
    <integer>1</integer>
    <key>URLBlocklist</key>
    <array>
HEADER
        url_blocklist | while IFS= read -r p; do
            printf '        <string>%s</string>\n' "$p"
        done
        cat <<'FOOTER'
    </array>
</dict>
</plist>
FOOTER
    } >"$tmp"

    if ! /usr/bin/plutil -lint "$tmp" >/dev/null 2>&1; then
        log "policy XML invalid: $base"
        rm -f "$tmp"
        return 1
    fi
    if ! /usr/bin/install -o root -g wheel -m 644 "$tmp" "$plist"; then
        log "policy install failed: $base"
        rm -f "$tmp"
        return 1
    fi
    rm -f "$tmp"
    log "policy applied: $base"
}

apply_policies() {
    write_policy "$EDGE_POLICY"
    write_policy "$CHROME_POLICY"
}

remove_policies() {
    local base plist backup
    for base in "$EDGE_POLICY" "$CHROME_POLICY"; do
        plist="$base.plist"
        backup="$STATE_DIR/backup-$(basename "$base").plist"
        if [ -f "$backup" ]; then
            cp -p "$backup" "$plist"
            rm -f "$backup"
            log "policy restored: $base"
        else
            rm -f "$plist"
            log "policy removed: $base"
        fi
    done
}

# MARK: - Blocks

apply_block() {
    if [ "$BLOCK_SITES" = "yes" ] && [ -n "$SESSION_DOMAINS" ]; then
        apply_hosts_block || return 1
        apply_policies
    else
        remove_hosts_block
        remove_policies
    fi
    flush_dns
    return 0
}

cleanup() {
    remove_hosts_block
    remove_policies
    rm -f "$STATE" "$ACTIVE_CONFIG" "$STATE_DIR/goal.active"
    flush_dns
    log "lockdown ended"
}

# MARK: - State

state_end() {
    [ -f "$STATE" ] || return 1
    local end
    end=$(awk -F= '$1 == "end" { print $2; exit }' "$STATE" 2>/dev/null)
    [ -n "${end:-}" ] || return 1
    echo "$end"
}

is_active() {
    local end now
    end=$(state_end) || return 1
    now=$(date +%s)
    [ "$end" -gt "$now" ]
}

# MARK: - Commands

cmd_start() {
    local minutes="${1:-}"
    local config_path="${2:-}"
    local goal="${3:-}"
    local now end home

    [[ "$minutes" =~ ^[0-9]+$ ]] || die "usage: lockdown-helper start <minutes> [config] [goal]"
    [ "$minutes" -ge 1 ] && [ "$minutes" -le 720 ] || die "minutes must be 1-720"

    goal=$(printf '%s' "$goal" | tr '\n\r' '  ' | cut -c1-280)
    goal=$(trim "$goal")

    if is_active; then
        echo "ALREADY ACTIVE"
        exit 2
    fi

    if [ -z "$config_path" ] && [ -n "${SUDO_USER:-}" ]; then
        home=$(/usr/bin/dscl . -read "/Users/$SUDO_USER" NFSHomeDirectory 2>/dev/null | /usr/bin/awk '{print $2}')
        [ -n "$home" ] && config_path="$home/Library/Application Support/Lockdown/config.conf"
    fi

    parse_config "$config_path"

    # Clear an expired or interrupted previous session, including its hosts
    # block and browser policies, so the new rule set is never stale.
    if [ -f "$STATE" ] || [ -f "$ACTIVE_CONFIG" ] || grep -qF "$MARK_BEGIN" "$HOSTS" 2>/dev/null; then
        cleanup >/dev/null 2>&1
    fi

    now=$(date +%s)
    end=$((now + minutes * 60))
    mkdir -p "$STATE_DIR"
    chown root:wheel "$STATE_DIR" 2>/dev/null
    chmod 755 "$STATE_DIR" 2>/dev/null

    printf 'start=%s\nend=%s\nminutes=%s\n' "$now" "$end" "$minutes" \
        >"$STATE_DIR/.state.new" || die "could not write state"
    chmod 644 "$STATE_DIR/.state.new"
    mv "$STATE_DIR/.state.new" "$STATE"

    if ! write_active_config; then
        rm -f "$STATE"
        die "failed to write active config"
    fi

    if [ -n "$goal" ]; then
        printf '%s\n' "$goal" >"$STATE_DIR/goal.active"
        chown root:wheel "$STATE_DIR/goal.active" 2>/dev/null
        chmod 644 "$STATE_DIR/goal.active" 2>/dev/null
    else
        rm -f "$STATE_DIR/goal.active"
    fi

    if ! apply_block; then
        rm -f "$STATE" "$ACTIVE_CONFIG"
        die "failed to apply block"
    fi

    log "lockdown started: ${minutes}m mode=$MODE allow=$(echo $ACTIVE_ALLOW | wc -w | tr -d ' ') block=$(echo $ACTIVE_BLOCK | wc -w | tr -d ' ') sites=$(echo $SESSION_DOMAINS | wc -w | tr -d ' ') goal=$([ -n "$goal" ] && echo set || echo none) (end=$end)"
    echo "OK $minutes"
}

cmd_status() {
    local end now start
    if ! end=$(state_end); then
        echo "INACTIVE"
        exit 0
    fi
    now=$(date +%s)
    if [ "$end" -le "$now" ]; then
        cleanup
        echo "INACTIVE"
        exit 0
    fi
    start=$(awk -F= '$1 == "start" { print $2; exit }' "$STATE" 2>/dev/null)
    [ -n "${start:-}" ] || start=$((end - 60))
    echo "ACTIVE $((end - now)) $((end - start))"
}

cmd_stop() {
    local typed="${1:-}"
    if [ -f "$ACTIVE_CONFIG" ]; then
        parse_config "$ACTIVE_CONFIG"
    fi
    if ! is_active; then
        cleanup >/dev/null 2>&1
        echo "INACTIVE"
        exit 0
    fi
    if [ "$typed" = "$SENTENCE" ]; then
        cleanup
        echo "OK ended"
        exit 0
    fi
    echo "SENTENCE MISMATCH"
    exit 3
}

cmd_enforce() {
    local end now
    if ! end=$(state_end); then
        echo "INACTIVE"
        exit 0
    fi
    now=$(date +%s)
    if [ "$end" -le "$now" ]; then
        cleanup
        echo "CLEANED"
        exit 0
    fi

    if [ ! -f "$ACTIVE_CONFIG" ]; then
        echo "ACTIVE $((end - now))"
        exit 0
    fi

    parse_config "$ACTIVE_CONFIG"

    if [ "$BLOCK_SITES" = "yes" ] && [ -n "$SESSION_DOMAINS" ]; then
        if ! grep -qF "$MARK_BEGIN" "$HOSTS" 2>/dev/null; then
            apply_hosts_block
            flush_dns
        fi
        if [ ! -f "$EDGE_POLICY.plist" ] || [ ! -f "$CHROME_POLICY.plist" ]; then
            apply_policies
        fi
    else
        if grep -qF "$MARK_BEGIN" "$HOSTS" 2>/dev/null; then
            remove_hosts_block
            flush_dns
        fi
        remove_policies
    fi

    echo "ACTIVE $((end - now))"
}

cmd_doctor() {
    local rc=0
    local before after

    echo "lockdown-helper doctor"
    echo "user: $(id -un)  uid: $(id -u)"
    [ "$(id -u)" -eq 0 ] && echo "root: yes" || { echo "root: NO (doctor must run as root)"; rc=1; }
    [ -x /usr/local/libexec/lockdown-agent ] && echo "agent binary: ok" || { echo "agent binary: MISSING"; rc=1; }
    [ -x /usr/local/libexec/lockdown-helper ] && echo "helper: ok" || { echo "helper: MISSING"; rc=1; }
    [ -f /usr/local/etc/lockdown-allowlist ] && echo "legacy allowlist: ok" || echo "legacy allowlist: absent (fine)"
    if [ -f /etc/sudoers.d/lockdown ]; then
        if visudo -cf /etc/sudoers.d/lockdown >/dev/null 2>&1; then
            echo "sudoers: valid"
        else
            echo "sudoers: INVALID"; rc=1
        fi
    else
        echo "sudoers: MISSING"; rc=1
    fi

    parse_config ""

    if is_active; then
        echo "hosts round-trip: skipped (a lockdown is active)"
        echo "active state: yes"
        exit "$rc"
    fi

    before=$(grep -cF "$MARK_BEGIN" "$HOSTS" 2>/dev/null || true)
    apply_hosts_block || { echo "hosts apply: FAILED"; rc=1; }
    if grep -qF "0.0.0.0 youtube.com" "$HOSTS"; then
        echo "hosts apply: ok"
    else
        echo "hosts apply: FAILED"; rc=1
    fi
    remove_hosts_block
    after=$(grep -cF "$MARK_BEGIN" "$HOSTS" 2>/dev/null || true)
    if [ "$after" = "0" ]; then
        echo "hosts cleanup: ok"
    else
        echo "hosts cleanup: FAILED (marker still present)"; rc=1
    fi
    [ "$before" = "0" ] || echo "note: a block was already present before doctor ran"

    echo "active state: $(is_active && echo yes || echo no)"
    exit "$rc"
}

case "${1:-}" in
    start)     shift; cmd_start "$@" ;;
    status)    cmd_status ;;
    stop)      shift; cmd_stop "$@" ;;
    enforce)   cmd_enforce ;;
    sentence)
        if [ -f "$ACTIVE_CONFIG" ]; then
            parse_config "$ACTIVE_CONFIG"
        fi
        echo "$SENTENCE"
        ;;
    doctor)    cmd_doctor ;;
    *)
        echo "usage: lockdown-helper {start <minutes> [config] [goal]|status|stop <sentence>|enforce|sentence|doctor}"
        exit 1
        ;;
esac