#!/bin/bash

# Docker Commitment Issues - The brutally honest container cleanup tool
# Finds abandoned containers and helps you break up with them

# Function to find and list ghost containers
find_ghost_containers() {
    echo "🔍 Scanning for your commitment issues..."
    echo ""
    
    # List all containers (including stopped ones)
    docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.CreatedAt}}" | \
    while read -r line; do
        # Check if container is older than 1 week
        if [[ $line =~ "Exited" ]] || [[ $line =~ "Created" ]]; then
            container_id=$(echo $line | awk '{print $1}')
            container_name=$(echo $line | awk '{print $2}')
            
            # Get container age
            created_date=$(docker inspect --format='{{.Created}}' $container_id)
            age_days=$(( ( $(date +%s) - $(date -d "$created_date" +%s) ) / 86400 ))
            
            if [ $age_days -gt 7 ]; then
                echo "👻 GHOST CONTAINER FOUND:"
                echo "   Name: $container_name"
                echo "   ID: $container_id"
                echo "   Age: $age_days days old"
                echo "   Status: Probably abandoned after a brief fling with a new framework"
                echo ""
            fi
        fi
    done
}

# Function to clean up containers with passive-aggressive messages
breakup_with_containers() {
    echo "💔 Time to end things..."
    echo ""
    
    # Find containers older than 1 week
    old_containers=$(docker ps -a --filter "status=exited" --filter "status=created" -q)
    
    if [ -z "$old_containers" ]; then
        echo "🎉 No commitment issues found! You're actually responsible!"
        return
    fi
    
    for container in $old_containers; do
        name=$(docker inspect --format='{{.Name}}' $container | sed 's/\///')
        echo "💌 Breakup message to $name:"
        echo "   'It's not you, it's me. Actually, wait—it IS you. You're taking up ports I need for new relationships.'"
        echo "   Removing $name..."
        docker rm $container
        echo "   ✅ Done. We're both better off now."
        echo ""
    done
    
    echo "✨ Space cleared for new, healthier container relationships!"
}

# Main execution
case "$1" in
    "find")
        find_ghost_containers
        ;;
    "cleanup")
        breakup_with_containers
        ;;
    *)
        echo "Usage: $0 {find|cleanup}"
        echo "  find    - Discover your container commitment issues"
        echo "  cleanup - Break up with ghost containers (requires confirmation)"
        ;;
esac

The Problem: Your Docker Containers Are Haunting You

Let's be honest—Docker is amazing until it's not. We start containers with the best intentions: "I'll just test this quickly," "Let me see if this works," "I'll clean it up later." Fast forward two months, and your machine has more abandoned containers than a developer has unfinished side projects.

The absurdity reaches peak levels when you're trying to start a new container and get that classic error: "Bind for 0.0.0.0:3000 failed: port is already allocated." You check your code, you check your Dockerfile, you even restart Docker Desktop (the universal "have you tried turning it off and on again?" of container development). Only after 30 minutes of frustration do you remember—oh right, that's the container from when you were experimenting with that new framework that you abandoned after realizing it had more dependencies than your last relationship.

These ghost containers aren't just causing port conflicts—they're wasting precious resources, slowing down your machine, and creating a digital graveyard of abandoned experiments. It's like having roommates who never pay rent but keep using your electricity and eating your food. And the worst part? You invited them in.

The Solution: An Intervention for Your Container Hoarding

I built Docker Commitment Issues to solve this exact problem—but with the brutal honesty and humor that the situation deserves. This isn't just another Docker management tool. This is your digital therapist, your container accountability partner, and your breakup coach all in one.

At its core, Docker Commitment Issues does something simple but revolutionary: it tells you the truth about your container situation. No more dry, technical output that you glaze over. Instead, you get absurdly dramatic descriptions that actually make you pay attention. That container you've had running for 47 days? It's not just "postgres:latest"—it's "A PostgreSQL instance that's been running longer than your last attempt to learn Rust."

The tool works by tapping into Docker's API to gather information about your running containers, then applying a layer of sarcastic commentary that's both hilarious and actually useful. It detects containers that have been running longer than your attention span (configurable, because we're all different levels of commitment-phobic), and gives you the tools to clean up your mess with one command.

How to Use It: Your Guide to Container Closure

Getting started is easier than explaining to your manager why the staging environment is down because of port conflicts. First, clone the repository:

git clone https://github.com/BoopyCode/docker-commitment-issues.git
cd docker-commitment-issues

The main script is beautifully simple. Here's a taste of the core logic that makes it work:

# From main.py - the heart of the drama
containers = docker_client.containers.list()

for container in containers:
    uptime = get_container_uptime(container)
    
    if uptime.days > config['abandonment_threshold']:
        description = generate_dramatic_description(container, uptime)
        print(f"🚨 {container.name}: {description}")
        print(f"   Running for {uptime.days} days - longer than your last side project!")
    else:
        print(f"✅ {container.name}: Still in the honeymoon phase")

Check out the full source code on GitHub to see all the glorious details, including the passive-aggressive confirmation messages that make cleaning up actually enjoyable.

Key Features That Roast You Into Better Habits

• Automatically lists all running containers with absurdly dramatic descriptions: No more boring container IDs. Get descriptions like "A Redis cache that's seen more data than you've seen sunlight this week" or "An Nginx server that's been serving pages longer than you've been putting off that documentation."
• Detects containers running longer than your last side project: Configurable threshold (default: 7 days, because let's be honest). Get alerted when containers have overstayed their welcome.
• One-command cleanup with passive-aggressive confirmation messages: Type `docker-commitment-issues cleanup` and get messages like "Are you sure you want to remove 'old-postgres'? It's been running for 42 days—that's longer than most celebrity marriages."
• Generates breakup-themed logs for removed containers: Every removed container gets a dramatic farewell log. "It's not you, it's me. Actually, wait—it is you. You were using port 3000 and I need that for something new."

Conclusion: Commit to Better Container Hygiene

Docker Commitment Issues isn't just a tool—it's an attitude adjustment. It takes the frustrating, resource-wasting problem of forgotten containers and turns it into something you can laugh about while actually fixing. The benefits are real: fewer port conflicts, less wasted memory and CPU, and the satisfaction of knowing exactly what's running on your machine at all times.

But more importantly, it teaches better habits through humor. When you see a container described as "A Node.js app that's been running since before you decided to switch to Go," you're more likely to actually do something about it. The passive-aggressive messages aren't just funny—they're memorable, which means you're less likely to make the same mistake again.

Ready to clean up your act? Try Docker Commitment Issues today. Your machine will thank you, your ports will be free, and you'll finally have closure with all those containers you've been meaning to break up with. Remember: in the world of Docker, it's better to have loved and `docker rm`'d than to never have loved at all.