#!/usr/bin/env bash

# Memory Usage Monitor Hook
# Monitors system and process memory usage during development activities

echo "💾 Memory Usage Monitor" >&2

# Initialize monitoring variables
TOTAL_MEMORY_KB=0
USED_MEMORY_KB=0
MEMORY_PERCENT=0
SWAP_PERCENT=0
HIGH_MEMORY_THRESHOLD=75
CRITICAL_MEMORY_THRESHOLD=90
HIGH_SWAP_THRESHOLD=25
WARNINGS=0
ERRORS=0

# Function to report memory status
report_memory() {
  local level="$1"
  local message="$2"
  
  case "$level" in
    "ERROR")
      echo "❌ CRITICAL: $message" >&2
      ERRORS=$((ERRORS + 1))
      ;;
    "WARNING")
      echo "⚠️ WARNING: $message" >&2
      WARNINGS=$((WARNINGS + 1))
      ;;
    "INFO")
      echo "ℹ️ INFO: $message" >&2
      ;;
    "PASS")
      echo "✅ OK: $message" >&2
      ;;
  esac
}

# Function to format bytes to human readable
format_bytes() {
  local bytes=$1
  local units=("B" "KB" "MB" "GB" "TB")
  local unit=0
  
  while (( bytes > 1024 && unit < 4 )); do
    bytes=$((bytes / 1024))
    unit=$((unit + 1))
  done
  
  echo "${bytes}${units[$unit]}"
}

# 1. System Memory Analysis
echo "📊 Analyzing system memory usage..." >&2

# Detect operating system for platform-specific commands
OS_TYPE=$(uname -s)

case "$OS_TYPE" in
  "Linux")
    # Linux memory information
    if [ -f /proc/meminfo ]; then
      TOTAL_MEMORY_KB=$(grep '^MemTotal:' /proc/meminfo | awk '{print $2}')
      AVAILABLE_MEMORY_KB=$(grep '^MemAvailable:' /proc/meminfo | awk '{print $2}' || echo "0")
      
      if [ "$AVAILABLE_MEMORY_KB" -eq 0 ]; then
        # Fallback calculation for older systems
        FREE_MEMORY_KB=$(grep '^MemFree:' /proc/meminfo | awk '{print $2}')
        BUFFERS_KB=$(grep '^Buffers:' /proc/meminfo | awk '{print $2}')
        CACHED_KB=$(grep '^Cached:' /proc/meminfo | awk '{print $2}')
        AVAILABLE_MEMORY_KB=$((FREE_MEMORY_KB + BUFFERS_KB + CACHED_KB))
      fi
      
      USED_MEMORY_KB=$((TOTAL_MEMORY_KB - AVAILABLE_MEMORY_KB))
      MEMORY_PERCENT=$((USED_MEMORY_KB * 100 / TOTAL_MEMORY_KB))
      
      echo "   🖥️ Total Memory: $(format_bytes $((TOTAL_MEMORY_KB * 1024)))" >&2
      echo "   📈 Used Memory: $(format_bytes $((USED_MEMORY_KB * 1024))) ($MEMORY_PERCENT%)" >&2
      
      # Check swap usage
      if [ -f /proc/swaps ]; then
        SWAP_TOTAL_KB=$(awk 'NR>1 {sum+=$3} END {print sum+0}' /proc/swaps)
        SWAP_USED_KB=$(awk 'NR>1 {sum+=$4} END {print sum+0}' /proc/swaps)
        
        if [ "$SWAP_TOTAL_KB" -gt 0 ]; then
          SWAP_PERCENT=$((SWAP_USED_KB * 100 / SWAP_TOTAL_KB))
          echo "   💿 Swap Usage: $(format_bytes $((SWAP_USED_KB * 1024))) / $(format_bytes $((SWAP_TOTAL_KB * 1024))) ($SWAP_PERCENT%)" >&2
        else
          echo "   💿 Swap: Not configured" >&2
        fi
      fi
    else
      report_memory "WARNING" "Unable to read /proc/meminfo - memory monitoring limited"
    fi
    ;;
    
  "Darwin")
    # macOS memory information
    if command -v vm_stat &> /dev/null; then
      # Get page size
      PAGE_SIZE=$(vm_stat | grep 'page size of' | awk '{print $8}' || echo "4096")
      
      # Get memory statistics
      VM_STAT_OUTPUT=$(vm_stat)
      PAGES_FREE=$(echo "$VM_STAT_OUTPUT" | grep 'Pages free:' | awk '{print $3}' | tr -d '.')
      PAGES_ACTIVE=$(echo "$VM_STAT_OUTPUT" | grep 'Pages active:' | awk '{print $3}' | tr -d '.')
      PAGES_INACTIVE=$(echo "$VM_STAT_OUTPUT" | grep 'Pages inactive:' | awk '{print $3}' | tr -d '.')
      PAGES_SPECULATIVE=$(echo "$VM_STAT_OUTPUT" | grep 'Pages speculative:' | awk '{print $3}' | tr -d '.' || echo "0")
      PAGES_WIRED=$(echo "$VM_STAT_OUTPUT" | grep 'Pages wired down:' | awk '{print $4}' | tr -d '.')
      
      # Calculate memory usage
      TOTAL_PAGES=$((PAGES_FREE + PAGES_ACTIVE + PAGES_INACTIVE + PAGES_SPECULATIVE + PAGES_WIRED))
      USED_PAGES=$((PAGES_ACTIVE + PAGES_INACTIVE + PAGES_SPECULATIVE + PAGES_WIRED))
      TOTAL_MEMORY_KB=$((TOTAL_PAGES * PAGE_SIZE / 1024))
      USED_MEMORY_KB=$((USED_PAGES * PAGE_SIZE / 1024))
      MEMORY_PERCENT=$((USED_MEMORY_KB * 100 / TOTAL_MEMORY_KB))
      
      echo "   🖥️ Total Memory: $(format_bytes $((TOTAL_MEMORY_KB * 1024)))" >&2
      echo "   📈 Used Memory: $(format_bytes $((USED_MEMORY_KB * 1024))) ($MEMORY_PERCENT%)" >&2
      
      # Check swap usage on macOS
      if command -v sysctl &> /dev/null; then
        SWAP_USAGE=$(sysctl vm.swapusage 2>/dev/null | grep -oE 'used = [0-9.]+[KMGT]?' | awk '{print $3}' || echo "0")
        SWAP_TOTAL=$(sysctl vm.swapusage 2>/dev/null | grep -oE 'total = [0-9.]+[KMGT]?' | awk '{print $3}' || echo "0")
        echo "   💿 Swap Usage: $SWAP_USAGE / $SWAP_TOTAL" >&2
      fi
    else
      report_memory "WARNING" "vm_stat command not available - memory monitoring limited"
    fi
    ;;
    
  *)
    report_memory "WARNING" "Unsupported operating system ($OS_TYPE) - limited memory monitoring"
    ;;
esac

# 2. Process-Specific Memory Analysis
echo "🔍 Analyzing development process memory usage..." >&2

# Define process patterns for different development environments
DEV_PROCESSES=("node" "python" "java" "ruby" "php" "go" "rust" "dotnet" "code" "claude")
TOTAL_DEV_MEMORY_KB=0
PROCESS_COUNT=0

for process in "${DEV_PROCESSES[@]}"; do
  if command -v pgrep &> /dev/null; then
    # Use pgrep for more accurate process detection
    PIDS=$(pgrep -f "$process" 2>/dev/null || true)
    
    if [ -n "$PIDS" ]; then
      PROCESS_MEMORY=0
      PROC_COUNT=0
      
      # Calculate memory for all matching processes
      for pid in $PIDS; do
        if [ -f "/proc/$pid/status" ]; then
          # Linux: Read from /proc/pid/status
          PID_MEMORY=$(grep '^VmRSS:' "/proc/$pid/status" 2>/dev/null | awk '{print $2}' || echo "0")
        elif command -v ps &> /dev/null; then
          # macOS/Other: Use ps command
          PID_MEMORY=$(ps -o rss= -p "$pid" 2>/dev/null | awk '{print $1}' || echo "0")
        else
          PID_MEMORY=0
        fi
        
        PROCESS_MEMORY=$((PROCESS_MEMORY + PID_MEMORY))
        PROC_COUNT=$((PROC_COUNT + 1))
      done
      
      if [ "$PROCESS_MEMORY" -gt 0 ]; then
        echo "   🔧 $process processes: $PROC_COUNT running, $(format_bytes $((PROCESS_MEMORY * 1024))) memory" >&2
        TOTAL_DEV_MEMORY_KB=$((TOTAL_DEV_MEMORY_KB + PROCESS_MEMORY))
        PROCESS_COUNT=$((PROCESS_COUNT + PROC_COUNT))
      fi
    fi
  fi
done

if [ "$TOTAL_DEV_MEMORY_KB" -gt 0 ]; then
  DEV_MEMORY_PERCENT=$((TOTAL_DEV_MEMORY_KB * 100 / TOTAL_MEMORY_KB))
  echo "   📊 Total dev processes: $PROCESS_COUNT processes, $(format_bytes $((TOTAL_DEV_MEMORY_KB * 1024))) ($DEV_MEMORY_PERCENT% of system)" >&2
else
  echo "   📋 No development processes detected" >&2
fi

# 3. Container Memory Monitoring (if applicable)
echo "🐳 Checking container memory usage..." >&2

if command -v docker &> /dev/null && docker info >/dev/null 2>&1; then
  # Check Docker container memory usage
  RUNNING_CONTAINERS=$(docker ps --format "table {{.Names}}" --no-trunc 2>/dev/null | tail -n +2 | wc -l || echo "0")
  
  if [ "$RUNNING_CONTAINERS" -gt 0 ]; then
    echo "   🐳 Docker containers: $RUNNING_CONTAINERS running" >&2
    
    # Get container memory stats (basic)
    CONTAINER_STATS=$(docker stats --no-stream --format "table {{.Container}}\t{{.MemUsage}}" 2>/dev/null | tail -n +2 | head -5 || true)
    
    if [ -n "$CONTAINER_STATS" ]; then
      echo "   📊 Top container memory usage:" >&2
      echo "$CONTAINER_STATS" | while read line; do
        echo "     $line" >&2
      done
    fi
  else
    echo "   🐳 No running Docker containers" >&2
  fi
else
  echo "   🐳 Docker not available or not running" >&2
fi

# 4. Memory Threshold Analysis
echo "⚠️ Analyzing memory thresholds..." >&2

# Check system memory thresholds
if [ "$MEMORY_PERCENT" -ge "$CRITICAL_MEMORY_THRESHOLD" ]; then
  report_memory "ERROR" "Critical system memory usage: $MEMORY_PERCENT% (threshold: $CRITICAL_MEMORY_THRESHOLD%)"
elif [ "$MEMORY_PERCENT" -ge "$HIGH_MEMORY_THRESHOLD" ]; then
  report_memory "WARNING" "High system memory usage: $MEMORY_PERCENT% (threshold: $HIGH_MEMORY_THRESHOLD%)"
else
  report_memory "PASS" "System memory usage within normal range: $MEMORY_PERCENT%"
fi

# Check swap usage
if [ "$SWAP_PERCENT" -ge "$HIGH_SWAP_THRESHOLD" ]; then
  report_memory "WARNING" "High swap usage detected: $SWAP_PERCENT% (threshold: $HIGH_SWAP_THRESHOLD%)"
else
  if [ "$SWAP_PERCENT" -gt 0 ]; then
    report_memory "INFO" "Swap usage normal: $SWAP_PERCENT%"
  fi
fi

# Check for potential memory leaks (high dev process usage)
if [ "$TOTAL_DEV_MEMORY_KB" -gt 0 ] && [ "$DEV_MEMORY_PERCENT" -ge 50 ]; then
  report_memory "WARNING" "Development processes using significant memory: $DEV_MEMORY_PERCENT% of system"
elif [ "$TOTAL_DEV_MEMORY_KB" -gt 0 ]; then
  report_memory "INFO" "Development process memory usage normal: $DEV_MEMORY_PERCENT% of system"
fi

# 5. Memory Recommendations
echo "💡 Memory optimization recommendations..." >&2

if [ "$MEMORY_PERCENT" -ge "$HIGH_MEMORY_THRESHOLD" ]; then
  echo "   • Consider closing unused applications and browser tabs" >&2
  echo "   • Restart development servers to free up memory" >&2
  echo "   • Check for memory leaks in your applications" >&2
fi

if [ "$SWAP_PERCENT" -ge "$HIGH_SWAP_THRESHOLD" ]; then
  echo "   • High swap usage may slow down development" >&2
  echo "   • Consider adding more RAM or closing applications" >&2
fi

if [ "$PROCESS_COUNT" -gt 10 ]; then
  echo "   • Many development processes running ($PROCESS_COUNT)" >&2
  echo "   • Consider stopping unused development servers" >&2
fi

# 6. Generate Memory Summary
echo "" >&2
echo "📋 Memory Usage Summary:" >&2
echo "========================" >&2
echo "   💾 System Memory: $MEMORY_PERCENT% used ($(format_bytes $((USED_MEMORY_KB * 1024))) / $(format_bytes $((TOTAL_MEMORY_KB * 1024))))" >&2
[ "$SWAP_PERCENT" -gt 0 ] && echo "   💿 Swap Usage: $SWAP_PERCENT%" >&2
echo "   🔧 Dev Processes: $PROCESS_COUNT running ($(format_bytes $((TOTAL_DEV_MEMORY_KB * 1024))))" >&2
echo "   ⚠️ Warnings: $WARNINGS" >&2
echo "   ❌ Critical Issues: $ERRORS" >&2

if [ "$ERRORS" -eq 0 ] && [ "$WARNINGS" -eq 0 ]; then
  echo "   🎉 Status: OPTIMAL - Memory usage is healthy" >&2
elif [ "$ERRORS" -eq 0 ]; then
  echo "   ✅ Status: GOOD - Memory usage acceptable with minor warnings" >&2
else
  echo "   ❌ Status: CRITICAL - Memory usage requires immediate attention" >&2
fi

echo "" >&2
echo "💡 Memory Best Practices:" >&2
echo "   • Monitor memory usage regularly during development" >&2
echo "   • Use memory profiling tools to identify leaks" >&2
echo "   • Restart development servers periodically" >&2
echo "   • Consider using lighter development tools when memory is limited" >&2
echo "   • Close unused applications and browser tabs" >&2

# Memory monitoring complete
exit 0