#!/bin/sh

# Container Management Tasks Script for Docker/Podman (Alpine/ash compatible)
# Usage: pm-task-ash [task]
# Tasks: (none), restart, start, stop

CONFIG_FILE="$HOME/.config/pm-task.conf"
WORKSPACE=""

# Check if docker command exists
if ! command -v docker >/dev/null 2>&1; then
    echo "Error: docker command not found."
    echo "Please install Docker or configure podman as an alias (or install podman-docker)."
    exit 1
fi

# Function to load configuration
load_config() {
    if [ ! -f "$CONFIG_FILE" ]; then
        echo "Config file not found. Creating new config..."
        mkdir -p "$(dirname "$CONFIG_FILE")"
        echo "# Configuration file for pm-task" > "$CONFIG_FILE"
        echo "# workspace=<path-to-your-docker-projects>" >> "$CONFIG_FILE"
    fi

    # Source the config file
    if [ -f "$CONFIG_FILE" ]; then
        # Extract workspace value if it exists
        WORKSPACE=$(grep "^workspace=" "$CONFIG_FILE" | cut -d'=' -f2 | tr -d '"')
    fi

    # If workspace is not set, ask user
    if [ -z "$WORKSPACE" ]; then
        echo "Workspace directory not configured."
        printf "Enter your Docker/Podman projects workspace directory: "
        read WORKSPACE
        # Save to config file
        echo "workspace=$WORKSPACE" >> "$CONFIG_FILE"
        echo "Configuration saved to $CONFIG_FILE"
    fi
}

# Function to check for compose file
check_compose_file() {
    if [ -f "compose.yaml" ]; then
        COMPOSE_FILE="compose.yaml"
    elif [ -f "docker-compose.yml" ]; then
        COMPOSE_FILE="docker-compose.yml"
    elif [ -f "docker-compose.yaml" ]; then
        COMPOSE_FILE="docker-compose.yaml"
    else
        echo "Error: No compose file found in $(basename "$PWD")"
        echo "Expected one of: compose.yaml, docker-compose.yml, docker-compose.yaml"
        return 1
    fi
}

# Function to build containers
build_containers() {
    if [ -f "compose.yaml" ] || [ -f "docker-compose.yml" ] || [ -f "docker-compose.yaml" ]; then
        ls -lah
        
        docker compose build
        
        # Prompt for restart (POSIX compatible)
        printf "Restart container(s)? [Y/n]: "
        read confirm
        confirm=$(echo "$confirm" | tr '[:upper:]' '[:lower:]')
        if [ -z "$confirm" ] || [ "$confirm" = "y" ]; then
            docker compose -f "$COMPOSE_FILE" down && docker compose -f "$COMPOSE_FILE" up -d
        fi
        
        # Check if nginx container is running before reloading
        reload_nginx
    else
        echo "Error: Cannot build (neither compose.yaml, docker-compose.yml nor docker-compose.yaml is found)."
        return 1
    fi
}

# Function to reload nginx
reload_nginx() {
    if docker ps --format '{{.Names}}' | grep -q '^nginx$'; then
        docker exec -d nginx service nginx reload
    else
        echo "Warning: nginx container is not running, skipping reload"
    fi
}

# Function to show menu and select directory
show_menu() {
    echo ""
    echo "=== Container Management Tasks ==="
    echo "Workspace: $WORKSPACE"
    echo ""
    
    # Validate workspace directory exists
    if [ ! -d "$WORKSPACE" ]; then
        echo "Error: Workspace directory '$WORKSPACE' does not exist."
        return 1
    fi
    
    # Get list of subdirectories (excluding dot directories) - POSIX compatible
    dirs=""
    for dir in "$WORKSPACE"/*; do
        if [ -d "$dir" ]; then
            basename_dir=$(basename "$dir")
            case "$basename_dir" in
                .*) ;; # Skip dot directories
                *) dirs="$dirs$dir
";;
            esac
        fi
    done
    
    # Count directories
    dir_count=$(echo "$dirs" | grep -c .)
    
    if [ "$dir_count" -eq 0 ]; then
        echo "No subdirectories found in $WORKSPACE"
        return 1
    fi
    
    echo "Available projects:"
    i=1
    echo "$dirs" | while read dir; do
        if [ -n "$dir" ]; then
            echo "   $i). $(basename "$dir")"
            i=$((i + 1))
        fi
    done
    echo ""
    
    printf "Select a project (1-$dir_count): "
    read choice
    
    # If user pressed Enter without selection, show workspace contents
    if [ -z "$choice" ]; then
        echo "Entering Docker/Podman Projects Workspace"
        cd "$WORKSPACE" || return 1
        ls -lah "$WORKSPACE"
        return 0
    fi
    
    # Get selected directory (simple approach for POSIX)
    selected_dir=$(echo "$dirs" | sed -n "${choice}p")
    
    if [ -z "$selected_dir" ] || [ ! -d "$selected_dir" ]; then
        echo "Invalid selection"
        return 1
    fi
    
    echo ""
    echo "=== Contents of $(basename "$selected_dir") ==="
    cd "$selected_dir" || return 1
    ls -lah
}

# Function to restart containers
restart_containers() {
    echo "Restarting containers in $WORKSPACE..."
    cd "$WORKSPACE" || return 1
    
    check_compose_file || return 1
    
    echo "Stopping containers..."
    docker compose -f "$COMPOSE_FILE" down
    
    echo "Waiting 1 second..."
    sleep 1
    
    echo "Starting containers..."
    docker compose -f "$COMPOSE_FILE" up
    
    echo "Done!"
}

# Function to start containers
start_containers() {
    echo "Starting containers in $WORKSPACE..."
    cd "$WORKSPACE" || return 1
    
    check_compose_file || return 1
    
    echo "Starting containers..."
    docker compose -f "$COMPOSE_FILE" up
    echo "Done!"
}

# Function to stop containers
stop_containers() {
    echo "Stopping containers in $WORKSPACE..."
    cd "$WORKSPACE" || return 1
    
    check_compose_file || return 1
    
    echo "Stopping containers..."
    docker compose -f "$COMPOSE_FILE" down
    echo "Done!"
}

# Function to run watch docker ps
watch_ps() {
    echo "Running 'watch docker ps'..."
    watch docker ps
}

# Function to run docker stats
run_stats() {
    echo "Running 'docker stats'..."
    docker stats
}

# Function to run docker logs
run_logs() {
    echo "Running 'docker logs -f $(basename "$PWD")'..."
    docker logs -f "$(basename "$PWD")"
}

# Function to run docker exec bash
run_shell() {
    echo "Running 'docker exec -it $(basename "$PWD") bash'..."
    docker exec -it "$(basename "$PWD") bash"
}

# Function to upgrade containers
upgrade_containers() {
    check_compose_file || return 1
    
    echo "Pulling latest images..."
    docker compose pull
    
    echo "Upgrading containers..."
    docker compose up -d --remove-orphans --force-recreate
    echo "Done!"
}

# Main script
main() {
    load_config
    
    task="${1:-}"
    
    # Handle --help flag
    if [ "$task" = "--help" ]; then
        echo "Usage: $0 [task]"
        echo "Tasks:"
        echo "    (none)            - Show menu and list container projects"
        echo "  restart             - Restart container(s)"
        echo "  start/up            - Start container(s)"
        echo "  stop/down           - Stop container(s)"
        echo "  ps                  - Watch running containers"
        echo "  stats               - Container statistics"
        echo "  logs/log            - Follow container logs"
        echo "  sh/bash/shell       - Exec into container bash shell"
        echo "  build/rebuild       - Build containers and reload nginx"
        echo "  reload              - Reload nginx service"
        echo "  upgrade             - Pull latest images and upgrade containers"
        exit 0
    fi
    
    case "$task" in
        restart)
            restart_containers
            ;;
        start|up)
            start_containers
            ;;
        stop|down)
            stop_containers
            ;;
        ps)
            watch_ps
            ;;
        stats)
            run_stats
            ;;
        build|rebuild)
            build_containers
            ;;
        logs|log)
            run_logs
            ;;
        sh|bash|shell)
            run_shell
            ;;
        reload)
            reload_nginx
            ;;
        upgrade)
            upgrade_containers
            ;;
        "")
            show_menu
            ;;
           *)             
             # Try to find a matching subdirectory in workspace
            if [ -d "$WORKSPACE" ]; then
                matching_dir=$(find "$WORKSPACE" -mindepth 1 -maxdepth 1 -type d ! -name '.*' -path "$WORKSPACE/$task*" 2>/dev/null | head -1)
                if [ -n "$matching_dir" ]; then
                    echo "Navigating to: $matching_dir"
                    cd "$matching_dir" || return 1
                    ls -lah
                    return 0
                fi
            fi
            echo "Unknown task: $task"
            echo "Usage: $0 [task]"
            echo "Run '$0 --help' for available tasks."
            return 1
            ;;
    esac
}

main "$@"