#!/bin/bash
set -e

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

SECRETS_FILE="$HOME/.zsh_secrets"
REMOTE_NAME="hetzner-box"

# 1. Dependency Check
if ! command -v rclone &> /dev/null; then
    echo -e "${RED}Error: rclone is not installed.${NC}"
    exit 1
fi

# 2. Load Secrets
if [ -f "$SECRETS_FILE" ]; then
    source "$SECRETS_FILE"
fi

# 3. Configure Remote (If missing)
if ! rclone listremotes | grep -q "^${REMOTE_NAME}:$"; then
    echo -e "${BLUE}Configuration missing. Starting setup...${NC}"

    if [ -z "$HETZNER_USER" ]; then
        DEFAULT_USER="u513875"
        read -p "Enter Username [$DEFAULT_USER]: " INPUT_USER
        HETZNER_USER="${INPUT_USER:-$DEFAULT_USER}"
    fi
    
    if [ -z "$HETZNER_HOST" ]; then
        DEFAULT_HOST="${HETZNER_USER}.your-storagebox.de"
        read -p "Enter Host [$DEFAULT_HOST]: " INPUT_HOST
        HETZNER_HOST="${INPUT_HOST:-$DEFAULT_HOST}"
    fi
    
    if [ -z "$HETZNER_PASS" ]; then
        echo -e "${YELLOW}Note: Passwords are obscured in config, but saving to secrets file uses plain text.${NC}"
        read -s -p "Enter Password: " HETZNER_PASS
        echo ""
    fi

    # Save to secrets
    if ! grep -q "HETZNER_USER" "$SECRETS_FILE" 2>/dev/null; then
        echo -e "${BLUE}Saving credentials to $SECRETS_FILE...${NC}"
        {
            echo ""
            echo "# Hetzner Storage Box"
            echo "export HETZNER_USER=\"$HETZNER_USER\""
            echo "export HETZNER_HOST=\"$HETZNER_HOST\""
            echo "export HETZNER_PASS=\"$HETZNER_PASS\""
        } >> "$SECRETS_FILE"
    fi

    OBSCURED_PASS=$(rclone obscure "$HETZNER_PASS")
    rclone config create "$REMOTE_NAME" sftp \
        host "$HETZNER_HOST" \
        user "$HETZNER_USER" \
        pass "$OBSCURED_PASS" \
        port 23 \
        --non-interactive
        
    echo -e "${GREEN}Configuration created!${NC}"
fi

# 4. Interactive Menu
echo -e "${BLUE}--- Hetzner Storage Box Manager ---${NC}"
echo "1) List files (ls)"
echo "2) Upload (Copy LOCAL -> REMOTE)"
echo "3) Download (Copy REMOTE -> LOCAL)"
echo "4) Mount (Fast NVMe Cache)"
echo "q) Quit"

read -p "Select option: " OPTION

case $OPTION in
    1)
        read -p "Enter depth [1]: " INPUT_DEPTH
        DEPTH="${INPUT_DEPTH:-1}"
        echo -e "${BLUE}Listing files on Hetzner...${NC}"
        rclone ls "${REMOTE_NAME}:" --max-depth "$DEPTH"
        ;;
    2)
        # UPLOAD
        read -p "Enter local folder/file to upload: " LOCAL_PATH
        # Remove trailing slash
        LOCAL_PATH=${LOCAL_PATH%/}
        
        read -p "Enter remote destination folder (e.g. Backup): " REMOTE_FOLDER
        # Remove leading/trailing slashes to ensure relative path safety (no //root/paths)
        REMOTE_FOLDER=${REMOTE_FOLDER#/}
        REMOTE_FOLDER=${REMOTE_FOLDER%/}
        
        echo -e "${YELLOW}Uploading '$LOCAL_PATH' to '${REMOTE_NAME}:$REMOTE_FOLDER'...${NC}"
        # FIX: Removed slash before $REMOTE_FOLDER to force relative path
        rclone copy "$LOCAL_PATH" "${REMOTE_NAME}:$REMOTE_FOLDER" -P
        ;;
    3)
        # DOWNLOAD
        echo -e "${BLUE}Contents of Root:${NC}"
        rclone lsd "${REMOTE_NAME}:" 
        
        read -p "Enter remote path to download (e.g. models/Test): " REMOTE_PATH
        # Strip leading slash to force relative path from Home
        REMOTE_PATH=${REMOTE_PATH#/}
        
        read -p "Enter local destination folder: " LOCAL_DEST
        # Create dest if missing
        mkdir -p "$LOCAL_DEST"
        
        echo -e "${YELLOW}Downloading '${REMOTE_NAME}:$REMOTE_PATH' to '$LOCAL_DEST'...${NC}"
        rclone copy "${REMOTE_NAME}:$REMOTE_PATH" "$LOCAL_DEST" -P
        ;;
    4)
        # MOUNT LOGIC (With Permission Fixes)
        if [ -d "/mnt/resource" ]; then
            BASE_DIR="/mnt/resource"
        else
            BASE_DIR="$HOME/mnt" # Fallback if no NVMe exists
            mkdir -p "$BASE_DIR"
        fi
        
        MOUNT_POINT="$BASE_DIR/storagebox"
        CACHE_DIR="$BASE_DIR/rclone_cache"

        echo -e "${BLUE}Target: $MOUNT_POINT${NC}"
        
        # Ensure permissions exist (sudo only if needed)
        if [ ! -d "$MOUNT_POINT" ]; then
            echo -e "${YELLOW}Creating mount points...${NC}"
            sudo mkdir -p "$MOUNT_POINT" "$CACHE_DIR" || mkdir -p "$MOUNT_POINT" "$CACHE_DIR"
            sudo chown $(whoami):$(id -gn) "$MOUNT_POINT" "$CACHE_DIR" 2>/dev/null || true
        fi

        echo -e "${YELLOW}Mounting... (Ctrl+C to stop)${NC}"
        
        rclone mount "${REMOTE_NAME}:" "$MOUNT_POINT" \
            --vfs-cache-mode full \
            --cache-dir "$CACHE_DIR" \
            --vfs-cache-max-size 10G \
            --vfs-cache-max-age 24h
        ;;
    q)
        exit 0
        ;;
    *)
        echo "Invalid option"
        ;;
esac