start

#!/bin/bash

# GraphDone - Single Entry Point
# The main launcher for all GraphDone operations

# Don't use set -e to allow better error handling
# set -e

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

# Default values
COMMAND=""
SKIP_BANNER=false
QUIET=false

# Platform detection
detect_platform() {
    if [[ "$OSTYPE" == "darwin"* ]]; then
        PLATFORM="macos"
        # macOS shell profile detection
        if [ -n "$ZSH_VERSION" ] || [ -f "$HOME/.zshrc" ]; then
            SHELL_PROFILE="$HOME/.zshrc"
        elif [ -f "$HOME/.bash_profile" ]; then
            SHELL_PROFILE="$HOME/.bash_profile"
        else
            SHELL_PROFILE="$HOME/.bashrc"
        fi
    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
        PLATFORM="linux"
        SHELL_PROFILE="$HOME/.bashrc"
    elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]] || [[ "$OS" == "Windows_NT" ]]; then
        PLATFORM="windows"
        # Windows shell profile detection
        if [ -n "$USERPROFILE" ]; then
            # PowerShell profile (preferred)
            SHELL_PROFILE="$USERPROFILE/Documents/PowerShell/Microsoft.PowerShell_profile.ps1"
            # Git Bash profile (fallback)
            if [ ! -f "$SHELL_PROFILE" ]; then
                SHELL_PROFILE="$HOME/.bashrc"
            fi
        else
            SHELL_PROFILE="$HOME/.bashrc"  # Git Bash fallback
        fi
    else
        PLATFORM="unknown"
        SHELL_PROFILE="$HOME/.bashrc"
    fi
}

# Initialize platform detection
detect_platform

# Help function
show_help() {
    echo -e "${BOLD}GraphDone${NC} - Graph-native management system"
    echo ""
    echo -e "${BOLD}USAGE:${NC}"
    echo "  ./start [COMMAND] [OPTIONS]"
    echo ""
    echo -e "${BOLD}COMMANDS:${NC}"
    echo -e "  ${CYAN}dev${NC}           Start development environment (default)"
    echo -e "  ${CYAN}quick${NC}         Quick start without full setup checks"
    echo -e "  ${CYAN}clean${NC}         Clean build artifacts and restart fresh"
    echo -e "  ${CYAN}setup${NC}         Run initial setup only"
    echo -e "  ${CYAN}test${NC}          Run test suite"
    echo -e "    ${YELLOW}--unit${NC}         Run unit tests only"
    echo -e "    ${YELLOW}--e2e${NC}          Run end-to-end tests only"
    echo -e "    ${YELLOW}--package PKG${NC}  Test specific package (core/server/web)"
    echo -e "    ${YELLOW}--coverage${NC}     Generate coverage report"
    echo -e "    ${YELLOW}--report${NC}       Generate consolidated test report"
    echo -e "  ${CYAN}build${NC}        Build all packages"
    echo -e "  ${CYAN}deploy${NC}       Deploy to production"
    echo -e "  ${CYAN}stop${NC}         Stop all running services"
    echo -e "  ${CYAN}remove${NC}       Remove GraphDone completely (services, data, dependencies)"
    echo -e "  ${CYAN}status${NC}       Check system status"
    echo -e "  ${CYAN}vm${NC}           Manage Multipass VMs"
    echo -e "    ${YELLOW}launch${NC}         Launch a new VM"
    echo -e "    ${YELLOW}delete${NC}         Delete a VM"
    echo -e "    ${YELLOW}stop${NC}           Stop a VM"
    echo -e "    ${YELLOW}start${NC}          Start a VM"
    echo -e "    ${YELLOW}shell${NC}          Open shell in VM"
    echo -e "    ${YELLOW}info${NC}           Show VM information"
    echo -e "    ${YELLOW}list${NC}           List all VMs"
    echo -e "    ${YELLOW}--name NAME${NC}    Specify VM name"
    echo -e "    ${YELLOW}--branch BRANCH${NC} Specify Git branch"
    echo -e "    ${YELLOW}--cpus N${NC}       Number of CPUs"
    echo -e "    ${YELLOW}--memory SIZE${NC}  Memory size (e.g., 8G)"
    echo -e "    ${YELLOW}--disk SIZE${NC}    Disk size (e.g., 30G)"
    echo ""
    echo -e "${BOLD}OPTIONS:${NC}"
    echo -e "  ${YELLOW}--help, -h${NC}    Show this help message"
    echo -e "  ${YELLOW}--quiet, -q${NC}   Suppress banner and verbose output"
    echo -e "  ${YELLOW}--no-banner${NC}   Skip the GraphDone banner"
    echo ""
    echo -e "${BOLD}EXAMPLES:${NC}"
    echo -e "  ${GREEN}./start${NC}                                  # Start development environment"
    echo -e "  ${GREEN}./start quick${NC}                            # Quick start"
    echo -e "  ${GREEN}./start clean${NC}                            # Clean and restart"
    echo -e "  ${GREEN}./start test --quiet${NC}                      # Run tests quietly"
    echo -e "  ${GREEN}./start remove${NC}                           # Completely remove GraphDone"
    echo -e "  ${GREEN}./start vm launch${NC}                        # Launch VM with default config"
    echo -e "  ${GREEN}./start vm launch --branch develop${NC}        # Launch VM with specific branch"
    echo -e "  ${GREEN}./start vm launch --cpus 8 --memory 16G${NC}   # Launch VM with custom resources"
    echo -e "  ${GREEN}./start vm shell${NC}                          # Connect to VM shell"
    echo -e "  ${GREEN}./start vm delete${NC}                         # Delete VM"
    echo ""
    echo -e "${BOLD}PRODUCTION (deploy):${NC}"
    echo -e "  ${CYAN}Web UI:${NC}       https://localhost:3128 (HTTPS)"
    echo -e "  ${CYAN}GraphQL:${NC}     https://localhost:4128/graphql (HTTPS)"
    echo -e "  ${CYAN}WebSocket:${NC}   wss://localhost:4128/graphql (WSS)"
    echo -e "  ${CYAN}Database:${NC}    http://localhost:7474 (Neo4j Browser)"
    echo ""
    echo -e "${BOLD}DEVELOPMENT (dev):${NC}"
    echo -e "  ${CYAN}Web UI:${NC}       http://localhost:3127"
    echo -e "  ${CYAN}GraphQL:${NC}     http://localhost:4127/graphql"
    echo -e "  ${CYAN}Database:${NC}    http://localhost:7474 (Neo4j Browser)"
}

# Parse command line arguments
REMAINING_ARGS=()
while [[ $# -gt 0 ]]; do
    case $1 in
        -h|--help)
            show_help
            exit 0
            ;;
        -q|--quiet)
            QUIET=true
            SKIP_BANNER=true
            shift
            ;;
        --no-banner)
            SKIP_BANNER=true
            shift
            ;;
        dev|quick|clean|setup|test|build|deploy|stop|remove|status|vm)
            COMMAND="$1"
            shift
            # Capture remaining arguments for the command
            REMAINING_ARGS=("$@")
            break
            ;;
        *)
            echo -e "${RED}❌ Unknown option or command: $1${NC}"
            echo "Use './start --help' for usage information."
            exit 1
            ;;
    esac
done

# Default command
if [ -z "$COMMAND" ]; then
    COMMAND="dev"
fi

# Smart npm install function that handles peer dependency conflicts automatically
smart_npm_install() {
    local attempt=1
    local max_attempts=2
    
    while [ $attempt -le $max_attempts ]; do
        if [ $attempt -eq 1 ]; then
            # First attempt: standard npm install
            if npm install 2>/dev/null; then
                return 0
            fi
        else
            # Second attempt: handle peer dependency conflicts
            log_info "  • Resolving dependency conflicts automatically..."
            if npm install --legacy-peer-deps; then
                return 0
            fi
        fi
        
        attempt=$((attempt + 1))
    done
    
    log_error "❌ Failed to install dependencies after $max_attempts attempts"
    return 1
}

# Show banner unless skipped
show_banner() {
    if [ "$SKIP_BANNER" = false ]; then
        clear
        echo -e "${PURPLE}"
        echo "╔══════════════════════════════════════════════════════════════╗"
        echo "║                                                              ║"
        echo "║                     🌐 GraphDone 🌐                          ║"
        echo "║                                                              ║"
        echo "║                Graph-native management system                ║"
        echo "║                                                              ║"
        echo "╚══════════════════════════════════════════════════════════════╝"
        echo -e "${NC}"
    fi
}

# Logging functions
log_info() {
    if [ "$QUIET" = false ]; then
        echo -e "${CYAN}$1${NC}"
    fi
}

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

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

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

# Docker error handling function
handle_docker_error() {
    local error_output="$1"
    local command="$2"

    echo ""
    log_error "╔════════════════════════════════════════════════════════════════╗"
    log_error "║                                                                ║"
    log_error "║                    ❌ Docker Error Detected ❌                  ║"
    log_error "║                                                                ║"
    log_error "╚════════════════════════════════════════════════════════════════╝"
    echo ""

    # Detect specific error types and provide targeted solutions
    # Check most specific patterns first, then more general ones
    if echo "$error_output" | grep -qi "Cannot connect to the Docker daemon\|docker.*not running\|Is the docker daemon running"; then
        log_warning "🔍 Issue: Docker is not running"
        echo ""
        echo "Docker daemon is not started."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  • Start Docker Desktop"
        echo "  • Wait for it to fully start (check system tray)"
        echo "  • Then run: ${GREEN}./start${NC}"
        echo ""

    elif echo "$error_output" | grep -qi "ContainerConfig\|container.*config\|image.*config"; then
        log_warning "🔍 Issue: Corrupted container state detected"
        echo ""
        echo "This happens when Docker containers are in an inconsistent state."
        echo ""
        log_info "${BOLD}Quick Fix (Recommended):${NC}"
        echo "  ${GREEN}./start stop${NC}    # Stop all services"
        echo "  ${GREEN}./start${NC}         # Start fresh"
        echo ""
        log_info "${BOLD}If that doesn't work, try a complete cleanup:${NC}"
        echo "  ${GREEN}./start remove${NC}  # Remove all containers and data"
        echo "  ${GREEN}./start setup${NC}   # Fresh installation"
        echo ""

    elif echo "$error_output" | grep -qi "permission denied\|Got permission denied"; then
        log_warning "🔍 Issue: Docker permission problem"
        echo ""
        echo "Docker requires proper permissions to run."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  ${GREEN}./scripts/setup_docker.sh${NC}  # Fix Docker permissions"
        echo "  Then restart your terminal and run: ${GREEN}./start${NC}"
        echo ""

    elif echo "$error_output" | grep -qi "no such container\|container.*not found"; then
        log_warning "🔍 Issue: Container not found"
        echo ""
        echo "Expected containers are missing."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  ${GREEN}./start stop${NC}    # Clean up"
        echo "  ${GREEN}./start${NC}         # Recreate containers"
        echo ""

    elif echo "$error_output" | grep -qi "port.*already allocated\|address already in use"; then
        log_warning "🔍 Issue: Port conflict detected"
        echo ""
        echo "Another service is using GraphDone's ports (3127, 3128, 4127, 4128, 7474, 7687)."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  ${GREEN}./start stop${NC}                    # Stop GraphDone services"
        echo "  ${GREEN}lsof -ti:3127 | xargs kill -9${NC}  # Kill specific port (example)"
        echo ""

    elif echo "$error_output" | grep -qi "no space left\|disk.*full"; then
        log_warning "🔍 Issue: Disk space problem"
        echo ""
        echo "Not enough disk space for Docker operations."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  ${GREEN}docker system prune -a${NC}  # Clean up Docker resources"
        echo "  Then run: ${GREEN}./start${NC}"
        echo ""

    elif echo "$error_output" | grep -qi "network.*not found\|network.*error"; then
        log_warning "🔍 Issue: Docker network problem"
        echo ""
        echo "Docker network configuration is corrupted."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  ${GREEN}./start stop${NC}    # Stop services"
        echo "  ${GREEN}docker network prune${NC}  # Clean up networks"
        echo "  ${GREEN}./start${NC}         # Restart"
        echo ""

    elif echo "$error_output" | grep -qi "timeout\|timed out"; then
        log_warning "🔍 Issue: Docker operation timeout"
        echo ""
        echo "Docker operations are taking too long (usually means Docker Desktop is slow)."
        echo ""
        log_info "${BOLD}Solution:${NC}"
        echo "  1. Restart Docker Desktop"
        echo "  2. Wait 30 seconds for Docker to fully start"
        echo "  3. Try again: ${GREEN}./start${NC}"
        echo ""

    else
        log_warning "🔍 Issue: Unknown Docker error"
        echo ""
        echo "An unexpected Docker error occurred."
        echo ""
        log_info "${BOLD}General Solutions (try in order):${NC}"
        echo "  1. ${GREEN}./start stop${NC}     # Stop services"
        echo "  2. ${GREEN}./start${NC}          # Restart"
        echo "  3. ${GREEN}./start remove${NC}   # Complete cleanup"
        echo "  4. ${GREEN}./start setup${NC}    # Fresh installation"
        echo ""
    fi

    log_info "${BOLD}Error Details:${NC}"
    echo "$error_output" | head -20
    echo ""

    return 1
}

# Safe Docker command wrapper
safe_docker() {
    local description="$1"
    shift
    local cmd="$@"

    if [ "$QUIET" = false ]; then
        echo -n "  ${description}..."
    fi

    local output
    local exit_code

    output=$(eval "$cmd" 2>&1) || exit_code=$?

    if [ ${exit_code:-0} -ne 0 ]; then
        if [ "$QUIET" = false ]; then
            echo " ❌"
        fi
        handle_docker_error "$output" "$cmd"
        return 1
    fi

    if [ "$QUIET" = false ]; then
        echo " ✅"
    fi
    return 0
}

# Function to ensure Node.js is available
ensure_nodejs() {
    if command -v node &> /dev/null && command -v npm &> /dev/null && node -e 'const [a,b]=process.versions.node.split(".").map(Number);process.exit(a>22||(a===22&&b>=18)?0:1)'; then
        log_success "✅ Node.js found: $(node --version), npm: $(npm --version)"
        return 0
    else
        log_warning "⚠️  Node.js 22.18+ is required - checking for existing installations..."
        
        export NVM_DIR="$HOME/.nvm"
        if [ -s "$NVM_DIR/nvm.sh" ]; then
            source "$NVM_DIR/nvm.sh"
            if [ -s "$NVM_DIR/bash_completion" ]; then
                source "$NVM_DIR/bash_completion"
            fi
            
            if nvm list | grep -q "v22"; then
                nvm use 22
            else
                nvm use node
            fi
            
            log_success "✅ Loaded Node.js from nvm: $(node --version)"
        else
            log_warning "🔧 No Node.js installation found. Installing automatically..."

            # Try to install Node.js automatically
            if [ -f "./scripts/setup_nodejs.sh" ]; then
                ./scripts/setup_nodejs.sh

                # Platform-aware post-installation setup
                case $PLATFORM in
                    "macos")
                        # macOS: Reload shell profile and update PATH for Homebrew
                        if [ -f "$SHELL_PROFILE" ]; then
                            source "$SHELL_PROFILE" 2>/dev/null || true
                        fi
                        # Add common macOS Node.js paths
                        export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
                        ;;
                    "linux")
                        # Linux: Reload bashrc and add snap PATH
                        if [ -f "$SHELL_PROFILE" ]; then
                            source "$SHELL_PROFILE" 2>/dev/null || true
                        fi
                        export PATH="/snap/bin:$PATH"
                        ;;
                    "windows")
                        # Windows: Refresh environment and add common paths
                        if command -v refreshenv &> /dev/null; then
                            refreshenv 2>/dev/null || true
                        fi
                        # Add common Windows Node.js paths
                        export PATH="/c/Program Files/nodejs:/c/ProgramData/chocolatey/bin:$PATH"
                        ;;
                    *)
                        # Unknown platform: Try to reload profile
                        if [ -f "$SHELL_PROFILE" ]; then
                            source "$SHELL_PROFILE" 2>/dev/null || true
                        fi
                        ;;
                esac

                # Verify Node.js is now available
                if command -v node &> /dev/null && command -v npm &> /dev/null && node -e 'const [a,b]=process.versions.node.split(".").map(Number);process.exit(a>22||(a===22&&b>=18)?0:1)'; then
                    log_success "✅ Node.js automatically installed: $(node --version)"
                    return 0
                fi
            fi

            # Fallback to platform-aware manual instructions
            log_error "❌ Could not install Node.js automatically."
            echo "Please install Node.js manually for $PLATFORM:"
            echo "  1. Run: ./scripts/setup_nodejs.sh"
            
            case $PLATFORM in
                "macos")
                    echo "  2. Or install via Homebrew: brew install node"
                    echo "  3. Or download from: https://nodejs.org/en/download/"
                    ;;
                "linux")
                    echo "  2. Or install via package manager:"
                    echo "     • Ubuntu/Debian: sudo apt install nodejs npm"
                    echo "     • Fedora/RHEL: sudo dnf install nodejs npm"
                    echo "  3. Or download from: https://nodejs.org/en/download/"
                    ;;
                "windows")
                    echo "  2. Or install via Chocolatey: choco install nodejs"
                    echo "  3. Or install via Scoop: scoop install nodejs"
                    echo "  4. Or download installer: https://nodejs.org/en/download/"
                    ;;
                *)
                    echo "  2. Visit: https://nodejs.org/en/download/"
                    ;;
            esac
            
            echo "  ${CYAN}Then restart terminal and run: ./start${NC}"
            exit 1
        fi
    fi
    if ! node -e 'const [a,b]=process.versions.node.split(".").map(Number);process.exit(a>22||(a===22&&b>=18)?0:1)'; then
        log_error "Node.js 22.18+ is required. Run ./scripts/setup_nodejs.sh to upgrade."
        return 1
    fi
}

# Command implementations
cmd_dev() {
    # Capture start time for end-to-end timing (milliseconds since epoch)
    # macOS/Windows date doesn't support %3N, so we use Python for milliseconds
    if command -v python3 &> /dev/null; then
        GRAPHDONE_START_TIME=$(python3 -c 'import time; print(int(time.time() * 1000))')
    else
        # Fallback to seconds * 1000 if Python not available
        GRAPHDONE_START_TIME=$(($(date +%s) * 1000))
    fi
    export GRAPHDONE_START_TIME

    show_banner
    log_info "Welcome to GraphDone! Starting development environment..."

    ensure_nodejs || return 1

    # Check Docker status (required for GraphDone)
    if ! docker ps &> /dev/null; then
        # Determine the specific issue
        if ! command -v docker &> /dev/null; then
            log_warning "🐳 Docker not installed - setting up Docker..."
        else
            log_warning "🐳 Docker permission issue detected - fixing permissions..."
        fi

        if ! ./scripts/setup_docker.sh; then
            log_error "❌ Docker setup failed. Please fix Docker issues and try again."
            exit 1
        fi
    else
        # Docker is working properly
        log_success "🐳 Docker is running and ready!"
    fi

    # Check if setup is needed
    setup_needed=false
    workspace_repair_needed=false
    dependencies_needed=false
    
    if [ ! -f "packages/server/.env" ] || [ ! -f "packages/web/.env" ]; then
        setup_needed=true
    fi
    
    if [ ! -f "packages/core/dist/index.js" ] || [ ! -L "node_modules/@graphdone/core" ]; then
        workspace_repair_needed=true
    fi
    
    # Check for critical dependencies
    if [ ! -d "node_modules" ] || [ ! -d "node_modules/neo4j-driver" ] || [ ! -d "node_modules/@neo4j/graphql" ] || [ ! -d "node_modules/@playwright/test" ]; then
        dependencies_needed=true
    fi
    
    # Install dependencies if needed
    if [ "$dependencies_needed" = true ]; then
        log_warning "📦 Missing dependencies detected..."
        log_info "Installing all project dependencies..."
        smart_npm_install
        log_success "✅ Dependencies installed!"
    fi
    
    # Run setup if needed
    if [ "$setup_needed" = true ]; then
        log_warning "🔧 First time setup detected..."
        log_info "Running initial setup (this may take a few minutes):"
        log_info "  • Setting up Docker"
        log_info "  • Setting up environment variables"
        log_info "  • Starting database"
        log_info "  • Running migrations"
        log_info "  • Building packages"

        # Setup Docker first
        log_info "🐳 Setting up Docker..."
        if ! ./scripts/setup_docker.sh; then
            log_error "❌ Docker setup failed. Please fix Docker issues and try again."
            exit 1
        fi

        ./scripts/stack/setup.sh
        log_success "✅ Setup complete!"
        
    elif [ "$workspace_repair_needed" = true ] || [ "$dependencies_needed" = true ]; then
        log_warning "🔧 Workspace dependencies need repair..."
        log_info "Fixing workspace dependencies:"
        
        if [ "$dependencies_needed" = true ]; then
            log_info "  • Installing missing dependencies"
            smart_npm_install --legacy-peer-deps
        fi
        log_info "  • Rebuilding core package"
        log_info "  • Ensuring workspace links"
        
        smart_npm_install --legacy-peer-deps
        (cd packages/core && npm run build)
        
        if [ -f "packages/core/dist/index.js" ] && [ -L "node_modules/@graphdone/core" ]; then
            log_success "✅ Workspace repair complete!"
        else
            log_error "❌ Workspace repair failed. Running full setup..."
            ./scripts/stack/setup.sh
        fi
    fi
    
    log_info "🚀 Starting GraphDone development environment..."
    ./scripts/stack/run.sh
}

cmd_quick() {
    show_banner
    log_info "🏃 Quick start - minimal checks..."
    ensure_nodejs || return 1
    ./scripts/stack/run.sh
}

cmd_clean() {
    show_banner
    log_info "🧹 Cleaning build artifacts and restarting fresh..."
    ensure_nodejs || return 1
    ./scripts/stack/cleanup.sh
    ./scripts/stack/setup.sh
    ./scripts/stack/run.sh
}

cmd_setup() {
    show_banner
    log_info "🔧 Running initial setup..."
    ensure_nodejs || return 1

    # Setup Docker first (required for GraphDone)
    log_info "🐳 Setting up Docker..."
    if ! ./scripts/setup_docker.sh; then
        log_error "❌ Docker setup failed. Please fix Docker issues and try again."
        exit 1
    fi

    ./scripts/stack/setup.sh
    log_success "✅ Setup complete! Run './start' to start development environment."
}

cmd_test() {
    show_banner
    log_info "🧪 Running test suite..."
    ensure_nodejs || return 1
    
    # Pass all remaining arguments to test.sh
    ./scripts/stack/test.sh "${REMAINING_ARGS[@]}"
}

cmd_build() {
    show_banner
    log_info "🏗️  Building all packages..."
    ensure_nodejs || return 1
    ./scripts/stack/build.sh
}

cmd_deploy() {
    # Capture start time for end-to-end timing (milliseconds since epoch)
    # macOS/Windows date doesn't support %3N, so we use Python for milliseconds
    if command -v python3 &> /dev/null; then
        GRAPHDONE_START_TIME=$(python3 -c 'import time; print(int(time.time() * 1000))')
    else
        # Fallback to seconds * 1000 if Python not available
        GRAPHDONE_START_TIME=$(($(date +%s) * 1000))
    fi
    export GRAPHDONE_START_TIME

    show_banner
    log_info "🚀 Starting production deployment with HTTPS..."
    log_info "Features enabled:"
    log_info "  • Full HTTPS encryption (web + API)"
    log_info "  • Auto-generated SSL certificates"
    log_info "  • Secure WebSocket connections (WSS)"
    log_info "  • Production-optimized containers"
    ./scripts/stack/run.sh
}

cmd_remove() {
    show_banner
    log_warning "🗑️  Removing GraphDone completely..."
    
    # Confirm with user
    echo -e "${YELLOW}This will remove:${NC}"
    echo -e "  • All running GraphDone services"
    echo -e "  • All Neo4j data and containers" 
    echo -e "  • All build artifacts and dependencies"
    echo -e "  • All test results and reports"
    echo ""
    
    read -p "Are you sure you want to completely remove GraphDone? (yes/no): " confirm
    if [ "$confirm" != "yes" ]; then
        log_info "Removal cancelled."
        exit 0
    fi
    
    log_info "🛑 Stopping all services..."
    
    # Check and stop GraphDone services
    local services_found=false
    
    # Platform-aware process termination
    case $PLATFORM in
        "windows")
            log_info "  • Stopping services on Windows..."
            # Windows: Use taskkill for process termination
            taskkill //F //IM node.exe 2>/dev/null || true
            taskkill //F //IM "npm.exe" 2>/dev/null || true
            # Stop services on specific ports (Windows netstat approach)
            for port in 3127 4127 7474 7687; do
                local pids=$(netstat -ano | grep ":$port " | awk '{print $5}' | sort -u 2>/dev/null)
                if [ -n "$pids" ]; then
                    echo "$pids" | xargs -r taskkill //F //PID 2>/dev/null || true
                fi
            done
            services_found=true
            ;;
        *)
            # Linux/macOS: Use traditional Unix commands
            if pgrep -f "node.*3127\|node.*4127\|vite\|tsx.*watch" >/dev/null 2>&1; then
                log_info "  • Stopping Node.js development servers..."
                pkill -f "node.*3127" 2>/dev/null || true
                pkill -f "node.*4127" 2>/dev/null || true
                pkill -f "vite" 2>/dev/null || true
                pkill -f "tsx.*watch" 2>/dev/null || true
                services_found=true
            fi
            
            # Kill processes on GraphDone ports
            for port in 3127 4127 7474 7687; do
                if command -v lsof &> /dev/null && lsof -ti:$port >/dev/null 2>&1; then
                    if [ "$services_found" = false ]; then
                        log_info "  • Stopping services on GraphDone ports..."
                        services_found=true
                    fi
                    lsof -ti:$port | xargs -r kill -9 2>/dev/null || true
                fi
            done
            ;;
    esac
    
    if [ "$services_found" = false ]; then
        log_info "  • No running GraphDone services found"
    else
        sleep 2  # Give processes time to stop
        log_info "  • Services stopped"
    fi
    
    log_info "🐳 Removing Docker containers and data..."
    
    # Stop and remove Neo4j containers
    docker stop graphdone-neo4j 2>/dev/null || true
    docker rm graphdone-neo4j 2>/dev/null || true
    docker stop neo4j 2>/dev/null || true
    docker rm neo4j 2>/dev/null || true
    
    # Remove Docker volumes
    docker volume rm graphdone-neo4j-data 2>/dev/null || true
    docker volume rm neo4j-data 2>/dev/null || true
    
    # Stop any docker-compose services
    if [ -f "docker-compose.yml" ]; then
        docker-compose down -v 2>/dev/null || true
    fi
    if [ -f "deployment/docker-compose.yml" ]; then
        docker-compose -f deployment/docker-compose.yml down -v 2>/dev/null || true
    fi
    
    log_info "🧹 Cleaning build artifacts..."
    
    # Remove build directories
    rm -rf packages/*/dist
    rm -rf packages/*/build
    rm -rf .turbo
    rm -rf coverage
    rm -rf test-results
    rm -rf playwright-report
    rm -rf packages/*/coverage
    rm -rf packages/*/test-results
    rm -rf packages/*/playwright-report
    rm -rf packages/*/.vite
    rm -rf packages/*/node_modules/.cache
    
    # Remove TypeScript build info
    find . -name "*.tsbuildinfo" -delete 2>/dev/null || true
    
    log_info "📦 Removing dependencies..."
    
    # Remove node_modules
    rm -rf node_modules
    rm -rf packages/*/node_modules
    
    # Remove lock files
    rm -f package-lock.json
    rm -f packages/*/package-lock.json
    
    log_info "🧪 Removing test artifacts..."
    
    # Remove test screenshots and artifacts
    rm -rf test-results/
    rm -rf screenshots/
    rm -rf error-handling-screenshots/
    rm -f *.png
    rm -f test-*.js
    
    log_success "✅ GraphDone has been completely removed!"
    echo ""
    echo -e "${BOLD}To reinstall GraphDone:${NC}"
    echo -e "  ${GREEN}./start setup${NC}    # Full setup"
    echo -e "  ${GREEN}./start${NC}          # Start development"
}

cmd_stop() {
    log_info "🛑 Stopping all services..."

    local stop_success=true

    # Stop Docker containers (works on all platforms)
    log_info "  • Stopping Docker containers..."

    # Try to stop production containers
    if docker-compose -f deployment/docker-compose.yml ps 2>/dev/null | grep -q "Up"; then
        if ! docker-compose -f deployment/docker-compose.yml down 2>&1; then
            log_warning "    ⚠️ Could not stop production containers (may not be running)"
        fi
    fi

    # Try to stop dev containers
    if docker-compose -f deployment/docker-compose.dev.yml ps 2>/dev/null | grep -q "Up"; then
        if ! docker-compose -f deployment/docker-compose.dev.yml down 2>&1; then
            log_warning "    ⚠️ Could not stop dev containers (may not be running)"
        fi
    fi

    # Platform-aware process termination
    case $PLATFORM in
        "windows")
            log_info "  • Stopping Windows processes..."
            # Windows: Use taskkill
            taskkill //F //IM node.exe 2>/dev/null || true
            taskkill //F //IM npm.exe 2>/dev/null || true

            # Stop processes on specific ports
            for port in 3127 3128 4127 4128 7474 7687; do
                local pids=$(netstat -ano | grep ":$port " | awk '{print $5}' | sort -u 2>/dev/null)
                if [ -n "$pids" ]; then
                    echo "$pids" | xargs -r taskkill //F //PID 2>/dev/null || true
                fi
            done
            ;;
        *)
            # Linux/macOS: Use traditional Unix commands
            log_info "  • Stopping Node.js processes..."
            pkill -f "npm run dev" 2>/dev/null || true
            pkill -f "vite" 2>/dev/null || true
            pkill -f "tsx.*watch" 2>/dev/null || true

            # Clean up any processes on GraphDone ports
            if command -v lsof &> /dev/null; then
                for port in 3127 3128 4127 4128 7474 7687; do
                    if lsof -ti:$port >/dev/null 2>&1; then
                        lsof -ti:$port | xargs -r kill -9 2>/dev/null || true
                    fi
                done
            fi
            ;;
    esac

    log_success "✅ All services stopped"
}

cmd_status() {
    log_info "📊 Checking system status..."

    echo ""
    echo -e "${BOLD}System Status:${NC}"

    # Check Node.js
    if command -v node &> /dev/null; then
        echo -e "  ${GREEN}✅${NC} Node.js: $(node --version)"
    else
        echo -e "  ${RED}❌${NC} Node.js: Not found"
    fi

    # Check Docker
    if command -v docker &> /dev/null; then
        echo -e "  ${GREEN}✅${NC} Docker: $(docker --version | cut -d' ' -f3 | cut -d',' -f1)"
    else
        echo -e "  ${RED}❌${NC} Docker: Not found"
    fi

    # Check services
    echo ""
    echo -e "${BOLD}Services:${NC}"

    if curl -s http://localhost:3127 >/dev/null 2>&1; then
        echo -e "  ${GREEN}✅${NC} Web UI: http://localhost:3127"
    else
        echo -e "  ${RED}❌${NC} Web UI: Not running"
    fi

    if curl -s http://localhost:4127/graphql >/dev/null 2>&1; then
        echo -e "  ${GREEN}✅${NC} GraphQL API: http://localhost:4127/graphql"
    else
        echo -e "  ${RED}❌${NC} GraphQL API: Not running"
    fi

    if curl -s http://localhost:7474 >/dev/null 2>&1; then
        echo -e "  ${GREEN}✅${NC} Neo4j Database: http://localhost:7474"
    else
        echo -e "  ${RED}❌${NC} Neo4j Database: Not running"
    fi
}

cmd_vm() {
    show_banner
    log_info "🖥️  Managing Multipass VMs..."

    # Check if multipass is installed
    if ! command -v multipass &> /dev/null; then
        log_error "❌ Multipass is not installed!"
        echo ""
        echo "Please install Multipass from: https://multipass.run"
        echo ""
        echo "Installation commands:"
        echo -e "  ${GREEN}macOS:${NC}   brew install --cask multipass"
        echo -e "  ${GREEN}Ubuntu:${NC}  sudo snap install multipass"
        echo -e "  ${GREEN}Windows:${NC} Download from https://multipass.run"
        exit 1
    fi

    # Pass all arguments to multipass.sh
    ./scripts/vm/multipass.sh "${REMAINING_ARGS[@]}"
}

# Execute the command
case $COMMAND in
    dev)
        cmd_dev
        ;;
    quick)
        cmd_quick
        ;;
    clean)
        cmd_clean
        ;;
    setup)
        cmd_setup
        ;;
    test)
        cmd_test
        ;;
    build)
        cmd_build
        ;;
    deploy)
        cmd_deploy
        ;;
    stop)
        cmd_stop
        ;;
    remove)
        cmd_remove
        ;;
    status)
        cmd_status
        ;;
    vm)
        cmd_vm
        ;;
    *)
        log_error "❌ Unknown command: $COMMAND"
        echo "Use './start --help' for usage information."
        exit 1
        ;;
esac