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

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

# Default values
SERVICE_NAME=""
SERVICE_DESCRIPTION=""
EXEC_START=""
WORKING_DIR=""
SERVICE_TYPE="exec"
RESTART_POLICY="always"
RESTART_SEC="5"
ENVIRONMENT_VARS=""

# Usage function
usage() {
    echo "Usage: $0 [OPTIONS]"
    echo "Configure systemd user services for application startup"
    echo ""
    echo "OPTIONS:"
    echo "  -n, --name NAME           Service name (required)"
    echo "  -d, --description DESC    Service description"
    echo "  -e, --exec COMMAND        Command to execute (required)"
    echo "  -w, --workdir DIR         Working directory (defaults to \$HOME)"
    echo "  -t, --type TYPE           Service type (default: exec)"
    echo "  -r, --restart POLICY      Restart policy (default: always)"
    echo "  -s, --restart-sec SEC     Restart delay in seconds (default: 5)"
    echo "  --env KEY=VALUE           Environment variable (can be used multiple times)"
    echo "  -h, --help               Show this help"
    echo ""
    echo "Examples:"
    echo "  $0 -n webserver -d 'Personal Web Server' -e '/usr/bin/python3 -m http.server 8080' -w '\$HOME/public'"
    echo "  $0 -n nodeapp -e '/usr/bin/node server.js' -w '\$HOME/myapp' --env NODE_ENV=production --env PORT=3000"
}

# Cleanup function
cleanup() {
    if [ $? -ne 0 ]; then
        echo -e "${RED}[ERROR] Script failed. Check the output above for details.${NC}"
    fi
}

trap cleanup EXIT

# Log functions
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Parse command line arguments
parse_args() {
    while [[ $# -gt 0 ]]; do
        case $1 in
            -n|--name)
                SERVICE_NAME="$2"
                shift 2
                ;;
            -d|--description)
                SERVICE_DESCRIPTION="$2"
                shift 2
                ;;
            -e|--exec)
                EXEC_START="$2"
                shift 2
                ;;
            -w|--workdir)
                WORKING_DIR="$2"
                shift 2
                ;;
            -t|--type)
                SERVICE_TYPE="$2"
                shift 2
                ;;
            -r|--restart)
                RESTART_POLICY="$2"
                shift 2
                ;;
            -s|--restart-sec)
                RESTART_SEC="$2"
                shift 2
                ;;
            --env)
                ENVIRONMENT_VARS="${ENVIRONMENT_VARS}Environment=$2\n"
                shift 2
                ;;
            -h|--help)
                usage
                exit 0
                ;;
            *)
                log_error "Unknown option: $1"
                usage
                exit 1
                ;;
        esac
    done

    # Validate required arguments
    if [ -z "$SERVICE_NAME" ] || [ -z "$EXEC_START" ]; then
        log_error "Service name and exec command are required"
        usage
        exit 1
    fi

    # Set default description if not provided
    if [ -z "$SERVICE_DESCRIPTION" ]; then
        SERVICE_DESCRIPTION="User service: $SERVICE_NAME"
    fi

    # Set default working directory if not provided
    if [ -z "$WORKING_DIR" ]; then
        WORKING_DIR="%h"
    fi
}

# Check if running as root
check_root() {
    if [ "$EUID" -eq 0 ]; then
        log_error "This script should not be run as root since it configures user services"
        exit 1
    fi
}

# Detect distribution and set package manager
detect_distro() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        case "$ID" in
            ubuntu|debian)
                PKG_MGR="apt"
                PKG_INSTALL="sudo apt install -y"
                PKG_UPDATE="sudo apt update"
                ;;
            almalinux|rocky|centos|rhel|ol|fedora)
                PKG_MGR="dnf"
                PKG_INSTALL="sudo dnf install -y"
                PKG_UPDATE="sudo dnf update -y"
                ;;
            amzn)
                PKG_MGR="yum"
                PKG_INSTALL="sudo yum install -y"
                PKG_UPDATE="sudo yum update -y"
                ;;
            *)
                log_error "Unsupported distro: $ID"
                exit 1
                ;;
        esac
    else
        log_error "Cannot detect distribution. /etc/os-release not found."
        exit 1
    fi
    log_info "Detected distribution: $PRETTY_NAME"
}

# Check prerequisites
check_prerequisites() {
    echo "[1/7] Checking prerequisites..."
    
    # Check if systemctl is available
    if ! command -v systemctl >/dev/null 2>&1; then
        log_error "systemctl not found. This system doesn't appear to use systemd."
        exit 1
    fi

    # Check if user systemd is running
    if ! systemctl --user status >/dev/null 2>&1; then
        log_warning "User systemd instance may not be running. Attempting to start..."
        sudo loginctl enable-linger "$USER"
    fi

    log_success "Prerequisites check completed"
}

# Create user service directory
create_service_directory() {
    echo "[2/7] Creating user service directory..."
    
    local service_dir="$HOME/.config/systemd/user"
    
    if [ ! -d "$service_dir" ]; then
        mkdir -p "$service_dir"
        chmod 755 "$service_dir"
        log_success "Created directory: $service_dir"
    else
        log_info "Directory already exists: $service_dir"
    fi
}

# Create working directory if specified
create_working_directory() {
    echo "[3/7] Setting up working directory..."
    
    if [ "$WORKING_DIR" != "%h" ]; then
        # Expand environment variables in working directory
        local expanded_dir=$(eval echo "$WORKING_DIR")
        
        if [ ! -d "$expanded_dir" ]; then
            mkdir -p "$expanded_dir"
            chmod 755 "$expanded_dir"
            log_success "Created working directory: $expanded_dir"
        else
            log_info "Working directory already exists: $expanded_dir"
        fi
    else
        log_info "Using home directory as working directory"
    fi
}

# Generate service file content
generate_service_file() {
    echo "[4/7] Generating service file..."
    
    local service_file="$HOME/.config/systemd/user/${SERVICE_NAME}.service"
    
    # Create service file content
    cat > "$service_file" << EOF
[Unit]
Description=$SERVICE_DESCRIPTION
After=network.target

[Service]
Type=$SERVICE_TYPE
ExecStart=$EXEC_START
EOF

    # Add working directory if specified
    if [ "$WORKING_DIR" != "%h" ]; then
        echo "WorkingDirectory=$WORKING_DIR" >> "$service_file"
    fi

    # Add environment variables if specified
    if [ -n "$ENVIRONMENT_VARS" ]; then
        echo -e "$ENVIRONMENT_VARS" >> "$service_file"
    fi

    # Add restart configuration
    cat >> "$service_file" << EOF
Restart=$RESTART_POLICY
RestartSec=$RESTART_SEC
StandardOutput=journal
StandardError=journal
SyslogIdentifier=$SERVICE_NAME

[Install]
WantedBy=default.target
EOF

    chmod 644 "$service_file"
    log_success "Service file created: $service_file"
}

# Enable and start the service
enable_service() {
    echo "[5/7] Enabling and starting service..."
    
    # Reload systemd user daemon
    systemctl --user daemon-reload
    log_success "Systemd user daemon reloaded"
    
    # Enable the service
    systemctl --user enable "${SERVICE_NAME}.service"
    log_success "Service enabled: ${SERVICE_NAME}.service"
    
    # Start the service
    systemctl --user start "${SERVICE_NAME}.service"
    log_success "Service started: ${SERVICE_NAME}.service"
}

# Verify service is running
verify_service() {
    echo "[6/7] Verifying service status..."
    
    # Check if service is active
    if systemctl --user is-active --quiet "${SERVICE_NAME}.service"; then
        log_success "Service is running: ${SERVICE_NAME}.service"
    else
        log_error "Service failed to start: ${SERVICE_NAME}.service"
        log_info "Service status:"
        systemctl --user status "${SERVICE_NAME}.service" --no-pager
        return 1
    fi
    
    # Check if service is enabled
    if systemctl --user is-enabled --quiet "${SERVICE_NAME}.service"; then
        log_success "Service is enabled for auto-start: ${SERVICE_NAME}.service"
    else
        log_warning "Service is not enabled for auto-start"
    fi
}

# Show service management commands
show_management_info() {
    echo "[7/7] Service configuration completed!"
    echo ""
    echo -e "${GREEN}Service Management Commands:${NC}"
    echo "  Status:  systemctl --user status ${SERVICE_NAME}.service"
    echo "  Stop:    systemctl --user stop ${SERVICE_NAME}.service"
    echo "  Start:   systemctl --user start ${SERVICE_NAME}.service"
    echo "  Restart: systemctl --user restart ${SERVICE_NAME}.service"
    echo "  Logs:    journalctl --user -u ${SERVICE_NAME}.service -f"
    echo "  Disable: systemctl --user disable ${SERVICE_NAME}.service"
    echo ""
    echo -e "${YELLOW}Note:${NC} User services start automatically when you log in."
    echo -e "${YELLOW}Note:${NC} To enable services to start without login, run: sudo loginctl enable-linger $USER"
}

# Main function
main() {
    parse_args "$@"
    check_root
    detect_distro
    check_prerequisites
    create_service_directory
    create_working_directory
    generate_service_file
    enable_service
    verify_service
    show_management_info
}

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