sleepcontrol

#!/bin/bash
RED=$'\033[31m'
GREEN=$'\033[32m'
YELLOW=$'\033[33m'
BLUE=$'\033[34m'
MAGENTA=$'\033[35m'
CYAN=$'\033[36m'
BOLD=$'\033[1m'
RESET=$'\033[0m'

INSTALL_DIR="@INSTALL_DIR@"
if [ -d "/home/chronos/user/MyFiles/Downloads" ]; then
    CONFIG_FILE="/home/chronos/user/MyFiles/Downloads/ChromeOS_PowerControl_Config/config"
else
    CONFIG_FILE="/usr/local/bin/ChromeOS_PowerControl_Config/config"
fi
SELF="$(readlink -f "$0")"
PID_FILE="$INSTALL_DIR/.sleepcontrol_pid"
RUN_FLAG="$INSTALL_DIR/.sleepcontrol_enabled"
LOG_FILE="/var/log/sleepcontrol.log"
BATTERY_STATUS_PATH="/var/log/power_manager/powerd.LATEST"
BACKLIGHT_NAME=""
BRIGHTNESS_PATH=""
MAX_BRIGHTNESS_PATH=""
FAKE_ACTIVITY_INTERVAL=240
LID_SUSPEND_IGNORE_UNTIL=0
LAST_FAKE_ACTIVITY_FILE="${INSTALL_DIR}/.last_fake_activity"
LAST_POWER_STATE="${INSTALL_DIR}/.last_power_state"
FAKE_ACTIVITY_GRACE=1
timestamp=$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1)
SAVED_BRIGHTNESS_FILE="$INSTALL_DIR/.saved_brightness"
SUSPEND_APPLIED_FLAG="/tmp/.sleepcontrol_suspend_applied"
CONF_SOURCE="$INSTALL_DIR/sleepcontrol.conf"
CONF_TARGET="/etc/init/sleepcontrol.conf"
DEEP_SUSPEND="$INSTALL_DIR/deep_suspend.sh"
DEEP_SUSPEND_BATTERY="$INSTALL_DIR/deep_suspend_battery.sh"

run_deep_suspend() {
    if [[ "$STATUS" == "Discharging" ]]; then
        sudo "$DEEP_SUSPEND_BATTERY" "$@"
    else
        sudo "$DEEP_SUSPEND" "$@"
    fi
}

if [ ! -f /usr/sbin/ectool ]; then
    echo "${RED}ectool not found. Exiting.${RESET}"
    sleep 3
    exit 1
fi

wait_for_config() {
    local config_dir="/home/chronos/user/MyFiles/Downloads/ChromeOS_PowerControl_Config"
    local max_wait=300
    local elapsed=0
    
    while [ $elapsed -lt $max_wait ]; do
        if [ -f "$CONFIG_FILE" ]; then
            return 0
        fi
        
        sleep 5
        elapsed=$((elapsed + 5))
    done
    
    echo "${RED}Error: Config file not available after 5 minutes${RESET}" | tee -a "$LOG_FILE"
    return 1
}

wait_for_config

#if [[ ! -f "$SUSPEND_APPLIED_FLAG" ]]; then
#    INSTALL_DIR="$(dirname "$(readlink -f "$0")")"
#    if [[ -f "$CONFIG_FILE" ]]; then
#        SUSPEND_MODE=$(grep "^SUSPEND_MODE=" "$CONFIG_FILE" | cut -d'=' -f2)
#       if [[ "$SUSPEND_MODE" == "freeze" || "$SUSPEND_MODE" == "deep" ]]; then
#           echo "$SUSPEND_MODE" | sudo tee /usr/share/power_manager/suspend_mode >/dev/null 2>&1
#           echo "$SUSPEND_MODE" | sudo tee /var/run/power_manager/power/initial_suspend_mode >/dev/null 2>&1
#            sudo restart powerd >/dev/null

#            if [[ "$SUSPEND_MODE" == "freeze" ]]; then
#                echo "$CHROME_MILESTONE" | sudo tee "$CHARD_ROOT/.chard_chrome" > /dev/null
#                echo "s2idle" | sudo tee /sys/power/mem_sleep >/dev/null 2>&1
#                echo "s2idle" | sudo tee /var/run/power_manager/power/initial_suspend_mode >/dev/null 2>&1
#            else
#                echo "deep" | sudo tee /sys/power/mem_sleep >/dev/null 2>&1
#                echo "deep" | sudo tee /var/run/power_manager/power/initial_suspend_mode >/dev/null 2>&1
#            fi
#            touch "$SUSPEND_APPLIED_FLAG"
#        fi
#    fi
#fi

get_battery_info() {
    local line last=""
    while IFS= read -r line; do
        case $line in
            *"On battery at"*|*"On AC"*|*"line_power"*)
                last=$line
                ;;
        esac
    done < "$BATTERY_STATUS_PATH"
    
    if [[ $last =~ On\ battery\ at\ ([0-9]+)% ]]; then
        CHARGE=${BASH_REMATCH[1]}
        STATUS="Discharging"
    elif [[ $last =~ On\ (AC|USB) ]]; then
        [[ $last =~ at\ ([0-9]+)% ]] && CHARGE=${BASH_REMATCH[1]} || CHARGE=""
        STATUS="Charging"
    elif [[ $last =~ line_power\ (connected|online) ]]; then
        [[ $last =~ at\ ([0-9]+)% ]] && CHARGE=${BASH_REMATCH[1]} || CHARGE=""
        STATUS="Charging"
    else
        CHARGE=""
        STATUS="Unknown"
    fi
}

if ! ( [[ -z "$1" ]] || [[ "$1" == "--h" || "$1" == "-h" || "$1" == "h" || "$1" == "--help" || "$1" == "-help" || "$1" == "help" || "$1" == "help_all" || "$1" == "monitor" || "$1" == "mon" || "$1" == "powerd" || "$1" == "status" ]] ) && [[ "$(id -u)" -ne 0 ]]; then    echo "${RED}SleepControl requires sudo to run${RESET}"
    echo "  Try: sudo sleepcontrol $*  or  sudo $0 $*"
    exit 1
fi

DEFAULT_BATTERY_DELAY=13
DEFAULT_BATTERY_BACKLIGHT=10
DEFAULT_BATTERY_DIM_DELAY=7
DEFAULT_POWER_DELAY=24
DEFAULT_POWER_BACKLIGHT=18
DEFAULT_POWER_DIM_DELAY=12
#DEFAULT_SUSPEND_MODE=deep
DEFAULT_AUDIO_DETECTION_BATTERY=0
DEFAULT_AUDIO_DETECTION_POWER=1
DEFAULT_LIDSLEEP_BATTERY=1
DEFAULT_LIDSLEEP_POWER=1


AUDIO_DETECTION_BATTERY=
AUDIO_DETECTION_POWER=
BATTERY_DELAY=
BATTERY_BACKLIGHT=
BATTERY_DIM_DELAY=
POWER_DELAY=
POWER_BACKLIGHT=
POWER_DIM_DELAY=
#SUSPEND_MODE=
#ORIGINAL_SUSPEND_MODE=
LIDSLEEP_BATTERY=
LIDSLEEP_POWER=
audio_active=0
saved_display_brightness=0
was_dimmed=0
PRESENTATION_MODE=0
BATTERY_DELAY=$DEFAULT_BATTERY_DELAY
POWER_DELAY=$DEFAULT_POWER_DELAY
BATTERY_BACKLIGHT=$DEFAULT_BATTERY_BACKLIGHT
POWER_BACKLIGHT=$DEFAULT_POWER_BACKLIGHT
BATTERY_DIM_DELAY=$DEFAULT_BATTERY_DIM_DELAY
POWER_DIM_DELAY=$DEFAULT_POWER_DIM_DELAY
#SUSPEND_MODE=$DEFAULT_SUSPEND_MODE
#ORIGINAL_SUSPEND_MODE=$ORIGINAL_SUSPEND_MODE

load_config() {
    if [ -f "$CONFIG_FILE" ]; then
        while IFS='=' read -r key value; do
            [[ "$key" =~ ^[[:space:]]*# ]] && continue
            [[ -z "$key" ]] && continue
            case "$key" in
                BATTERY_DELAY|POWER_DELAY|BATTERY_BACKLIGHT|POWER_BACKLIGHT|\
                BATTERY_DIM_DELAY|POWER_DIM_DELAY|AUDIO_DETECTION_BATTERY|AUDIO_DETECTION_POWER|\
                LIDSLEEP_BATTERY|LIDSLEEP_POWER|BRIGHTNESS_PATH|MAX_BRIGHTNESS_PATH)
                    eval "$key=\"$value\""
                    ;;
            esac
        done < "$CONFIG_FILE"
    fi
    validate_config
    recalc_timers
}

last_reload_time=$EPOCHSECONDS
last_ts=$EPOCHSECONDS

recalc_timers() {
    if [[ "$STATUS" == "Discharging" ]]; then
        dim_delay=$((BATTERY_DIM_DELAY * 60))
        backlight_delay=$((BATTERY_BACKLIGHT * 60))
        suspend_delay=$((BATTERY_DELAY * 60))
        AUDIO_DETECTION_ENABLED=$AUDIO_DETECTION_BATTERY
        LIDSLEEP_ENABLED=$LIDSLEEP_BATTERY
    else
        dim_delay=$((POWER_DIM_DELAY * 60))
        backlight_delay=$((POWER_BACKLIGHT * 60))
        suspend_delay=$((POWER_DELAY * 60))
        AUDIO_DETECTION_ENABLED=$AUDIO_DETECTION_POWER
        LIDSLEEP_ENABLED=$LIDSLEEP_POWER
    fi    
}

validate_config() {
    if [[ -z "$BATTERY_DELAY" || ! "$BATTERY_DELAY" =~ ^[0-9]+$ ]]; then
        BATTERY_DELAY=$DEFAULT_BATTERY_DELAY
    fi
    if [[ -z "$POWER_DELAY" || ! "$POWER_DELAY" =~ ^[0-9]+$ ]]; then
        POWER_DELAY=$DEFAULT_POWER_DELAY
    fi
    if [[ -z "$BATTERY_BACKLIGHT" || ! "$BATTERY_BACKLIGHT" =~ ^[0-9]+$ ]]; then
        BATTERY_BACKLIGHT=$DEFAULT_BATTERY_BACKLIGHT
    fi
    if [[ -z "$POWER_BACKLIGHT" || ! "$POWER_BACKLIGHT" =~ ^[0-9]+$ ]]; then
        POWER_BACKLIGHT=$DEFAULT_POWER_BACKLIGHT
    fi
    if [[ -z "$BATTERY_DIM_DELAY" || ! "$BATTERY_DIM_DELAY" =~ ^[0-9]+$ ]]; then
        BATTERY_DIM_DELAY=$DEFAULT_BATTERY_DIM_DELAY
    fi
    if [[ -z "$POWER_DIM_DELAY" || ! "$POWER_DIM_DELAY" =~ ^[0-9]+$ ]]; then
        POWER_DIM_DELAY=$DEFAULT_POWER_DIM_DELAY
    fi

    if [[ -z "$AUDIO_DETECTION_BATTERY" || ! "$AUDIO_DETECTION_BATTERY" =~ ^[01]$ ]]; then
        AUDIO_DETECTION_BATTERY=1
    fi
    if [[ -z "$AUDIO_DETECTION_POWER" || ! "$AUDIO_DETECTION_POWER" =~ ^[01]$ ]]; then
        AUDIO_DETECTION_POWER=1
    fi

    if [[ -z "$LIDSLEEP_BATTERY" || ! "$LIDSLEEP_BATTERY" =~ ^[01]$ ]]; then
        LIDSLEEP_BATTERY=$DEFAULT_LIDSLEEP_BATTERY
    fi
    if [[ -z "$LIDSLEEP_POWER" || ! "$LIDSLEEP_POWER" =~ ^[01]$ ]]; then
        LIDSLEEP_POWER=$DEFAULT_LIDSLEEP_POWER
    fi


    #if [[ -z "$SUSPEND_MODE" || ( "$SUSPEND_MODE" != "freeze" && "$SUSPEND_MODE" != "deep" ) ]]; then
    #    if [[ -f "/usr/share/power_manager/suspend_mode" ]]; then
    #        SUSPEND_MODE=$(cat /usr/share/power_manager/suspend_mode)
    #        if [[ "$SUSPEND_MODE" != "freeze" && "$SUSPEND_MODE" != "deep" ]]; then
    #            SUSPEND_MODE="freeze"
    #        fi
    #    else
    #        SUSPEND_MODE="freeze"
    #    fi
    #fi
}


save_config() {
    validate_config
    if [[ -f "$CONFIG_FILE" ]]; then
        sed -i "s/^BATTERY_DELAY=.*/BATTERY_DELAY=$BATTERY_DELAY/" "$CONFIG_FILE" || echo "BATTERY_DELAY=$BATTERY_DELAY" >> "$CONFIG_FILE"
        sed -i "s/^POWER_DELAY=.*/POWER_DELAY=$POWER_DELAY/" "$CONFIG_FILE" || echo "POWER_DELAY=$POWER_DELAY" >> "$CONFIG_FILE"
        sed -i "s/^BATTERY_BACKLIGHT=.*/BATTERY_BACKLIGHT=$BATTERY_BACKLIGHT/" "$CONFIG_FILE" || echo "BATTERY_BACKLIGHT=$BATTERY_BACKLIGHT" >> "$CONFIG_FILE"
        sed -i "s/^POWER_BACKLIGHT=.*/POWER_BACKLIGHT=$POWER_BACKLIGHT/" "$CONFIG_FILE" || echo "POWER_BACKLIGHT=$POWER_BACKLIGHT" >> "$CONFIG_FILE"
        sed -i "s/^BATTERY_DIM_DELAY=.*/BATTERY_DIM_DELAY=$BATTERY_DIM_DELAY/" "$CONFIG_FILE" || echo "BATTERY_DIM_DELAY=$BATTERY_DIM_DELAY" >> "$CONFIG_FILE"
        sed -i "s/^POWER_DIM_DELAY=.*/POWER_DIM_DELAY=$POWER_DIM_DELAY/" "$CONFIG_FILE" || echo "POWER_DIM_DELAY=$POWER_DIM_DELAY" >> "$CONFIG_FILE"
        sed -i "s/^AUDIO_DETECTION_BATTERY=.*/AUDIO_DETECTION_BATTERY=$AUDIO_DETECTION_BATTERY/" "$CONFIG_FILE" || echo "AUDIO_DETECTION_BATTERY=$AUDIO_DETECTION_BATTERY" >> "$CONFIG_FILE"
        sed -i "s/^AUDIO_DETECTION_POWER=.*/AUDIO_DETECTION_POWER=$AUDIO_DETECTION_POWER/" "$CONFIG_FILE" || echo "AUDIO_DETECTION_POWER=$AUDIO_DETECTION_POWER" >> "$CONFIG_FILE"
        #sed -i "s/^SUSPEND_MODE=.*/SUSPEND_MODE=$SUSPEND_MODE/" "$CONFIG_FILE" || echo "SUSPEND_MODE=$SUSPEND_MODE" >> "$CONFIG_FILE"
        #sed -i "s/^ORIGINAL_SUSPEND_MODE=.*/ORIGINAL_SUSPEND_MODE=$ORIGINAL_SUSPEND_MODE/" "$CONFIG_FILE" || echo "ORIGINAL_SUSPEND_MODE=$ORIGINAL_SUSPEND_MODE" >> "$CONFIG_FILE"
        sed -i "s/^LIDSLEEP_BATTERY=.*/LIDSLEEP_BATTERY=$LIDSLEEP_BATTERY/" "$CONFIG_FILE" || echo "LIDSLEEP_BATTERY=$LIDSLEEP_BATTERY" >> "$CONFIG_FILE"
        sed -i "s/^LIDSLEEP_POWER=.*/LIDSLEEP_POWER=$LIDSLEEP_POWER/" "$CONFIG_FILE" || echo "LIDSLEEP_POWER=$LIDSLEEP_POWER" >> "$CONFIG_FILE"
    fi
}

show_help() {
echo "${BLUE}"
echo "╔════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗"
echo "║                                                                                                                    ║"
echo "║                                          SleepControl commands with examples:                                      ║"
echo "║                                                                                                                    ║"
echo "║  sleepcontrol                       # Show SleepControl status                                                     ║"
echo "║  sleepcontrol help                  # Help menu                                                                    ║"
echo "║  sleepcontrol monitor               # Monitor sleepcontrol activity in realtime (ctrl-c to exit)                   ║"
echo "║  sleepcontrol powerd                # Monitor powerd.LATEST log in realtime (ctrl-c to exit)                       ║"
echo "║  sudo sleepcontrol start            # Start SleepControl                                                           ║"
echo "║  sudo sleepcontrol stop             # Stop SleepControl                                                            ║"
echo "║  sudo sleepcontrol battery 3 7 12   # When idle, display dims in 3m -> timeout in 7m -> sleeps in 12m on battery   ║"
echo "║  sudo sleepcontrol power 5 15 30    # When idle, display dims in 5m -> timeout -> 15m -> sleeps in 30m plugged-in  ║"
echo "║  sudo sleepcontrol battery audio 0  # Disable audio detection on battery; sleep can occur during media playback    ║"
echo "║  sudo sleepcontrol power audio 1    # Enable audio detection on power; delaying sleep until audio is stopped       ║"
echo "║  sudo sleepcontrol lid power 0      # Prevent closing lid from putting system to sleep when on power               ║"
echo "║  sudo sleepcontrol lid battery 0    # Prevent closing lid from putting system to sleep when on battery             ║"
echo "║  sudo sleepcontrol startup          # Copy or Remove sleepcontrol.conf at: /etc/init/                              ║"
echo "║                                                                                                                    ║"
echo "╚════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝"
echo "${RESET}"
            }

load_config

set_display_brightness() {
    local value=$1
    if [[ -n "$BRIGHTNESS_PATH" ]]; then
        printf '%s\n' "$value" | sudo tee "$BRIGHTNESS_PATH" >/dev/null 2>&1
    fi
    }

save_current_brightness() {
    if [[ $was_dimmed -eq 0 ]]; then
        if [[ -f "$BRIGHTNESS_PATH" && -r "$BRIGHTNESS_PATH" ]]; then
            if read -r brightness_val < "$BRIGHTNESS_PATH" 2>/dev/null; then
                if [[ -f "$MAX_BRIGHTNESS_PATH" && -r "$MAX_BRIGHTNESS_PATH" ]]; then
                    max_brightness=$(cat "$MAX_BRIGHTNESS_PATH" 2>/dev/null)
                    min_threshold=$((max_brightness * 1 / 100))
                    if [[ "$brightness_val" =~ ^[0-9]+$ ]] && [[ "$brightness_val" -ge "$min_threshold" ]] && [[ "$brightness_val" -le "$max_brightness" ]]; then
                        printf '%s' "$brightness_val" | sudo tee "$SAVED_BRIGHTNESS_FILE" >/dev/null 2>&1
                        saved_display_brightness="$brightness_val"
                        echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Saved brightness: ${RESET}${YELLOW}$brightness_val${RESET}" >> "$LOG_FILE"
                    else
                        echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Brightness too low ${RESET}${YELLOW}($brightness_val < $min_threshold)${RESET}${BLUE}, not saving${RESET}" >> "$LOG_FILE"
                    fi
                else
                    printf '%s' "$brightness_val" | sudo tee "$SAVED_BRIGHTNESS_FILE" >/dev/null 2>&1
                    saved_display_brightness="$brightness_val"
                    #echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Saved brightness: ${RESET}${YELLOW}$brightness_val${RESET}" >> "$LOG_FILE"
                fi
            fi
        fi
    fi
}

get_saved_brightness() {
    if [[ -f "$SAVED_BRIGHTNESS_FILE" ]]; then
        cat "$SAVED_BRIGHTNESS_FILE" 2>/dev/null || echo "0" 
    else
        echo "0"
    fi
}

   set_audio_detection() {
    local mode=$1
    local value=$2
    load_config
    if [[ "$value" =~ ^[01]$ ]]; then
        if [[ "$mode" == "battery" ]]; then
            AUDIO_DETECTION_BATTERY=$value
        else
            AUDIO_DETECTION_POWER=$value
        fi
        save_config
        echo "${BLUE}Audio detection for $mode set to $value${RESET}"
    else
        echo "Usage: $0 $mode audio <0|1>"
    fi
}

update_power_state_file() {
    printf '%s' "$STATUS" | sudo tee "$LAST_POWER_STATE" >/dev/null 2>&1
}

idle_elapsed=0

monitor_idle_activity() {
    exec 200>"$PID_FILE.lock"
    flock -n 200 || {
        echo "${BLUE}"
        echo " SleepControl is already running."
        echo "${RESET}"
        exit 1
    }

    wait_for_config
    load_config
    saved_display_brightness=$(get_saved_brightness) 2>/dev/null
    recalc_timers
    last_reload_time=$EPOCHSECONDS
    last_ts=$EPOCHSECONDS
    local last_log_ts=0
    local wake_grace_end=0

    echo "$BASHPID" > "$PID_FILE"
    touch "$RUN_FLAG"
    echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - SleepControl started (PID $$)${RESET}" > "$LOG_FILE"

    local active=1
    local monitor_idle=0
    local sending_fake_activity=0
    local fake_activity_pid=0
    local idle_since=0
    local backlight_off=0
    local kb_brightness_restored=1
    local power_backlight_ts=$EPOCHSECONDS
    local battery_backlight_ts=$EPOCHSECONDS
    last_reload_time=0
    local saved_kb_brightness=$(sudo ectool pwmgetkblight 2>/dev/null | awk '{print $NF}')
    local lid_closed=0

    if [[ "$saved_kb_brightness" -gt 0 ]]; then
        saved_kb_brightness="$saved_kb_brightness"
    else
        saved_kb_brightness=""
    fi

    save_current_brightness
    last_power_check_time=0
    
    send_fake_activity() {
        now=$EPOCHSECONDS
    
        if (( monitor_idle == 1 || audio_active == 1 )); then
            dbus-send --system --type=method_call \
                --dest=org.chromium.PowerManager \
                /org/chromium/PowerManager \
                org.chromium.PowerManager.HandleUserActivity int32:0 int32:0
    
            printf '%s' "$now" | sudo tee "$LAST_FAKE_ACTIVITY_FILE" >/dev/null 2>&1
            echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Simulated user activity${RESET}" >> "$LOG_FILE"
        fi
    }

    post_suspend_reset() {
    last_ts=$EPOCHSECONDS
    idle_since=$EPOCHSECONDS
    monitor_idle=0
    active=1
    idle_elapsed=0
    backlight_off=0
    was_dimmed=0
    wake_grace_end=$(( EPOCHSECONDS + 3 ))
}
    start_fake_activity() {
        if (( sending_fake_activity == 0 )); then
            
            (
                while [ -f "$RUN_FLAG" ]; do
                    sleep "$FAKE_ACTIVITY_INTERVAL"
                    send_fake_activity
                done
            ) &
            fake_activity_pid=$!
            sending_fake_activity=1
            echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Starting simulated activity loop... (PID $fake_activity_pid)${RESET}" >> "$LOG_FILE"
        fi
    }

    stop_fake_activity() {
        if (( sending_fake_activity == 1 )); then
            kill "$fake_activity_pid" 2>/dev/null
            wait "$fake_activity_pid" 2>/dev/null
    
            last_ts=$EPOCHSECONDS
            idle_elapsed=0
            #monitor_idle=0
    
            sending_fake_activity=0
            fake_activity_pid=0
    
            echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Stopping simulated activity loop...${RESET}" >> "$LOG_FILE"
        fi
    }



    exec 3< <(
        tail -Fn0 /var/log/power_manager/powerd.LATEST |
        while IFS= read -r line; do
            sleep 0.04
            printf '%s\n' "$line"
        done
    )

    load_config
    last_reload_time=$EPOCHSECONDS
    last_ts=$EPOCHSECONDS

    while true; do
    IFS= read -r -t 5 line <&3
    read_status=$?

    if (( read_status != 0 )); then
        if (( read_status > 128 )); then
            line=""
        else
            exec 3<&-
            sleep 0.2
            exec 3< <(
                tail -Fn0 /var/log/power_manager/powerd.LATEST |
                while IFS= read -r line; do
                    sleep 0.04
                    printf '%s\n' "$line"
                done
            )
            sleep 0.2
            continue
        fi
    fi

    now=$EPOCHSECONDS
    
        if (( now - last_reload_time >= 5 )); then
            load_config
            last_reload_time=$now
            if [[ -f "$CONFIG_FILE" ]]; then
                startup_enabled=0
                if [[ -f "$CONFIG_FILE" ]]; then
                    while IFS='=' read -r k v; do
                        [[ $k == STARTUP_SLEEPCONTROL ]] && { [[ $v == 1 ]] && startup_enabled=1; break; }
                    done < "$CONFIG_FILE"
                fi
                
                if (( startup_enabled )); then
                    if [[ ! -f $CONF_TARGET ]]; then
                        sudo cp "$CONF_SOURCE" "$CONF_TARGET" 2>/dev/null
                        printf '%s%(%F %T)T - SleepControl Startup enabled%s\n' "$BLUE" -1 "$RESET" >> "$LOG_FILE"
                    fi
                else
                    if [[ -f $CONF_TARGET ]]; then
                        sudo rm -f "$CONF_TARGET" 2>/dev/null
                        printf '%s%(%F %T)T - SleepControl Startup disabled%s\n' "$RED" -1 "$RESET" >> "$LOG_FILE"
                    fi
                fi

                if [ -f "$LOG_FILE" ] && [ "$(stat -c%s "$LOG_FILE")" -gt 1048576 ]; then
                    echo "${MAGENTA}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Truncated log file (exceeded 1MB) ${RESET}" | tee -a "$LOG_FILE"
                fi
            fi
        fi
    
        if [[ "$STATUS" == "Discharging" ]]; then
            AUDIO_DETECTION_ENABLED=$AUDIO_DETECTION_BATTERY
        else
            AUDIO_DETECTION_ENABLED=$AUDIO_DETECTION_POWER
        fi
        
        (( AUDIO_DETECTION_ENABLED == 0 )) && audio_active=0
        
        if [[ "$STATUS" == "Discharging" ]]; then
            LIDSLEEP_ENABLED=$LIDSLEEP_BATTERY
        else
            LIDSLEEP_ENABLED=$LIDSLEEP_POWER
        fi

      # (( LIDSLEEP_ENABLED == 0 )) && lid_closed=0

        case "$line" in
        *"Chrome is using presentation display mode"*)
            PRESENTATION_MODE=1
            echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Presentation mode/External display detected${RESET}" >> "$LOG_FILE"
            monitor_idle=0
            active=1
            last_ts=$now
            stop_fake_activity
            lid_closed=0
            ;;
        *"Chrome is using normal display mode"*)
            PRESENTATION_MODE=0
            ;;
        *"Audio activity started"*|*"Audio activity ongoing"*)
            if (( AUDIO_DETECTION_ENABLED == 1 )); then
                audio_active=1
                start_fake_activity
                last_ts=$now
                monitor_idle=1
                active=0
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Audio Activity Detected - Resetting Timers. ${RESET}" >> "$LOG_FILE"
            fi
            ;;
        *"Audio activity stopped"*)
            if (( AUDIO_DETECTION_ENABLED == 1 )); then
                audio_active=0
                last_ts=$EPOCHSECONDS
                idle_elapsed=0
                active=1
            fi
            ;;
      *"User activity stopped"*)
            if (( audio_active == 0 )) && (( now - last_ts > 5 )) && (( now - idle_since > 5 )); then
                if (( LIDSLEEP_ENABLED == 1 && lid_closed == 1 )); then
                    echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Lid sleep enabled and lid closed, skipping fake activity${RESET}" >> "$LOG_FILE"
                    sleep 0.1
                    run_deep_suspend 2>/dev/null
                    post_suspend_reset
                    stop_fake_activity
                else
                    monitor_idle=1
                    active=0
                    kb_brightness_restored=0
                    start_fake_activity
                fi
            fi
            ;;
        *"Lid closed"*)
            lid_closed=1
            get_battery_info
            if [[ "$STATUS" == "Discharging" ]]; then
                LIDSLEEP_ENABLED=$LIDSLEEP_BATTERY
            else
                LIDSLEEP_ENABLED=$LIDSLEEP_POWER
            fi
        
            if (( LIDSLEEP_ENABLED == 1 )); then
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Lid closed, lid sleep on! ${RESET}" >> "$LOG_FILE"
                #stop_fake_activity
                sleep 0.1
                run_deep_suspend
                post_suspend_reset
                stop_fake_activity
            else
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Lid closed, lid sleep off!${RESET}" >> "$LOG_FILE"
                monitor_idle=1
                active=0
                sleep 0.1
                #start_fake_activity
            fi
            ;;
        *"Lid opened"*)
            lid_closed=0
            monitor_idle=0
            last_ts=$now
            active=1
            backlight_off=0
            was_dimmed=0
            stop_fake_activity
            sleep 0.1
            echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Lid opened!${RESET}" >> "$LOG_FILE"
            
            if (( PRESENTATION_MODE == 0 )); then
                if (( kb_brightness_restored == 0 )); then
                    kb_brightness_restored=1
                fi
        
                if [[ -n "$saved_display_brightness" && "$saved_display_brightness" -gt 0 ]]; then
                    set_display_brightness "$saved_display_brightness" > /dev/null 2>&1
                fi
            fi
            ;;
     *"On battery at"*|*"On AC"*|*"On USB"*|*"line_power connected"*|*"line_power online"*)
            if [[ -f "$LAST_POWER_STATE" ]]; then
                prev_status=$(<"$LAST_POWER_STATE")
            else
                prev_status=""
            fi
            
            get_battery_info
            
            if [[ "$STATUS" != "$prev_status" ]]; then
                recalc_timers
                last_ts=$now
                printf '%s' "$STATUS" | sudo tee "$LAST_POWER_STATE" >/dev/null 2>&1
                
                if [[ -n "$saved_display_brightness" && "$saved_display_brightness" -ge 0 ]]; then
                    set_display_brightness "$saved_display_brightness"
                fi
        
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Power state changed: ${RESET}${YELLOW}${prev_status}${RESET}${BLUE} -> ${RESET}${YELLOW}${STATUS}${RESET}" >> "$LOG_FILE"
                
                if (( lid_closed == 1 )); then
                    if [[ "$STATUS" == "Discharging" ]]; then
                        LIDSLEEP_ENABLED=$LIDSLEEP_BATTERY
                    else
                        LIDSLEEP_ENABLED=$LIDSLEEP_POWER
                    fi
                    
                    if (( LIDSLEEP_ENABLED == 1 )); then
                        echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Lid is closed - lid sleep enabled on ${STATUS}, going back to sleep!${RESET}" >> "$LOG_FILE"
                        #stop_fake_activity
                        sleep 0.1
                        run_deep_suspend
                        post_suspend_reset
                        stop_fake_activity
                    else
                        echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Lid is closed - lid sleep disabled on ${STATUS}${RESET}" >> "$LOG_FILE"
                    fi
                fi
            fi
            ;;
         *"Enabling wakeup for"*|*"User triggered wake"*|*"User activity ongoing"*)
            if (( lid_closed == 1 && LIDSLEEP_ENABLED == 0 )); then
                continue
            fi
            monitor_idle=0
            last_ts=$now
            active=1
            stop_fake_activity
            backlight_off=0
            if (( kb_brightness_restored == 0 )); then
                kb_brightness_restored=1
            fi
    
            if [[ -n "$saved_display_brightness" && "$saved_display_brightness" -ge 0 ]]; then
                set_display_brightness "$saved_display_brightness"
            fi
            power_backlight_ts=$now
            battery_backlight_ts=$now
            was_dimmed=0
            if [[ ! -f "$LAST_FAKE_ACTIVITY_FILE" ]] && (( was_dimmed == 0 )); then
                save_current_brightness
            fi
            ;;
        *"User activity reported"*)
            if [[ -f "$LAST_FAKE_ACTIVITY_FILE" ]]; then
                last_fake_ts=$(head -n1 "$LAST_FAKE_ACTIVITY_FILE" 2>/dev/null || echo 0)
            else
                last_fake_ts=0
            fi
            if (( last_fake_ts > 0 && now - last_fake_ts <= FAKE_ACTIVITY_GRACE )); then
                sudo rm -f "$LAST_FAKE_ACTIVITY_FILE" 2>/dev/null || true
                continue
            fi
            if (( monitor_idle == 1 )); then
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - User activity resumed${RESET}" >> "$LOG_FILE"
            fi
            monitor_idle=0
            active=1
            last_ts=$now
            idle_elapsed=0
            stop_fake_activity
            backlight_off=0
            if (( kb_brightness_restored == 0 )); then
                kb_brightness_restored=1
            fi
        
            if [[ -n "$saved_display_brightness" && "$saved_display_brightness" -ge 0 ]]; then
                set_display_brightness "$saved_display_brightness"
            fi
        
            power_backlight_ts=$now
            battery_backlight_ts=$now
            was_dimmed=0
            ;;
        *"Got user-triggered request to set brightness to "*)
            monitor_idle=0
            last_ts=$now
            active=1
            stop_fake_activity
            backlight_off=0
        
            line=$(tail -n 200 /var/log/power_manager/powerd.LATEST | grep "Setting brightness to" | tail -n1)
            brightness_value=$(echo "$line" | sed -n 's/.*Setting brightness to \([0-9]\+\) (.*/\1/p')
        
            if [[ -n "$brightness_value" && "$brightness_value" -gt 0 && $lid_closed -eq 0 && $backlight_off -eq 0 && $was_dimmed -eq 0 ]]; then
                if [[ -f "$MAX_BRIGHTNESS_PATH" && -r "$MAX_BRIGHTNESS_PATH" ]]; then
                    max_brightness=$(cat "$MAX_BRIGHTNESS_PATH" 2>/dev/null)
                    min_threshold=$((max_brightness * 1 / 100))
                    
                    if [[ "$brightness_value" -ge "$min_threshold" ]]; then
                        saved_display_brightness="$brightness_value"
                        printf '%s' "$brightness_value" | sudo tee "$SAVED_BRIGHTNESS_FILE" >/dev/null 2>&1
                        printf -v ts '%(%Y-%m-%d %H:%M:%S)T' -1
                        printf '%s%s - Saved display brightness:%s %s\n' "$BLUE" "$ts" "$RESET" "${YELLOW}${saved_display_brightness}${RESET}" >> "$LOG_FILE"
                    fi
                fi
            fi
            ;;
         *"Adaptive Charging ML predicts"*)
            #echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Adaptive Charging${RESET}" >> "$LOG_FILE"
            if (( idle_elapsed >= suspend_delay )); then
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Timers already elapsed, returning to sleep${RESET}" >> "$LOG_FILE"
                sleep 0.1
                run_deep_suspend
                post_suspend_reset
                stop_fake_activity
            else
                monitor_idle=1
                active=0
                start_fake_activity
            fi
            ;;
        esac

        if (( monitor_idle == 1 )); then
            idle_elapsed=$(( now - last_ts ))
                if [[ "$STATUS" == "Discharging" ]]; then
                    AUDIO_DETECTION_ENABLED=$AUDIO_DETECTION_BATTERY
                else
                    AUDIO_DETECTION_ENABLED=$AUDIO_DETECTION_POWER
                fi

            if (( now - last_log_ts >= 30 )); then
                remaining_dim=$(( dim_delay - (now - last_ts) ))
                remaining_backlight=$(( backlight_delay - (now - last_ts) ))
                remaining_suspend=$(( suspend_delay - (now - last_ts) ))
                (( remaining_dim < 0 )) && remaining_dim=0
                (( remaining_backlight < 0 )) && remaining_backlight=0
                (( remaining_suspend < 0 )) && remaining_suspend=0
            
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - ${RESET}${CYAN}Dim: ${BOLD}${remaining_dim}s${RESET}${CYAN} -> ${RESET}${GREEN}Display off: ${BOLD}${remaining_backlight}s${RESET}${GREEN} -> ${RESET}${MAGENTA}Idle: ${BOLD}${remaining_suspend}s${RESET}" >> "$LOG_FILE"
                last_log_ts=$now
            fi


           if (( idle_elapsed >= dim_delay && idle_elapsed < backlight_delay )); then
            if (( audio_active == 1 )); then
                (( sending_fake_activity == 0 )) && start_fake_activity
            else
                if [[ $was_dimmed -eq 0 ]]; then
                    was_dimmed=1
                    dim_value=$((saved_display_brightness/8))
                    (( dim_value < 1 )) && dim_value=1
                    set_display_brightness "$dim_value"
                    echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Display dimmed to ${RESET}${YELLOW}${dim_value}${RESET}" >> "$LOG_FILE"
                fi
                (( sending_fake_activity == 0 )) && start_fake_activity
            fi
        fi
    
       if (( idle_elapsed >= backlight_delay && idle_elapsed < suspend_delay )); then
            if (( backlight_off == 0 )); then
                if [[ -n "$BRIGHTNESS_PATH" ]]; then
                    printf '%s\n' 0 | sudo tee "$BRIGHTNESS_PATH" >/dev/null 2>&1
                fi
                backlight_off=1
                echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Display and keyboard backlight off${RESET}" >> "$LOG_FILE"
            fi
            (( audio_active == 1 || sending_fake_activity == 0 )) && start_fake_activity
        fi

            if (( idle_elapsed >= suspend_delay )); then
                if (( PRESENTATION_MODE == 1 )); then
                    echo "$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Presentation mode active, suspend skipped." >> "$LOG_FILE"
                    stop_fake_activity
                elif (( audio_active == 1 )); then
                    (( sending_fake_activity == 0 )) && start_fake_activity
                else
                    #stop_fake_activity
                    sleep 0.1
                    echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - Sleep threshold elapsed; going to sleep!" >> "$LOG_FILE"
                    monitor_idle=0
                    idle_since=$now
                    last_ts=$now
                    idle_elapsed=0
                    run_deep_suspend
                    post_suspend_reset
                    stop_fake_activity
                fi
            fi
        fi
    done

    stop_fake_activity
}

stop_monitoring() {
    if [ -f "$PID_FILE" ]; then
        PID=$(cat "$PID_FILE" 2>/dev/null)
        if [[ -n "$PID" ]] && ps -p "$PID" > /dev/null 2>&1; then
            echo "Stopping SleepControl (PID: $PID)..."
            kill -- -"$PID" 2>/dev/null
            kill "$PID" 2>/dev/null
        fi
    fi

    local stray_pids
    stray_pids=$(pgrep -f "$SELF __sleepcontrol_monitor__" 2>/dev/null)
    if [[ -n "$stray_pids" ]]; then
        echo "Stopping stray monitor PIDs: $stray_pids"
        kill $stray_pids 2>/dev/null
    fi

    local waited=0
    while pgrep -f "$SELF __sleepcontrol_monitor__" > /dev/null 2>&1 && (( waited < 50 )); do
        sleep 0.1
        (( waited++ ))
    done

    stray_pids=$(pgrep -f "$SELF __sleepcontrol_monitor__" 2>/dev/null)
    if [[ -n "$stray_pids" ]]; then
        kill -9 $stray_pids 2>/dev/null
        sleep 0.1
    fi

    local stopped_pid=${PID:-"unknown"}
    sudo rm -f "$RUN_FLAG"
    sudo rm -f "$PID_FILE"
    echo "${RED}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - SleepControl Stopped (PID $stopped_pid)${RESET}"
}

case "$1" in
    start)
        if pgrep -f "$SELF __sleepcontrol_monitor__" > /dev/null; then
            echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - SleepControl is already running. ${RESET}" | tee -a "$LOG_FILE"
            exit 0
        fi

        if [[ -n "$BRIGHTNESS_PATH" ]]; then
            current_brightness=$(cat "$BRIGHTNESS_PATH" 2>/dev/null)
            if [[ -z "$current_brightness" || "$current_brightness" -eq 0 ]]; then
                line=$(grep "Setting brightness to" /var/log/power_manager/powerd.LATEST | tail -n1)
                last_brightness=$(echo "$line" | sed -n 's/.*Setting brightness to \([0-9]\+\) (.*/\1/p')
                if [[ -n "$last_brightness" && "$last_brightness" -gt 0 ]]; then
                    printf '%s\n' "$last_brightness" | sudo tee "$BRIGHTNESS_PATH" >/dev/null 2>&1
                fi
            fi
        fi

        stop_monitoring >/dev/null 2>&1

        setsid "$0" __sleepcontrol_monitor__ >> "$LOG_FILE" 2>&1 &
        echo "${BLUE}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - SleepControl Started. Output is logged to $LOG_FILE${RESET}" | tee -a "$LOG_FILE"
        ;;
    stop)
        if [[ -n "$BRIGHTNESS_PATH" ]]; then
            current_brightness=$(cat "$BRIGHTNESS_PATH" 2>/dev/null)
            if [[ -z "$current_brightness" || "$current_brightness" -eq 0 ]]; then
                line=$(grep "Setting brightness to" /var/log/power_manager/powerd.LATEST | tail -n1)
                last_brightness=$(echo "$line" | sed -n 's/.*Setting brightness to \([0-9]\+\) (.*/\1/p')
                if [[ -n "$last_brightness" && "$last_brightness" -gt 0 ]]; then
                    printf '%s\n' "$last_brightness" | sudo tee "$BRIGHTNESS_PATH" >/dev/null 2>&1
                fi
            fi
        fi

        stop_monitoring >/dev/null 2>&1
        echo "${RED}$(printf '%(%Y-%m-%d %H:%M:%S)T\n' -1) - SleepControl Stopped (PID $PID)${RESET}"
        ;;
    battery|power)
    MODE=$1

     if [[ "$2" == "audio" ]]; then
        set_audio_detection "$MODE" "$3"
        exit 0
        fi

    if [[ $# -eq 4 ]]; then
        DIM_VAL=$2
        BACKLIGHT_VAL=$3
        DELAY_VAL=$4

        for v in "$DIM_VAL" "$BACKLIGHT_VAL" "$DELAY_VAL"; do
            if ! [[ "$v" =~ ^[0-9]+$ && "$v" -ge 1 && "$v" -le 9999 ]]; then
                echo "${RED}Values must be integers between 1 and 9999 minutes${RESET}"
                exit 1
            fi
        done

        if (( DIM_VAL > BACKLIGHT_VAL )); then
            echo "${RED}Dim delay cannot be greater than display off delay${RESET}"
            exit 1
        fi

        if (( BACKLIGHT_VAL > DELAY_VAL )); then
            echo "${RED}Display off delay cannot be greater than idle delay${RESET}"
            exit 1
        fi

        if [[ "$MODE" == "battery" ]]; then
            BATTERY_DIM_DELAY=$DIM_VAL
            BATTERY_BACKLIGHT=$BACKLIGHT_VAL
            BATTERY_DELAY=$DELAY_VAL
        else
            POWER_DIM_DELAY=$DIM_VAL
            POWER_BACKLIGHT=$BACKLIGHT_VAL
            POWER_DELAY=$DELAY_VAL
        fi

        save_config
        echo "${BLUE}${BOLD}${MODE^}${RESET}${BLUE} = Dim: $((DIM_VAL)) min -> Display off: $((BACKLIGHT_VAL)) min -> Idle: $((DELAY_VAL)) min${RESET}"
        load_config

    elif [[ $# -eq 3 ]]; then
        BACKLIGHT_VAL=$2
        DELAY_VAL=$3

        if ! [[ "$BACKLIGHT_VAL" =~ ^[0-9]+$ && "$DELAY_VAL" =~ ^[0-9]+$ ]]; then
            echo "${RED}Invalid values. Usage: sleepcontrol $MODE <backlight_off_delay> <sleep_delay>${RESET}"
            exit 1
        fi

        if (( BACKLIGHT_VAL < 1 || BACKLIGHT_VAL > 9999 || DELAY_VAL < 1 || DELAY_VAL > 9999 )); then
            echo "${RED}Values must be integers between 1 and 9999 minutes${RESET}"
            exit 1
        fi

        if (( BACKLIGHT_VAL > DELAY_VAL )); then
            echo "${RED}Backlight timeout cannot be greater than idle delay${RESET}"
            exit 1
        fi

        if [[ "$MODE" == "battery" ]]; then
            BATTERY_BACKLIGHT=$BACKLIGHT_VAL
            BATTERY_DELAY=$DELAY_VAL
        else
            POWER_BACKLIGHT=$BACKLIGHT_VAL
            POWER_DELAY=$DELAY_VAL
        fi

        save_config
        echo "${BLUE}${BOLD}${MODE^}${RESET}${BLUE} = Timeout: $((POWER_BACKLIGHT)) min -> Idle: $((POWER_DELAY)) min${RESET}"
        load_config


    elif [[ $# -eq 2 ]]; then
        VAL=$2

        if ! [[ "$VAL" =~ ^[0-9]+$ && "$VAL" -ge 1 && "$VAL" -le 9999 ]]; then
            echo "${RED}Invalid value. Must be an integer between 1 and 9999${RESET}"
            exit 1
        fi

        if [[ "$MODE" == "battery" ]]; then
            BATTERY_DELAY=$VAL
        else
            POWER_DELAY=$VAL
        fi

        save_config
        echo "${BLUE}${BOLD}${MODE^}${RESET}${BLUE} = Idle: $((POWER_DELAY)) min${RESET}"
        load_config

    else
        load_config
       if [[ "$MODE" == "battery" ]]; then
            echo "${BLUE}Battery = Dim: $((BATTERY_DIM_DELAY)) min -> Display off: $((BATTERY_BACKLIGHT)) min -> Idle: $((BATTERY_DELAY)) min | Audio Detection: $AUDIO_DETECTION_BATTERY Lid Sleep: $LIDSLEEP_POWER ${RESET}"
        else
            echo "${BLUE}Power = Dim: $((POWER_DIM_DELAY)) min -> Display off: $((POWER_BACKLIGHT)) min -> Idle: $((POWER_DELAY)) min | Audio Detection: $AUDIO_DETECTION_POWER | Lid Sleep: $LIDSLEEP_BATTERY ${RESET}"
        fi
    fi
        ;;
        startup)
        CONF_SOURCE="$INSTALL_DIR/sleepcontrol.conf"
        CONF_TARGET="/etc/init/sleepcontrol.conf"

        read -p "Do you want SleepControl to startup automatically? (y/n): " choice
        if [[ "$choice" =~ ^[Yy]$ ]]; then
            if [ -f "$CONF_SOURCE" ]; then
                echo "Copying sleepcontrol.conf to /etc/init/..."
                sudo cp "$CONF_SOURCE" "$CONF_TARGET"
                echo "${BLUE}sleepcontrol.conf copied.${RESET}"
            else
                echo "${RED}sleepcontrol.conf not found at $CONF_SOURCE${RESET}"
            fi
        else
            echo "SleepControl will not startup automatically."
            sudo rm -f /etc/init/sleepcontrol.conf >/dev/null 2>&1
        fi
        ;;
        status|"")
        load_config
        if [ -f "$RUN_FLAG" ]; then
            PID=$(cat "$PID_FILE")
            if ps -p "$PID" > /dev/null 2>&1; then
echo "${BLUE}"
echo "═════════════════════════════════════════════════════════════════════════════════════════════════════"
echo "                          SleepControl Status: RUNNING (PID $PID)                                  "                                 
echo ""
            else
echo "${RED}"
echo "═════════════════════════════════════════════════════════════════════════════════════════════════════"
echo " SleepControl Status: RUN FLAG PRESENT, but process not yet running (120s delay on boot)"
echo ""

            fi

         else
echo "${RED}"
echo "═════════════════════════════════════════════════════════════════════════════════════════════════════"
echo "                              SleepControl Status: STOPPED                                       "
        fi
echo "  Battery = Dim: $((BATTERY_DIM_DELAY)) min -> Display off: $((BATTERY_BACKLIGHT)) min -> Sleep: $((BATTERY_DELAY)) min | Audio Detection: $AUDIO_DETECTION_BATTERY | Lid Sleep: $LIDSLEEP_BATTERY "
echo "  Power   = Dim: $((POWER_DIM_DELAY)) min -> Display off: $((POWER_BACKLIGHT)) min -> Sleep: $((POWER_DELAY)) min | Audio Detection: $AUDIO_DETECTION_POWER | Lid Sleep: $LIDSLEEP_POWER "
echo "═════════════════════════════════════════════════════════════════════════════════════════════════════"
echo "${RESET}"
       
        ;;
    __sleepcontrol_monitor__)
        monitor_idle_activity
        ;;
        --h|-h|h|--help|-help|help)
            show_help
        ;;
    monitor|mon)
        tail -f /var/log/sleepcontrol.log
        ;;
    powerd)
        tail -f /var/log/power_manager/powerd.LATEST
        ;;
    stop)
        stop_monitoring
        ;;
    mode)
        if [[ $# -eq 2 ]]; then
            SUSPEND_MODE="$2"
            if [[ "$SUSPEND_MODE" != "freeze" && "$SUSPEND_MODE" != "deep" ]]; then
                echo ""
                echo "${RED}Invalid suspend type: ${SUSPEND_MODE}${RESET}"
                echo "${BLUE}Valid suspend types: freeze or deep${RESET}"
                echo ""
                exit 1
            fi

            if [[ "$SUSPEND_MODE" == "deep" ]]; then
                for f in /var/lib/power_manager/disable_dark_resume \
                         /usr/share/power_manager/disable_dark_resume \
                         /mnt/stateful_partition/encrypted/var/lib/power_manager/disable_dark_resume; do
                    [[ -f "$f" ]] && echo 0 | sudo tee "$f" 2>/dev/null
                done
            fi
        
            echo "$SUSPEND_MODE" | sudo tee /usr/share/power_manager/suspend_mode 2>/dev/null
            sudo restart powerd >/dev/null
    
            if [[ "$SUSPEND_MODE" == "freeze" ]]; then
                echo s2idle | sudo tee /sys/power/mem_sleep 2>/dev/null
            else
                echo deep | sudo tee /sys/power/mem_sleep 2>/dev/null
            fi
    
            save_config
            echo ""
            echo "${BLUE}Suspend mode set to: $SUSPEND_MODE${RESET}"
            echo ""
        else
            echo "${BLUE}"
            echo "Valid suspend types: freeze | deep"
            echo "Current suspend mode:"
            echo ""
            echo "${RESET}${BOLD}${BLUE$}$(cat /sys/power/mem_sleep)${RESET}${BLUE}"
            echo ""
            echo "Note: freeze is s2idle - use freeze to apply correct value."
            echo "If set to deep, ChromeOS_PowerControl logic will continue to function when plugged in."
            echo "This logic is overridden on battery - with s2idle being auto-applied and then reverted when back on power."
            echo "${RESET}"
        fi
        ;;
    lidsleep | lid)
            if [[ $# -eq 3 ]]; then
                MODE=$2
                VAL=$3
    
                if [[ "$MODE" != "battery" && "$MODE" != "power" ]]; then
                    echo "${RED}Invalid mode: $MODE. Use 'battery' or 'power'${RESET}"
                    exit 1
                fi
    
                if ! [[ "$VAL" =~ ^[0-1]$ ]]; then
                    echo "${RED}Invalid value: $VAL. Must be 0 (disabled) or 1 (enabled)${RESET}"
                    exit 1
                fi
    
                if [[ "$MODE" == "battery" ]]; then
                    LIDSLEEP_BATTERY=$VAL
                else
                    LIDSLEEP_POWER=$VAL
                fi
    
                save_config
                echo ""
                echo "${BLUE}Lid sleep for $MODE set to: $VAL${RESET}"
                echo ""
                load_config
    
            elif [[ $# -eq 1 ]]; then
                load_config
                echo "${BLUE}"
                echo "  Lid sleep settings:"
                echo "  Battery: $LIDSLEEP_BATTERY"
                echo "  Power  : $LIDSLEEP_POWER"
                echo "${RESET}"
            else
                echo ""
                echo "${RED}Usage: sleepcontrol lid battery 1${RESET}"
                echo "${RED}Usage: sleepcontrol lid power 0${RESET}"
                echo ""
                exit 1
            fi
        ;;
    *)
        show_help
        ;;
esac