Configure Linux environment variables and PATH management for development workflows

#!/usr/bin/env bash
set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Global variables
SCRIPT_NAME="$(basename "$0")"
BACKUP_DIR="/tmp/env_backup_$(date +%s)"

# Usage function
usage() {
    echo "Usage: $SCRIPT_NAME [OPTIONS]"
    echo "Configure Linux environment variables and PATH management"
    echo ""
    echo "Options:"
    echo "  --user-only          Configure only user-level environment"
    echo "  --system-only        Configure only system-level environment"
    echo "  --custom-vars FILE   Load custom variables from file"
    echo "  --help               Show this help message"
    echo ""
    echo "Example:"
    echo "  $SCRIPT_NAME --user-only"
    echo "  $SCRIPT_NAME --custom-vars /path/to/vars.conf"
    exit 1
}

# Logging functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# Cleanup function for rollback
cleanup() {
    if [[ -d "$BACKUP_DIR" ]]; then
        log_warn "Script failed. Restoring backups from $BACKUP_DIR"
        if [[ -f "$BACKUP_DIR/bashrc" ]]; then
            cp "$BACKUP_DIR/bashrc" "$HOME/.bashrc" 2>/dev/null || true
        fi
        if [[ -f "$BACKUP_DIR/profile" ]]; then
            cp "$BACKUP_DIR/profile" "$HOME/.profile" 2>/dev/null || true
        fi
        if [[ -f "$BACKUP_DIR/environment" ]] && [[ "$EUID" -eq 0 ]]; then
            cp "$BACKUP_DIR/environment" /etc/environment 2>/dev/null || true
        fi
    fi
}

# Set up error trap
trap cleanup ERR

# Detect distribution
detect_distro() {
    if [[ -f /etc/os-release ]]; then
        . /etc/os-release
        case "$ID" in
            ubuntu|debian) 
                PKG_MGR="apt"
                PKG_INSTALL="apt install -y"
                PROFILE_DIR="/etc/profile.d"
                ;;
            almalinux|rocky|centos|rhel|ol|fedora) 
                PKG_MGR="dnf"
                PKG_INSTALL="dnf install -y"
                PROFILE_DIR="/etc/profile.d"
                # Use yum for older versions
                if ! command -v dnf &> /dev/null; then
                    PKG_MGR="yum"
                    PKG_INSTALL="yum install -y"
                fi
                ;;
            amzn) 
                PKG_MGR="yum"
                PKG_INSTALL="yum install -y"
                PROFILE_DIR="/etc/profile.d"
                ;;
            *) 
                log_error "Unsupported distribution: $ID"
                exit 1 
                ;;
        esac
        export PKG_MGR PKG_INSTALL PROFILE_DIR
        log_info "Detected distribution: $PRETTY_NAME"
    else
        log_error "Cannot detect distribution - /etc/os-release not found"
        exit 1
    fi
}

# Create backup directory
create_backup() {
    mkdir -p "$BACKUP_DIR"
    log_info "Created backup directory: $BACKUP_DIR"
    
    # Backup user files
    [[ -f "$HOME/.bashrc" ]] && cp "$HOME/.bashrc" "$BACKUP_DIR/bashrc"
    [[ -f "$HOME/.profile" ]] && cp "$HOME/.profile" "$BACKUP_DIR/profile"
    
    # Backup system files if root
    if [[ "$EUID" -eq 0 ]]; then
        [[ -f /etc/environment ]] && cp /etc/environment "$BACKUP_DIR/environment"
    fi
}

# Configure user-level environment variables
configure_user_environment() {
    log_info "Configuring user-level environment variables"
    
    # Ensure .bashrc exists
    if [[ ! -f "$HOME/.bashrc" ]]; then
        touch "$HOME/.bashrc"
        chmod 644 "$HOME/.bashrc"
    fi
    
    # Add development environment variables to .bashrc
    cat >> "$HOME/.bashrc" << 'EOF'

# Development Environment Variables - Added by environment setup script
export EDITOR="${EDITOR:-vim}"
export BROWSER="${BROWSER:-firefox}"
export DEVELOPMENT_MODE="true"

# Custom paths
export MY_SCRIPTS_HOME="$HOME/scripts"
export MY_PROJECTS_HOME="$HOME/projects"

# Add user bin directories to PATH
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"

# Node.js configuration
export NPM_CONFIG_PREFIX="$HOME/.npm-global"
export PATH="$NPM_CONFIG_PREFIX/bin:$PATH"

# Python configuration
export PIP_REQUIRE_VIRTUALENV="false"
export PYTHONPATH="$HOME/.local/lib/python:$PYTHONPATH"

# Go configuration
export GOPATH="$HOME/go"
export PATH="$GOPATH/bin:$PATH"
EOF
    
    # Create user bin directories
    mkdir -p "$HOME/bin" "$HOME/.local/bin" "$HOME/scripts" "$HOME/projects"
    chmod 755 "$HOME/bin" "$HOME/.local/bin" "$HOME/scripts" "$HOME/projects"
    
    log_info "User environment configuration completed"
}

# Configure system-level environment variables
configure_system_environment() {
    if [[ "$EUID" -ne 0 ]]; then
        log_warn "Skipping system configuration - root privileges required"
        return 0
    fi
    
    log_info "Configuring system-level environment variables"
    
    # Configure /etc/environment
    if [[ ! -f /etc/environment ]]; then
        touch /etc/environment
        chmod 644 /etc/environment
    fi
    
    # Add system-wide variables to /etc/environment
    cat >> /etc/environment << 'EOF'

# System Development Environment - Added by environment setup script
JAVA_HOME="/usr/lib/jvm/default-java"
SYSTEM_DEV_MODE="true"
EOF
    
    # Create custom profile script
    cat > "$PROFILE_DIR/99-development.sh" << 'EOF'
#!/bin/bash
# Development environment configuration
# Added by environment setup script

# System development paths
export DEV_TOOLS_PATH="/opt/dev-tools"
export SYSTEM_SCRIPTS_PATH="/opt/scripts"

# Add system development paths to PATH
if [[ ":$PATH:" != *":$DEV_TOOLS_PATH/bin:"* ]]; then
    export PATH="$DEV_TOOLS_PATH/bin:$PATH"
fi

if [[ ":$PATH:" != *":$SYSTEM_SCRIPTS_PATH:"* ]]; then
    export PATH="$SYSTEM_SCRIPTS_PATH:$PATH"
fi

# Database configuration for development
export DB_HOST="${DB_HOST:-localhost}"
export DB_PORT="${DB_PORT:-5432}"

# Development tool configurations
export DOCKER_BUILDKIT="1"
export COMPOSE_DOCKER_CLI_BUILD="1"
EOF
    
    chmod 755 "$PROFILE_DIR/99-development.sh"
    chown root:root "$PROFILE_DIR/99-development.sh"
    
    # Create system directories
    mkdir -p /opt/dev-tools/bin /opt/scripts
    chmod 755 /opt/dev-tools /opt/dev-tools/bin /opt/scripts
    chown root:root /opt/dev-tools /opt/dev-tools/bin /opt/scripts
    
    log_info "System environment configuration completed"
}

# Load custom variables from file
load_custom_variables() {
    local custom_file="$1"
    
    if [[ ! -f "$custom_file" ]]; then
        log_error "Custom variables file not found: $custom_file"
        exit 1
    fi
    
    log_info "Loading custom variables from: $custom_file"
    
    # Validate and source custom variables
    if bash -n "$custom_file"; then
        while IFS='=' read -r key value; do
            # Skip empty lines and comments
            [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
            
            # Export the variable
            export "$key=$value"
            echo "export $key=\"$value\"" >> "$HOME/.bashrc"
        done < <(grep -E '^[A-Z_][A-Z0-9_]*=' "$custom_file")
        
        log_info "Custom variables loaded successfully"
    else
        log_error "Custom variables file contains syntax errors"
        exit 1
    fi
}

# Verify environment configuration
verify_configuration() {
    log_info "Verifying environment configuration"
    
    # Test loading .bashrc
    if bash -n "$HOME/.bashrc"; then
        log_info "✓ .bashrc syntax is valid"
    else
        log_error "✗ .bashrc contains syntax errors"
        return 1
    fi
    
    # Test environment variable access
    if source "$HOME/.bashrc" && [[ -n "${DEVELOPMENT_MODE:-}" ]]; then
        log_info "✓ User environment variables loaded correctly"
    else
        log_warn "⚠ User environment variables may not be loading correctly"
    fi
    
    # Check directory creation
    local dirs=("$HOME/bin" "$HOME/.local/bin" "$HOME/scripts" "$HOME/projects")
    for dir in "${dirs[@]}"; do
        if [[ -d "$dir" ]]; then
            log_info "✓ Directory exists: $dir"
        else
            log_error "✗ Directory missing: $dir"
        fi
    done
    
    # Check system configuration if root
    if [[ "$EUID" -eq 0 ]] && [[ -f "$PROFILE_DIR/99-development.sh" ]]; then
        if bash -n "$PROFILE_DIR/99-development.sh"; then
            log_info "✓ System profile script is valid"
        else
            log_error "✗ System profile script contains errors"
        fi
    fi
    
    log_info "Configuration verification completed"
}

# Main function
main() {
    local user_only=false
    local system_only=false
    local custom_vars_file=""
    
    # Parse arguments
    while [[ $# -gt 0 ]]; do
        case $1 in
            --user-only)
                user_only=true
                shift
                ;;
            --system-only)
                system_only=true
                shift
                ;;
            --custom-vars)
                custom_vars_file="$2"
                shift 2
                ;;
            --help)
                usage
                ;;
            *)
                log_error "Unknown option: $1"
                usage
                ;;
        esac
    done
    
    echo "[1/6] Detecting Linux distribution"
    detect_distro
    
    echo "[2/6] Creating backup of existing configuration"
    create_backup
    
    if [[ "$system_only" != true ]]; then
        echo "[3/6] Configuring user-level environment variables"
        configure_user_environment
    else
        echo "[3/6] Skipping user configuration (--system-only specified)"
    fi
    
    if [[ "$user_only" != true ]]; then
        echo "[4/6] Configuring system-level environment variables"
        configure_system_environment
    else
        echo "[4/6] Skipping system configuration (--user-only specified)"
    fi
    
    if [[ -n "$custom_vars_file" ]]; then
        echo "[5/6] Loading custom variables"
        load_custom_variables "$custom_vars_file"
    else
        echo "[5/6] No custom variables file specified"
    fi
    
    echo "[6/6] Verifying configuration"
    verify_configuration
    
    log_info "Environment variable configuration completed successfully!"
    log_info "Restart your terminal or run 'source ~/.bashrc' to apply changes"
    log_info "Backup files are available in: $BACKUP_DIR"
}

# Run main function with all arguments
main "$@"