import os
import sys
from typing import Dict, List

def confess_environment_sins() -> Dict[str, List[str]]:
    """
    Analyzes your environment variables and confesses all sins.
    Returns a dictionary with 'missing', 'deprecated', and 'mismatched' variables.
    """
    
    # Define your expected environment variables
    EXPECTED_VARS = {
        'API_KEY': 'Your main API key',
        'DATABASE_URL': 'PostgreSQL connection string',
        'NODE_ENV': 'Environment (production/staging/development)',
        'REDIS_URL': 'Redis connection string',
        'PORT': 'Application port number'
    }
    
    # Define deprecated variables that should be removed
    DEPRECATED_VARS = [
        'API_KEY_FROM_THAT_SERVICE_WE_DEPRECATED_IN_2019',
        'LEGACY_DB_CONNECTION',
        'OLD_FEATURE_FLAG'
    ]
    
    # Define expected values for specific environments
    EXPECTED_VALUES = {
        'NODE_ENV': ['production', 'staging', 'development'],
        'PORT': lambda x: x.isdigit() and 1024 <= int(x) <= 65535
    }
    
    results = {
        'missing': [],
        'deprecated': [],
        'mismatched': []
    }
    
    # Check for missing expected variables
    for var, description in EXPECTED_VARS.items():
        if var not in os.environ:
            results['missing'].append(f"{var}: {description}")
    
    # Check for deprecated variables still in use
    for var in DEPRECATED_VARS:
        if var in os.environ:
            results['deprecated'].append(var)
    
    # Validate variable values
    for var, validator in EXPECTED_VALUES.items():
        if var in os.environ:
            value = os.environ[var]
            if isinstance(validator, list):
                if value not in validator:
                    results['mismatched'].append(f"{var}='{value}' (expected: {', '.join(validator)})")
            elif callable(validator):
                if not validator(value):
                    results['mismatched'].append(f"{var}='{value}' (failed validation)")
    
    return results

# Usage example
if __name__ == "__main__":
    sins = confess_environment_sins()
    
    if any(sins.values()):
        print("\n🔍 ENVIRONMENT VARIABLE CONFESSION:\n")
        
        if sins['missing']:
            print("❌ MISSING VARIABLES:")
            for item in sins['missing']:
                print(f"  - {item}")
        
        if sins['deprecated']:
            print("\n🗑️ DEPRECATED VARIABLES STILL IN USE:")
            for var in sins['deprecated']:
                print(f"  - {var}")
        
        if sins['mismatched']:
            print("\n⚠️ VALUE MISMATCHES:")
            for item in sins['mismatched']:
                print(f"  - {item}")
        
        sys.exit(1)  # Exit with error code if sins found
    else:
        print("✅ Your environment is clean! No sins to confess.")
        sys.exit(0)

The Problem: Your .env Files Are Cargo-Cult Scripture

Let's be honest: your project's .env.example file is less of a template and more of an archaeological artifact. It contains variables like API_KEY_FROM_THAT_SERVICE_WE_DEPRECATED_IN_2019 that nobody has touched in years, alongside cryptic entries like NODE_ENV=production (which, shockingly, you've been running as 'development' in staging for six months).

This problem exists because environment variables have become the duct tape of configuration management. Need a secret? Environment variable. Need a feature flag? Environment variable. Need to remember which port the Redis instance is on? Environment variable. Before you know it, you've got 47 sacred incantations that must be whispered exactly right into the shell, or your application will collapse like a Jenga tower in an earthquake.

The absurdity peaks when you witness the 'it works on my machine' ritual. Developer A's application runs flawlessly because they have a secret .env.local file they forgot to commit (or, more likely, intentionally hid because it contains their personal AWS credentials). Developer B's identical code fails silently because their STRIPE_WEBHOOK_SECRET is actually named STRIPE_WEBHOOK_KEY in the code. The entire team spends Thursday afternoon performing digital archaeology instead of building features.

The Solution: A Digital Priest for Your Configuration Sins

I built Env Vars Confessional to solve this exact problem. It's not just another linter or validator—it's an intervention for your configuration management.

Here's how it works: the tool scans your codebase for every instance of process.env.SOMETHING or equivalent environment variable access patterns. It then compares this list against what's actually available in your environment (including .env files, shell environment, etc.). Instead of giving you a dry error report, it generates dramatic 'confessions' that highlight exactly what's wrong.

The beauty is in the brutal honesty. While other tools might whisper 'undefined variable,' Env Vars Confessional shouts: 'I CONFESS! I tried to access DATABASE_PASSWORD but found only DATABASE_PASSWD in the environment. This is not a typo I can forgive.' It's useful precisely because it makes the problem impossible to ignore while actually suggesting fixes.

How to Use It: Your Path to Redemption

Installation is straightforward—because if it weren't, you'd never use it, and we'd all go back to debugging missing variables at 2 AM. Install it globally or as a dev dependency:

npm install -g env-vars-confessional
# or
npm install --save-dev env-vars-confessional

Basic usage is even simpler. Navigate to your project and run:

env-confess

The tool will scan your code and output something beautifully dramatic. Here's a snippet from the actual confession generator:

// From the confession generator in the source
function generateConfession(missingVar, foundVars) {
  const suggestions = foundVars.filter(v => 
    levenshteinDistance(v, missingVar) < 3
  );
  
  if (suggestions.length > 0) {
    return `I CONFESS! I sought ${missingVar} but found ${suggestions[0]}. ` +
           `Was this a typo or an act of rebellion?`;
  }
  return `I CONFESS! ${missingVar} is missing. ` +
         `The void where it should be mocks us all.`;
}

Check out the full source code on GitHub to see how it intelligently suggests fixes based on similar variable names—because we all know API_KEY versus APIKEY has caused more production incidents than any actual bug.

Key Features: More Than Just Shame

• Scans your code for process.env calls and required variables: It actually reads your code, unlike your junior developer who's still using the .env file from the tutorial they followed three years ago.
• Compares against actual environment and .env files: It checks everywhere variables might be hiding, because secrets have more hiding spots than a toddler with a cookie.
• Generates dramatic 'confessions' for missing/misconfigured variables: The theatrical shame is scientifically proven to be 73% more memorable than dry error codes.
• Suggests actual fixes instead of just complaining: It doesn't just point out that DB_HOST is missing—it suggests that maybe you meant DATABASE_HOST which is actually set.
• Can run as pre-commit hook or CI step: Prevent configuration sins from ever reaching your repository, like a bouncer for bad environment variables.

Conclusion: Stop Debugging, Start Confessing

The real benefit of Env Vars Confessional isn't just that it finds missing variables—it's that it creates a living documentation of what your application actually needs. No more copying .env files from project to project like they're sacred texts. No more silent failures in production because someone forgot to set the REDIS_TLS_ENABLED flag. Just clear, dramatic, actually helpful feedback about what's wrong with your configuration.

Try it out: https://github.com/BoopyCode/env-vars-confessional. Your future self—the one who isn't debugging production at 3 AM—will thank you.

Remember: in the church of DevOps, environment variables are the holy water. Make sure yours isn't just tap water in a fancy bottle.