$ ftp -o /tmp/quicklisp.lisp https://beta.quicklisp.org/quicklisp.lisp
$ ftp -o /tmp/quicklisp-setup.lisp https://codeberg.org/Izder456/dotfiles/raw/branch/main/quicklisp-setup.lisp
$ sbcl --load /tmp/quicklisp.lisp --script /tmp/quicklisp-setup.lisp

#!/bin/ksh

# Constants
USERHOME=$HOME
CODEBERG="https://codeberg.org"
SLEEPTIME=2
LOG_FILE="$HOME/setup.log"

# Set PATH explicitly
export PATH='/bin:/usr/bin:/sbin:/usr/sbin:/usr/X11R6/bin:/usr/local/bin:/usr/local/sbin:$HOME/bin'

# Throw an error!
function exception {
    error=$1
    echo "Error: $error"
    exit 1
}

# Log setup messages with timestamp
function log {
    message=$1
    stdout=${2:-1}  # Default to logging to stdout if not specified
    timestamp=$(date +"%Y%m%d%H%M%S")

    if [[ $stdout -eq 1 ]]; then
        echo "$message"
    fi

    echo "[$timestamp] $message" >> "$LOG_FILE" 2>&1 || exception "Could not write to $LOG_FILE"
}

# check for config sanity
for configfile in "/etc/doas.conf" "/etc/sysctl.conf"; do
    if [ -f $configfile ]; then
        grep -q "pickles" "${configfile}" && \
            exception "Pickles error. Please read the config file you just installed." || \
                echo "Pickles are fine. Thanks for reading."
    else
        exception "Did you read the readme? Install the doas.conf and sysctl.conf and read them over."
    fi
done

# Clean unnecessary files
function clean {
    log "Removing Cruft..."
    rex remove_default_cruft
}

# Ensure Lisp environment is set up
function ensure_lisp {
    log "Quicklisp Setup"
    if [[ "${quicklisp}" == "on" ]]; then
        log "quicklisp set on."
        log "Installing quicklisp and related deps..."
        if [ -d $HOME/.quicklisp ]; then
            log "Quicklisp install dir found... removing that..."
            printf "Press any key..."
            read
            rm -Rvf $HOME/.quicklisp
        fi
        doas pkg_add -m sbcl rlwrap || exception "Could not install sbcl or rlwrap"
        ftp -o /tmp/quicklisp.lisp "https://beta.quicklisp.org/quicklisp.lisp" || exception "Failed to download quicklisp.lisp"
        ftp -o /tmp/quicklisp-setup.lisp "$CODEBERG/izder456/dotfiles/raw//branch/main/quicklisp-setup.lisp" || exception "Failed to download quicklisp-setup.lisp"
        sbcl --load /tmp/quicklisp.lisp --script /tmp/quicklisp-setup.lisp || exception "Failed to run quicklisp setup"
    elif [[ "${quicklisp}" == "off" ]]; then
        log "quicklisp set off."
        log "Skipping..."
    else
        exception "Invalid quicklisp setting. how did we get here?"
    fi
}

# Install port dependencies
function ports_deps {
    log "Installing port dependencies..."
    if [[ "${pkglite}" == "off" ]]; then
        log "pkglite set off."
        log "Installing full package set."
        doas pkg_add -m -l ~/.pkglist || exception "Failed to install port dependencies"
    elif [[ "${pkglite}" == "on" ]]; then
        log "pkglite set on."
        log "Installing lite package set."
        doas pkg_add -m -l ~/.pkglistlite || exeption "Failed to install port dependencies"
    else
        exception "Invalid pkglite setting. how did we get here?"
    fi
}

# Install cargo dependencies
function cargo_deps {
    if [[ "${rustdeps}" == "on" ]]; then
        log "rustdeps set on."
        log "Installing cargo dependencies."
        doas pkg_add rust || exception "Failed to install Rust"
        xargs cargo install < ~/.cargolist || exception "Failed to install rust dependencies"
    elif [[ "${rustdeps}" == "off" ]]; then
        log "rustdeps set off."
        log "Skipping..."
    else
        exception "Invalid rustdep setting. how did we get here?"
    fi
}

function setup_gtkicons {
    log "Setting up gtk themes..."
    rex configure_gtk
    log "Setting up icon themes..."
    rex configure_icons
}

# Clone or update dotfiles repository and run setup scripts
function config_install {
    log "Cloning/Installing Dotfiles..."
    if [ -d "$USERHOME/.dotfiles" ]; then
        cd $USERHOME/.dotfiles || exception "Failed to change directory to .dotfiles"
        GIT_TRACE=1 git pull --recurse-submodules --depth 1 --verbose || exception "Failed to pull dotfiles"
    else
        GIT_TRACE=1 git clone --recurse-submodules --depth 1 --single-branch --verbose $CODEBERG/Izder456/dotfiles.git $USERHOME/.dotfiles || exception "Failed to clone dotfiles"
    fi
    if [[ "${gtkicons}" == "on" ]]; then
        log "gtkicons set on"
        setup_gtkicons
    elif [[ "${gtkicons}" == "off" ]]; then
        log "gtkicons set off"
        log "Skipping..."
    else
        exception "Invalid gtkicons setting. how did we get here?"
    fi
    $USERHOME/.dotfiles/dfm/dfm install
}

# Setup ZSH shell
function setup_shell {
    log "Setting up FiZSH..."
    rex configure_default_shell
    rex compile_afetch
}

# Setup URxvt
function setup_urxvt {
    log "Setting up urxvt..."
    rex configure_urxvt
}

# Setup background images
function setup_backgrounds {
    log "Installing Backgrounds..."
    rex install_backgrounds
}

# Setup Emacs
function setup_emacs {
    log "Setting up Emacs..."
    rex configure_emacs
}

# Setup Enhanced Motif WM
function setup_fvwm {
    log "Setting up FVWM..."
    rex configure_fvwm
}

# Setup StumpWM
function setup_stumpwm {
    ensure_lisp
    log "Setting up StumpWM..."
    rex configure_stumpwm
}

# Miscellaneous setup tasks
function setup_misc {
    setup_shell
    log "Miscellaneous setup..."
    rex compile_shuf
    rex compile_slock
    rex compile_st
    rex compile_surf
    rex configure_apmd
    rex install_backgrounds
    rex update_xdg
}

# Setup XenoDM
function setup_xenodm {
    log "Setting up XenoDM..."
    rex configure_xenodm
}

# Check for internet connection
function is_internet_up {
    log "Checking internet connection..."
    nc -zw1 OpenBSD.org 443 || exception "You need internet for this dumdum!"
    log "Internet connection is up!"
}

# Ensure necessary tools are installed
function ensure_needed {
    log "Installing necessary tools: git, git-lfs and p5-Rex..."
    doas pkg_add -m p5-Rex git git-lfs || exception "Failed to install git, git-lfs and p5-Rex"
    log "Setting up git-lfs..."
    git lfs install
    ftp -o $USERHOME/Rexfile $CODEBERG/Izder456/dotfiles/raw/branch/main/Rexfile || exception "Failed to download Rexfile"
}

# Ensure all prerequisites
function do_ensure {
    echo "Log file is at ${LOG_FILE}"
    echo "Refer to it for debugging"
    printf "Press any key..."
    read
    is_internet_up
    ensure_needed
}

do_ensure

# Default states
pkglite="off" # set full package set by default
gtkicons="on" # set downloading gtk themes and icons enabled by default
rustdeps="on" # set rust/cargo deps by default
quicklisp="on" # install/set up quicklisp and dependencies

# Function to confirm toggles
function confirm_toggles {
    log ''
    log 'Current toggles:'
    log "pkglite:   $pkglite"
    log "gtkicons:  $gtkicons"
    log "rustdeps:  $rustdeps"
    log "quicklisp: $quicklisp"
    log ''
    printf "Are these settings correct? (y/N) "
}

# Function to prompt for toggles
function toggle_prompt {
    log ''
    log 'Fine tuned toggles:'
    log '---------------------------------------------------------'
    log ' Key:                                                    '
    log ' - pkglite   means: "lite packages"                      '
    log ' - gtkicons  means: "gtk themes and icons"               '
    log ' - rustdeps  means: "rust deps on supported archs"       '
    log ' - quicklisp means: "common lisp deps needed for stumpwm"'
    log '---------------------------------------------------------'
    while true; do
        confirm_toggles # Confirm toggles with the end user.
        read confirmation
        if [[ "$confirmation" == "y" ]]; then
            break
        else
            # Loop through each variable and prompt user to set its value directly
            for toggle in pkglite gtkicons rustdeps quicklisp; do
                eval current_value=\$$toggle

                # Adjust capitalization of the prompt dynamically
                if [ "$current_value" = "on" ]; then
                    default_prompt="ON/off"
                else
                    default_prompt="on/OFF"
                fi

                while true; do
                    # Prompt user
                    printf "Turn $toggle on or off? ($default_prompt): "
                    read answer

                    # Handle user input
                    case "$answer" in
                        "on"|"ON"|"y"|"Y")
                            eval "$toggle=on"
                            log "$toggle set to on." 0
                            break
                            ;;
                        "off"|"OFF"|"n"|"N")
                            eval "$toggle=off"
                            log "$toggle set to off." 0
                            break
                            ;;
                        "")
                            # Keep current value if no input is given
                            log "Keeping $toggle as $current_value." 0
                            break
                            ;;
                        *)
                            log "Invalid input. Please enter 'on' or 'off', or press Enter to keep the current value." 0
                            ;;
                    esac
                done
            done
        fi
    done
}

# Display menu and handle user input
function menu {
    while true; do
        clear

        echo 'Srcerizder Dotfiles Setup'
        echo 'Options:'
        echo '---------------------------------------'
        echo '0) Packages (lite)  1) Packages (all)'
        echo '2) StumpWM          3) FVWM'
        echo '4) Emacs            5) XenoDM'
        echo '6) Rust Packages    7) GTK/Icons'
        echo '8) Misc. Config     9) Misc. Software'
        echo
        echo 'Other Options:'
        echo '----------------'
        echo 'a) All (recommended)'
        echo 'r) Reload Menu'
        echo 'q) Quit'
        echo

        printf "Enter your selection: "
        read selection # Move the input prompt to the same line

        [ -z $selection ] && selection="r"

        # reset these vars incase the user selected otherwise and it failed.
        pkglite="off" # set full package set by default
        gtkicons="on" # set downloading gtk themes and icons enabled by default
        rustdeps="on" # set rust/cargo deps by default
        quicklisp="on" # install/set up quicklisp and dependencies

        case $selection in
            0)
                echo "Selected Lite Package List Install..."; sleep $SLEEPTIME; pkglite="on"; ports_deps;
                ;;
            1)
                echo "Selected Full Package List Install..."; sleep $SLEEPTIME; pkglite="off"; ports_deps
                ;;
            2)
                echo "Selected StumpWM Config..."; sleep $SLEEPTIME; quicklisp="on"; setup_stupmwm;
                ;;
            3)
                echo "Selected FVWM Config..."; sleep $SLEEPTIME; setup_fvwm;
                ;;
            4)
                echo "Selected Emacs Config..."; sleep $SLEEPTIME; setup_emacs;
                ;;
            5)
                echo "Selected XenoDM Config..."; sleep $SLEEPTIME; setup_xenodm;
                ;;
            6)
                echo "Selected Rust Deps..."; sleep $SLEEPTIME; cargo_deps;
                ;;
            7)
                echo "Selected GTK Theme/Icon Theme Setup..."; sleep $SLEEPTIME; setup_gtkicon;
                ;;
            8)
                echo "Selected Misc. Configs..."; sleep $SLEEPTIME; config_install;
                ;;
            9)
                echo "Selected Misc. Software..."; sleep $SLEEPTIME; setup_misc;
                ;;
            "a")
                echo "Running All...";
                toggle_prompt; # let the use toggle what they wish
                sleep $SLEEPTIME; clean;
                config_install; ports_deps; cargo_deps;
                setup_fvwm; setup_stumpwm; setup_urxvt; setup_emacs; setup_xenodm;
                setup_misc;
                ;;
            "r")
                continue;
                ;;
            "q")
                echo "";
                exit;
                ;;
            *)
                echo "Invalid selection";
                sleep $SLEEPTIME;
                ;;
        esac
    done
}

menu

#!/bin/ksh

readonly XMESG_WIDTH=512
readonly XMESG_HEIGHT=128

# Hardware acceleration and style overrides
export MOZ_ACCELERATED=1
export MOZ_WEBRENDER=1
export QT_STYLE_OVERRIDE=kvantum
export SDL_VIDEO_X11_DGAMOUSE=0

# Function to ensure XDG environment variables are set
function xdg_runtime {
    export XDG_RUNTIME_DIR=/tmp/run/user/$(id -u)
    export XDG_CONFIG_HOME=$HOME/.config
    export XDG_CACHE_HOME=$HOME/.cache
    export XDG_DATA_DIR=$HOME/.local/share
    export XDG_STATE_HOME=$HOME/.local/state
    [ -n "${selected_wm}" ] && export XDG_CURRENT_DESKTOP="${selected_wm}"
    [ ! -d "$XDG_RUNTIME_DIR" ] && mkdir -m 700 -p "$XDG_RUNTIME_DIR"
}

# Get screen width (0) or height (1)
function get_screen_dimension {
    typeset dimension=$(xrandr --current | grep '*' | uniq | awk '{print $1}' | head -n1)
    case $1 in
        0) echo "${dimension%x*}" ;;
        1) echo "${dimension#*x}" ;;
        *) echo "Invalid argument. Use 0 for width or 1 for height." ;;
    esac
}

# Load files if they exist
function load_environment {
    set -A files "$@"
    for file in "${files[@]}"; do
        [ -f "$file" ] && . "$file"
    done
}

# Merge X resources
function load_resources {
    set -A resources "$@"
    for resource in "${resources[@]}"; do
        [ -f "$resource" ] && xrdb -merge "$resource"
    done
}

# Run a list of background processes, killing any previous instance
function run_commands {
    set -A commands "$@"
    for cmd in "${commands[@]}"; do
        typeset pname="${cmd%% *}"
        pkill "$pname" 2>/dev/null
        eval "$cmd" &
    done
}

# Play a random startup WAV sound from directory
function play_startup_sound {
    if command -v aucat &>/dev/null; then
        sleep 1
        aucat -i $(find "$1" -type f -name '*.wav' | sort -R | head -n1)
    fi
}

# Set default input/output volume
function set_default_volume {
    sndioctl input.level=0.45
    sndioctl output.level=1.00
}

# Helper to calculate xmessage position
function get_centered_geometry {
    typeset xwidth=$(get_screen_dimension 0)
    typeset xheight=$(get_screen_dimension 1)
    typeset xpos=$(( (xwidth - XMESG_WIDTH) / 2 ))
    typeset ypos=$(( (xheight - XMESG_HEIGHT) / 2 ))
    echo "${XMESG_WIDTH}x${XMESG_HEIGHT}+${xpos}-${ypos}"
}

# Prompt to choose a window manager
function select_wm {
    typeset geometry=$(get_centered_geometry)
    xmessage "Please Choose a Session to load" \
             -buttons "StumpWM[]":1,"FVWM[]":2 \
             -default "StumpWM[]" \
             -geometry "$geometry"
    case $? in
        1) echo "stumpwm" ;;
        2) echo "fvwm" ;;
        *) echo "stumpwm" ;;
    esac
}

# Load env and resources
load_environment /etc/profile ~/.profile
load_resources ~/.Xresources ~/.xresources.d/emwm

# Select WM
selected_wm=$(select_wm)

# Resolve WM binary
case "$selected_wm" in
    stumpwm) wm=$(command -v stumpwm) ;;
    fvwm)    wm=$(command -v fvwm) ;;
esac
wm_args=""

# Disable core dumps
ulimit -Sc 0

# Cleanup stray processes trap
trap 'pkill -U $(id -u) -P $$' EXIT INT TERM
trap 'kill -- -$AUTOSTART_GRP' EXIT INT TERM

# XDG + GPG Setup
xdg_runtime

# Autostart common services
(
    run_commands \
        "picom -b" \
        "emacs --daemon" \
        "nxbelld -t 150 -v100 -d200 -f ~/.local/alert/Funk.wav -b" \
        "feh --bg-fill --randomize /usr/local/share/backgrounds" \
        "xidle -delay 5 -nw -program /usr/local/bin/slock -timeout 1800" \
        "dunst --startup_notification true"

    [ -f ~/.autostart ] && (sleep 10 && sh ~/.autostart)
) &

AUTOSTART_GRP=$!

# Set volumes
set_default_volume

# Play startup SFX
(play_startup_sound ~/.local/sfx/) &

# DBus
if [ -x /usr/local/bin/dbus-launch -a -z "${DBUS_SESSION_BUS_ADDRESS}" ]; then
    eval `dbus-launch --sh-syntax --exit-with-x11`
fi

# Launch WM
if ! exec "$wm" $wm_args; then
    echo "Failed to launch window manager $wm."
    exit 1
fi

exit 0

# ZSH
export ENV=~/.zprofile

# Locale
export LC_CTYPE="en_US.UTF-8"
export LC_ALL="en_US.UTF-8"

# Editors
if command -v aee >/dev/null; then
    export EDITOR="aee"
    export VISUAL="aee"
elif command -v ee >/dev/null; then
    export EDITOR="ee"
    export VISUAL="ee"
elif command -v nvi >/dev/null; then
    export EDITOR="nvi"
    export VISUAL="nvi"
else
    export EDITOR="vi"
    export VISUAL="vi"
fi

# Pager
export PAGER=less
export MANPAGER=less

# Java
export JAVA_HOME=/usr/local/jdk-17
export PATH=$PATH:$JAVA_HOME/bin

# Erlang
export PATH=$PATH:/usr/local/lib/erlang27/bin

# Go
export GOPATH=$HOME/.go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

# Ruby
export GEM_HOME="$HOME/.gems"
export PATH=$PATH:$GEM_HOME/bin

# Cargo
export PATH=$HOME/.cargo/bin:$PATH

# Local
export PATH=$HOME/.local/bin:$PATH

# OS-specific PATH additions
case "$(uname)" in
    OpenBSD)
        export PATH=/usr/ports/infrastructure/bin:/usr/games:$PATH
        ;;
    Linux)
        export PATH=/usr/sbin:/sbin:$PATH
        ;;
esac

#!/usr/bin/env zsh

# Load env
[[ -f ~/.profile ]] && source ~/.profile

##
# Check if TTY if on OpenBSD
##

if [[ "$(uname)" == "OpenBSD" ]]; then
    if [[ "$(tty)" == "/dev/ttyC"* ]]; then
        export TERM=wsvt25
    fi
fi

##
# Prompt
##

setopt prompt_subst
autoload -Uz colors vcs_info
colors

zstyle ':vcs_info:*' enable git
zstyle ':vcs_info:git:*' check-for-changes true
zstyle ':vcs_info:git:*' stagedstr "+"
zstyle ':vcs_info:git:*' unstagedstr "*"
zstyle ':vcs_info:git:*' formats ' git:(%b%u%c)'
zstyle ':vcs_info:git:*' actionformats ' git:(%b|%a%u%c)'

function precmd {
    vcs_info
    local color
    case "$(uname)" in
	OpenBSD) color="%F{yellow}" ;;
	FreeBSD) color="%F{green}" ;;
	*)       color="%F{blue}" ;;
    esac
    local char=$([[ $EUID -eq 0 ]] && echo "%F{red}#%f" || echo "%F{white}$%f")
    PROMPT="${color}%~%f${vcs_info_msg_0_} ${char} "
}

##
# Lazy Loading
##

source ~/.zshrc.d/defer/zsh-defer.plugin.zsh

##
# Autoload zmv
##

zsh-defer autoload -Uz zmv

##
# Setup Completions
##

zsh-defer autoload -U compinit
zsh-defer compinit
zsh-defer autoload -U bashcompinit
zsh-defer bashcompinit

# We don't need to load OpenBSD completions on non-OpenBSD Systems

if [[ "$(uname)" == "OpenBSD" ]]; then
    fpath=($HOME/.zshrc.d/openbsd/completions $HOME/.zshrc.d/completions/src $fpath)
else
    fpath=($HOME/.zshrc.d/completions/src $fpath)
fi
setopt MENU_COMPLETE
setopt AUTO_LIST
setopt COMPLETE_IN_WORD
zsh-defer eval "$(register-python-argcomplete pipx)"

##
# Autopair
##

zsh-defer source ~/.zshrc.d/autopair/autopair.zsh
zsh-defer autopair-init

##
# Suggestions
##

zsh-defer source ~/.zshrc.d/suggest/zsh-autosuggestions.plugin.zsh

##
# Syntax Highlight
##

zsh-defer source ~/.zshrc.d/fsh/fast-syntax-highlighting.plugin.zsh

##
# History substring search
##

zsh-defer source ~/.zshrc.d/substring/zsh-history-substring-search.plugin.zsh
HISTFILE="$HOME/.zshrc.d/.history"
HISTSIZE=100
SAVEHIST=100

##
# Vim-mode
##

MODE_INDICATOR=""
VIM_MODE_TRACK_KEYMAP=no
VIM_MODE_INITIAL_KEYMAP=viins
zsh-defer source ~/.zshrc.d/vim-mode/zsh-vim-mode.plugin.zsh

##
# FZF-Zsh
##

if command -v fzf &> /dev/null; then
    zsh-defer source ~/.zshrc.d/fzf/fzf-tab.plugin.zsh
    zsh-defer source ~/.zshrc.d/fzf-comp/zsh/fzf-zsh-completion.sh
fi

##
# Alias for muscle memory
##

if command -v doas &> /dev/null; then
    alias sudo="doas"
    alias su="echo 'did you mean to run doas -s? '"
elif command -v sudo &> /dev/null; then
    alias doas="sudo"
    alias su="echo 'did you mean to run sudo -i? '"
fi

##
# Alias for CD
##

if command -v zoxide &> /dev/null; then
    zsh-defer eval "$(zoxide init --cmd cd zsh)"
fi

##
# Alias for listing files
##

if command -v eza &> /dev/null; then
    alias ls="eza --icons=never -Hh"
    alias la="eza --icons=never -ah"
    alias ll="eza --icons=never -lh"
    alias lh="eza --icons=never -lAh"
    alias tree="eza --icons=never -Th"
elif command -v colorls &> /dev/null; then
    alias ls="colorls -G -Hh"
    alias la="colorls -G -ah"
    alias ll="colorls -G -lh"
    alias lh="colorls -G -lAh"
elif command -v ls &> /dev/null; then
    alias ls="ls -Hh"
    alias la="ls -ah"
    alias ll="ls -lh"
    alias lh="ls -lAh"
fi

##
# Alias for parsing
##

if command -v bat &> /dev/null; then
    export BAT_THEME=ansi
    alias cat="bat -pp"
    alias bat="bat -p"
fi
if command -v rg &> /dev/null; then
    alias rgrep="rg"
fi

##
# Alias for editing
##

alias edit=$EDITOR
alias vedit=$VISUAL

##
# Alias for media
##

alias audio-dlp="yt-dlp -x --audio-quality 0 --audio-format vorbis \
	--concurrent-fragments 5"
alias video-dlp="yt-dlp --write-subs --sub-format srt --remux-video mkv \
	--embed-subs --concurrent-fragments 5"
alias tidal-dlp="tidal-dl -o /home/izder456/Music -q Master -r P1080 -l "


##
# Tere config
##

function tere {
    local result=$(command tere "$@")
    [ -n "$result" ] && cd -- "$result"
}

##
# Binds
##

bindkey "^[[1;5C" forward-word
bindkey "^[[1;5D" backward-word

bindkey "^[[1;5A" previous-history
bindkey "^[[1;5B" next-history
bindkey '^[[A' history-substring-search-up
bindkey '^[[B' history-substring-search-down

##
# the r/unixporn rite of passage
##

if command -v exfetch &> /dev/null; then
    exfetch
fi

zsh-defer . $HOME/.shellrc.load