tap_fullstack.py

import os
import sys
import subprocess
from pathlib import Path
import secrets
import string
import shutil
import json
import textwrap

# ------------------------
# Config
# ------------------------
PROJECT_REQUIREMENTS = [
    "django>=4.2",
    "djangorestframework",
    "djangorestframework-simplejwt",
    "django-cors-headers",
    "python-dotenv",
    "django-jet-reboot",
    "drf-yasg",
    "gunicorn",
    "whitenoise",
    "psycopg2-binary",  # PostgreSQL support
    "dj-database-url",  # Database URL parsing
]

API_APP = "api"


# ------------------------
# Helpers
# ------------------------
def run(cmd, cwd=None):
    print(f"→ Running: {cmd}")
    result = subprocess.run(cmd, shell=True, cwd=cwd)
    if result.returncode != 0:
        print(f"❌ Command failed: {cmd}")
        sys.exit(1)


def generate_secret_key():
    chars = string.ascii_letters + string.digits + "!@#$%^&*(-_=+)"
    return "".join(secrets.choice(chars) for _ in range(50))


def write_file(path, content):
    path.write_text(content.strip() + "\n")


def get_system_python():
    python = shutil.which("python3") or shutil.which("python")
    if not python:
        raise RuntimeError("Python not found! Install python3 or add python to PATH.")
    return python


def get_venv_python(base):
    """Detect correct venv python executable"""
    if os.name == "nt":
        venv_python = base / "venv" / "Scripts" / "python.exe"
    else:
        venv_python = base / "venv" / "bin" / "python3"
        if not venv_python.exists():
            venv_python = base / "venv" / "bin" / "python"
    if not venv_python.exists():
        raise RuntimeError(f"Python executable not found in venv: {venv_python}")
    return venv_python


# ------------------------
# Deployment Config Generators
# ------------------------
def generate_google_cloud_config(base, project_name):
    """Generate Google Cloud Run/App Engine configurations"""
    gcloud_dir = base / "deploy" / "google-cloud"
    gcloud_dir.mkdir(parents=True, exist_ok=True)
    
    # App Engine app.yaml
    write_file(gcloud_dir / "app.yaml", textwrap.dedent(f"""
        runtime: python311
        entrypoint: gunicorn {project_name}.wsgi:application --bind 0.0.0.0:$PORT
        
        env_variables:
          DJANGO_SETTINGS_MODULE: "{project_name}.settings"
          SECRET_KEY: "${{SECRET_KEY}}"
          DEBUG: "False"
          ALLOWED_HOSTS: ".your-app.appspot.com,.run.app"
          CSRF_TRUSTED_ORIGINS: "https://*.appspot.com,https://*.run.app"
          
          # Database (Cloud SQL)
          DB_ENGINE: "django.db.backends.postgresql"
          DB_HOST: "/cloudsql/YOUR_PROJECT:REGION:INSTANCE_NAME"
          DB_NAME: "YOUR_DB_NAME"
          DB_USER: "YOUR_DB_USER"
          DB_PASSWORD: "${{DB_PASSWORD}}"
        
        # Enable App Engine bundled services
        beta_settings:
          cloud_sql_instances: "YOUR_PROJECT:REGION:INSTANCE_NAME"
        
        automatic_scaling:
          min_instances: 1
          max_instances: 3
          target_cpu_utilization: 0.65
        
        handlers:
        - url: /static
          static_dir: staticfiles/
        - url: /.*
          script: auto
    """))
    
    # Cloud Run Dockerfile
    write_file(gcloud_dir / "Dockerfile.cloudrun", textwrap.dedent(f"""
        # Use the official Python image
        FROM python:3.11-slim
        
        # Install Node.js for frontend build
        RUN apt-get update && apt-get install -y curl gnupg
        RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash -
        RUN apt-get install -y nodejs build-essential
        
        # Create and set working directory
        WORKDIR /app
        
        # Copy requirements and install dependencies
        COPY requirements.txt .
        RUN pip install --upgrade pip && pip install -r requirements.txt
        RUN pip install gunicorn
        
        # Copy frontend and build
        COPY frontend/ ./frontend/
        WORKDIR /app/frontend
        RUN npm install && npm run build
        WORKDIR /app
        
        # Copy application code
        COPY . .
        
        # Collect static files
        RUN python manage.py collectstatic --noinput
        
        # Run migrations (in production, this should be handled separately)
        # RUN python manage.py migrate --noinput
        
        # Run the web service on container startup
        CMD exec gunicorn --bind :$PORT --workers 2 --threads 8 --timeout 0 {project_name}.wsgi:application
    """))
    
    # Cloud Build configuration
    write_file(gcloud_dir / "cloudbuild.yaml", textwrap.dedent("""
        steps:
        # Build the container image
        - name: 'gcr.io/cloud-builders/docker'
          args: ['build', '-t', 'gcr.io/$PROJECT_ID/$REPO_NAME:$COMMIT_SHA', '-f', 'deploy/google-cloud/Dockerfile.cloudrun', '.']
        
        # Push the container image to Container Registry
        - name: 'gcr.io/cloud-builders/docker'
          args: ['push', 'gcr.io/$PROJECT_ID/$REPO_NAME:$COMMIT_SHA']
        
        # Deploy to Cloud Run
        - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
          entrypoint: gcloud
          args:
          - 'run'
          - 'deploy'
          - '$REPO_NAME'
          - '--image'
          - 'gcr.io/$PROJECT_ID/$REPO_NAME:$COMMIT_SHA'
          - '--region'
          - 'us-central1'
          - '--platform'
          - 'managed'
          - '--allow-unauthenticated'
          - '--set-env-vars'
          - 'SECRET_KEY=$_SECRET_KEY,DEBUG=$_DEBUG,ALLOWED_HOSTS=$_ALLOWED_HOSTS'
        
        images:
        - 'gcr.io/$PROJECT_ID/$REPO_NAME:$COMMIT_SHA'
    """))
    
    # Deployment script
    write_file(gcloud_dir / "deploy.sh", textwrap.dedent("""#!/bin/bash
        
        # Google Cloud Deployment Script
        
        set -e
        
        echo "🔧 Setting up Google Cloud deployment..."
        
        # Check if gcloud is installed
        if ! command -v gcloud &> /dev/null; then
            echo "❌ Google Cloud SDK not found. Please install: https://cloud.google.com/sdk/docs/install"
            exit 1
        fi
        
        # Authenticate
        echo "🔐 Authenticating with Google Cloud..."
        gcloud auth login
        
        # Set project
        read -p "Enter your Google Cloud Project ID: " PROJECT_ID
        gcloud config set project $PROJECT_ID
        
        # Enable required APIs
        echo "🔄 Enabling required APIs..."
        gcloud services enable \
            cloudbuild.googleapis.com \
            run.googleapis.com \
            sqladmin.googleapis.com
        
        # Build and deploy
        echo "🚀 Building and deploying to Cloud Run..."
        
        # Set environment variables
        export SECRET_KEY=$(openssl rand -hex 32)
        export DEBUG=False
        export ALLOWED_HOSTS=".run.app"
        
        # Submit build
        gcloud builds submit \
            --config deploy/google-cloud/cloudbuild.yaml \
            --substitutions _SECRET_KEY=$SECRET_KEY,_DEBUG=$DEBUG,_ALLOWED_HOSTS=$ALLOWED_HOSTS
        
        echo "✅ Deployment complete!"
        echo "📦 Your app is now running on Cloud Run"
    """))
    os.chmod(gcloud_dir / "deploy.sh", 0o755)
    
    # README
    write_file(gcloud_dir / "README.md", textwrap.dedent(f"""
        # Google Cloud Deployment
        
        ## Prerequisites
        
        1. Install [Google Cloud SDK](https://cloud.google.com/sdk/docs/install)
        2. Create a Google Cloud Project
        3. Enable billing for your project
        
        ## Deployment Options
        
        ### Option 1: Cloud Run (Recommended)
        
        ```bash
        # Make deployment script executable
        chmod +x deploy/google-cloud/deploy.sh
        
        # Run deployment
        ./deploy/google-cloud/deploy.sh
        ```
        
        ### Option 2: App Engine
        
        ```bash
        # Deploy to App Engine
        gcloud app deploy deploy/google-cloud/app.yaml
        
        # View deployment
        gcloud app browse
        ```
        
        ### Option 3: Google Kubernetes Engine (GKE)
        
        See `deploy/google-cloud/` for Kubernetes manifests.
        
        ## Environment Variables
        
        Required environment variables for production:
        
        ```bash
        SECRET_KEY=your-secure-secret-key
        DEBUG=False
        ALLOWED_HOSTS=.run.app,.appspot.com
        DB_HOST=/cloudsql/PROJECT:REGION:INSTANCE_NAME
        DB_NAME=your_db_name
        DB_USER=your_db_user
        DB_PASSWORD=your_db_password
        ```
        
        ## Database Setup (Cloud SQL)
        
        1. Create Cloud SQL instance:
        ```bash
        gcloud sql instances create [INSTANCE_NAME] \\
            --database-version=POSTGRES_14 \\
            --cpu=1 --memory=3840MB \\
            --region=[REGION]
        ```
        
        2. Create database and user:
        ```bash
        gcloud sql databases create [DATABASE_NAME] --instance=[INSTANCE_NAME]
        gcloud sql users create [USER_NAME] --instance=[INSTANCE_NAME] --password=[PASSWORD]
        ```
        
        ## Monitoring
        
        - View logs: `gcloud app logs tail -s default`
        - Monitor metrics in Google Cloud Console
        - Set up alerts in Cloud Monitoring
    """))


def generate_aws_config(base, project_name):
    """Generate AWS Elastic Beanstalk/ECS configurations"""
    aws_dir = base / "deploy" / "aws"
    aws_dir.mkdir(parents=True, exist_ok=True)
    
    # Elastic Beanstalk
    write_file(aws_dir / "Dockerrun.aws.json", json.dumps({
        "AWSEBDockerrunVersion": "1",
        "Image": {
            "Name": "<YOUR_ECR_REPOSITORY_URI>:latest",
            "Update": "true"
        },
        "Ports": [{
            "ContainerPort": "8000",
            "HostPort": "8000"
        }],
        "Logging": "/var/log/django",
        "Volumes": [{
            "HostDirectory": "/var/app",
            "ContainerDirectory": "/var/app"
        }]
    }, indent=2))
    
    # ECS Task Definition
    write_file(aws_dir / "task-definition.json", json.dumps({
        "family": f"{project_name}-task",
        "networkMode": "awsvpc",
        "executionRoleArn": "arn:aws:iam::ACCOUNT_ID:role/ecsTaskExecutionRole",
        "taskRoleArn": "arn:aws:iam::ACCOUNT_ID:role/ecsTaskRole",
        "cpu": "512",
        "memory": "1024",
        "requiresCompatibilities": ["FARGATE"],
        "containerDefinitions": [{
            "name": f"{project_name}-container",
            "image": "<YOUR_ECR_REPOSITORY_URI>:latest",
            "portMappings": [{
                "containerPort": 8000,
                "hostPort": 8000,
                "protocol": "tcp"
            }],
            "environment": [
                {"name": "DJANGO_SETTINGS_MODULE", "value": f"{project_name}.settings"},
                {"name": "SECRET_KEY", "value": "from-parameter-store"},
                {"name": "DEBUG", "value": "False"},
                {"name": "ALLOWED_HOSTS", "value": ".elasticbeanstalk.com,.amazonaws.com"},
                {"name": "DATABASE_URL", "value": "from-secrets-manager"}
            ],
            "secrets": [
                {"name": "SECRET_KEY", "valueFrom": "arn:aws:ssm:REGION:ACCOUNT_ID:parameter/SECRET_KEY"},
                {"name": "DATABASE_URL", "valueFrom": "arn:aws:secretsmanager:REGION:ACCOUNT_ID:secret:DATABASE_URL"}
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": f"/ecs/{project_name}",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "ecs"
                }
            }
        }]
    }, indent=2))
    
    # Elastic Beanstalk .ebextensions
    ebext_dir = aws_dir / ".ebextensions"
    ebext_dir.mkdir(exist_ok=True)
    
    write_file(ebext_dir / "01_packages.config", textwrap.dedent("""
        packages:
          yum:
            nodejs18: []
            postgresql15-devel: []
        
        commands:
          01_install_node:
            command: "curl -fsSL https://rpm.nodesource.com/setup_18.x | bash -"
          02_update_node:
            command: "yum install -y nodejs"
    """))
    
    write_file(ebext_dir / "02_python.config", textwrap.dedent(f"""
        option_settings:
          aws:elasticbeanstalk:container:python:
            WSGIPath: {project_name}.wsgi:application
            NumProcesses: 3
            NumThreads: 20
          aws:elasticbeanstalk:application:environment:
            DJANGO_SETTINGS_MODULE: "{project_name}.settings"
            PYTHONPATH: "/var/app/current:$PYTHONPATH"
          aws:elasticbeanstalk:environment:proxy:staticfiles:
            /static: staticfiles/
    """))
    
    # RDS database setup
    write_file(ebext_dir / "03_rds.config", textwrap.dedent("""
        option_settings:
          aws:elasticbeanstalk:application:environment:
            RDS_HOSTNAME: "`{ \"Ref\" : \"AWSEBRDSDatabase\" }`"
            RDS_PORT: "`{ \"Fn::GetAtt\" : [ \"AWSEBRDSDatabase\", \"Endpoint.Port\" ] }`"
            RDS_DB_NAME: "`{ \"Ref\" : \"AWSEBRDSDatabase\" }`"
            RDS_USERNAME: "`{ \"Ref\" : \"AWSEBRDSDatabaseUsername\" }`"
            RDS_PASSWORD: "`{ \"Ref\" : \"AWSEBRDSDatabasePassword\" }`"
        
        Resources:
          AWSEBRDSDatabase:
            Type: AWS::RDS::DBInstance
            Properties:
              AllocatedStorage: 10
              DBInstanceClass: db.t3.micro
              Engine: postgres
              EngineVersion: "15.2"
              MasterUsername:
                Ref: AWSEBRDSDatabaseUsername
              MasterUserPassword:
                Ref: AWSEBRDSDatabasePassword
              DBName:
                Ref: AWSEBRDSDatabase
    """))
    
    # Deployment scripts
    write_file(aws_dir / "deploy-eb.sh", textwrap.dedent(f"""#!/bin/bash
        
        # AWS Elastic Beanstalk Deployment
        
        set -e
        
        echo "🔧 Setting up AWS Elastic Beanstalk deployment..."
        
        # Check prerequisites
        if ! command -v aws &> /dev/null; then
            echo "❌ AWS CLI not found. Please install: https://aws.amazon.com/cli/"
            exit 1
        fi
        
        if ! command -v eb &> /dev/null; then
            echo "❌ Elastic Beanstalk CLI not found. Please install: https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-install.html"
            exit 1
        fi
        
        # Initialize EB application
        echo "🚀 Initializing Elastic Beanstalk application..."
        eb init -p "python-3.11" {project_name} --region us-east-1
        
        # Create environment
        echo "🌱 Creating Elastic Beanstalk environment..."
        eb create {project_name}-env \
            --instance_type t3.small \
            --database \
            --database.username django \
            --database.password $(openssl rand -hex 16) \
            --database.engine postgres \
            --database.version 15.2 \
            --single \
            --envvars SECRET_KEY=$(openssl rand -hex 32),DEBUG=False,ALLOWED_HOSTS=.elasticbeanstalk.com
        
        # Deploy
        echo "📦 Deploying application..."
        eb deploy
        
        echo "✅ Deployment complete!"
        echo "🌐 Your app is running at: $(eb status | grep CNAME | awk '{{print $2}}')"
    """))
    os.chmod(aws_dir / "deploy-eb.sh", 0o755)
    
    write_file(aws_dir / "deploy-ecs.sh", textwrap.dedent(f"""#!/bin/bash
        
        # AWS ECS Deployment
        
        set -e
        
        echo "🔧 Setting up AWS ECS deployment..."
        
        # Variables
        REGION="us-east-1"
        REPOSITORY_NAME="{project_name}"
        CLUSTER_NAME="{project_name}-cluster"
        SERVICE_NAME="{project_name}-service"
        TASK_DEFINITION="deploy/aws/task-definition.json"
        
        # Check AWS CLI
        if ! command -v aws &> /dev/null; then
            echo "❌ AWS CLI not found. Please install: https://aws.amazon.com/cli/"
            exit 1
        fi
        
        # Login to ECR
        echo "🔐 Logging into ECR..."
        aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query 'Account' --output text).dkr.ecr.$REGION.amazonaws.com
        
        # Create ECR repository
        echo "📦 Creating ECR repository..."
        aws ecr create-repository --repository-name $REPOSITORY_NAME --region $REGION || true
        
        # Build and push image
        echo "🏗️ Building Docker image..."
        docker build -t $REPOSITORY_NAME:latest .
        
        # Tag and push
        REPOSITORY_URI=$(aws ecr describe-repositories --repository-names $REPOSITORY_NAME --query 'repositories[0].repositoryUri' --output text --region $REGION)
        docker tag $REPOSITORY_NAME:latest $REPOSITORY_URI:latest
        docker push $REPOSITORY_URI:latest
        
        # Update task definition with image URI
        echo "🔄 Updating task definition..."
        sed -i.bak "s|<YOUR_ECR_REPOSITORY_URI>|$REPOSITORY_URI|g" $TASK_DEFINITION
        
        # Register task definition
        echo "📝 Registering task definition..."
        aws ecs register-task-definition --cli-input-json file://$TASK_DEFINITION --region $REGION
        
        # Create cluster (if not exists)
        echo "🏗️ Creating ECS cluster..."
        aws ecs create-cluster --cluster-name $CLUSTER_NAME --region $REGION || true
        
        # Create service
        echo "🚀 Creating ECS service..."
        aws ecs create-service \
            --cluster $CLUSTER_NAME \
            --service-name $SERVICE_NAME \
            --task-definition {project_name}-task \
            --desired-count 1 \
            --launch-type FARGATE \
            --network-configuration "awsvpcConfiguration={{subnets=[subnet-xxxxxx],securityGroups=[sg-xxxxxx],assignPublicIp=ENABLED}}" \
            --region $REGION
        
        echo "✅ Deployment complete!"
    """))
    os.chmod(aws_dir / "deploy-ecs.sh", 0o755)
    
    # README
    write_file(aws_dir / "README.md", textwrap.dedent(f"""
        # AWS Deployment
        
        ## Deployment Options
        
        ### Option 1: Elastic Beanstalk (Easiest)
        
        ```bash
        # Install EB CLI first
        pip install awsebcli
        
        # Run Elastic Beanstalk deployment
        chmod +x deploy/aws/deploy-eb.sh
        ./deploy/aws/deploy-eb.sh
        ```
        
        ### Option 2: ECS with Fargate (More Control)
        
        ```bash
        # Run ECS deployment
        chmod +x deploy/aws/deploy-ecs.sh
        ./deploy/aws/deploy-ecs.sh
        ```
        
        ### Option 3: EC2 Manual Deployment
        
        1. Launch EC2 instance with Amazon Linux 2
        2. SSH into instance and run:
        ```bash
        # Install dependencies
        sudo yum update -y
        sudo yum install -y python3-pip nodejs postgresql-devel gcc
        
        # Clone your repository
        git clone <your-repo>
        cd {project_name}
        
        # Install and setup
        pip3 install -r requirements.txt
        npm install --prefix frontend
        npm run build --prefix frontend
        
        # Collect static files
        python3 manage.py collectstatic --noinput
        python3 manage.py migrate
        
        # Run with gunicorn
        gunicorn {project_name}.wsgi:application --bind 0.0.0.0:8000
        ```
        
        ## Database Setup (RDS)
        
        ### Automatic (with Elastic Beanstalk):
        - Database is automatically created with EB deployment
        
        ### Manual RDS Creation:
        ```bash
        aws rds create-db-instance \\
            --db-instance-identifier {project_name}-db \\
            --db-instance-class db.t3.micro \\
            --engine postgres \\
            --allocated-storage 20 \\
            --master-username django \\
            --master-user-password $(openssl rand -hex 16) \\
            --backup-retention-period 7 \\
            --multi-az false \\
            --publicly-accessible true \\
            --storage-type gp2
        ```
        
        ## Environment Variables
        
        Store sensitive data in AWS Systems Manager Parameter Store:
        
        ```bash
        aws ssm put-parameter \\
            --name "/{project_name}/SECRET_KEY" \\
            --value "$(openssl rand -hex 32)" \\
            --type SecureString
        
        aws ssm put-parameter \\
            --name "/{project_name}/DATABASE_URL" \\
            --value "postgres://user:pass@host:5432/dbname" \\
            --type SecureString
        ```
        
        ## Monitoring
        
        - CloudWatch Logs: View application logs
        - CloudWatch Metrics: Monitor performance
        - AWS X-Ray: Enable distributed tracing
        - Health Checks: Configure in Load Balancer
    """))


def generate_heroku_config(base, project_name):
    """Generate Heroku configurations"""
    heroku_dir = base / "deploy" / "heroku"
    heroku_dir.mkdir(parents=True, exist_ok=True)
    
    # Procfile
    write_file(base / "Procfile", f"web: gunicorn {project_name}.wsgi:application --bind 0.0.0.0:$PORT")
    
    # runtime.txt
    write_file(base / "runtime.txt", "python-3.11.6")
    
    # Heroku app.json
    write_file(heroku_dir / "app.json", json.dumps({
        "name": project_name,
        "description": f"{project_name} - Django REST API with React Frontend",
        "keywords": ["django", "rest", "react", "postgresql"],
        "scripts": {
            "postdeploy": "python manage.py migrate --noinput"
        },
        "env": {
            "SECRET_KEY": {
                "description": "Django secret key",
                "generator": "secret"
            },
            "DEBUG": {
                "description": "Disable debug mode in production",
                "value": "False"
            },
            "ALLOWED_HOSTS": {
                "description": "Comma-separated list of allowed hosts",
                "value": ".herokuapp.com"
            },
            "DISABLE_COLLECTSTATIC": {
                "description": "Disable collectstatic during build",
                "value": "0"
            }
        },
        "addons": [
            {
                "plan": "heroku-postgresql:hobby-dev",
                "options": {
                    "version": "15"
                }
            }
        ],
        "buildpacks": [
            {
                "url": "heroku/python"
            },
            {
                "url": "heroku/nodejs"
            }
        ],
        "formation": {
            "web": {
                "quantity": 1,
                "size": "eco"
            }
        }
    }, indent=2))
    
    # Heroku deployment script
    write_file(heroku_dir / "deploy.sh", textwrap.dedent(f"""#!/bin/bash
        
        # Heroku Deployment Script
        
        set -e
        
        echo "🔧 Setting up Heroku deployment..."
        
        # Check if Heroku CLI is installed
        if ! command -v heroku &> /dev/null; then
            echo "❌ Heroku CLI not found. Please install: https://devcenter.heroku.com/articles/heroku-cli"
            exit 1
        fi
        
        # Login to Heroku
        echo "🔐 Logging into Heroku..."
        heroku login
        
        # Create Heroku app
        echo "🚀 Creating Heroku app..."
        heroku create {project_name}-$(date +%s) || true
        
        # Set buildpacks (Python first, then Node.js)
        echo "🏗️ Setting buildpacks..."
        heroku buildpacks:clear
        heroku buildpacks:add heroku/python
        heroku buildpacks:add heroku/nodejs
        
        # Add PostgreSQL addon
        echo "💾 Adding PostgreSQL..."
        heroku addons:create heroku-postgresql:hobby-dev
        
        # Set environment variables
        echo "⚙️ Setting environment variables..."
        heroku config:set SECRET_KEY=$(openssl rand -hex 32)
        heroku config:set DEBUG=False
        heroku config:set ALLOWED_HOSTS=.herokuapp.com
        heroku config:set DISABLE_COLLECTSTATIC=0
        
        # Configure for Django
        echo "🔧 Configuring Django..."
        heroku config:set DJANGO_SETTINGS_MODULE={project_name}.settings
        heroku config:set PYTHONPATH="/app"
        
        # Deploy
        echo "📦 Deploying to Heroku..."
        git push heroku main
        
        # Run migrations
        echo "🔄 Running migrations..."
        heroku run python manage.py migrate --noinput
        
        # Create superuser (optional)
        read -p "Create superuser? (y/n): " -n 1 -r
        echo
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            heroku run python manage.py createsuperuser
        fi
        
        # Open app
        echo "🌐 Opening application..."
        heroku open
        
        echo "✅ Deployment complete!"
        echo "📊 View logs: heroku logs --tail"
    """))
    os.chmod(heroku_dir / "deploy.sh", 0o755)
    
    # Heroku-specific Django settings
    write_file(heroku_dir / "heroku_settings.py", textwrap.dedent(f"""
        # Heroku-specific Django settings
        import os
        import dj_database_url
        
        # Configure Django for Heroku
        SECRET_KEY = os.environ.get('SECRET_KEY')
        DEBUG = os.environ.get('DEBUG', 'False') == 'True'
        ALLOWED_HOSTS = os.environ.get('ALLOWED_HOSTS', '.herokuapp.com').split(',')
        
        # Database configuration
        DATABASES = {{
            'default': dj_database_url.config(
                default=os.environ.get('DATABASE_URL'),
                conn_max_age=600,
                conn_health_checks=True,
            )
        }}
        
        # Static files
        STATIC_ROOT = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'staticfiles')
        STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
        
        # HTTPS settings
        SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
        SECURE_SSL_REDIRECT = not DEBUG
        SESSION_COOKIE_SECURE = not DEBUG
        CSRF_COOKIE_SECURE = not DEBUG
        
        # HSTS settings
        SECURE_HSTS_SECONDS = 31536000 if not DEBUG else 0
        SECURE_HSTS_INCLUDE_SUBDOMAINS = not DEBUG
        SECURE_HSTS_PRELOAD = not DEBUG
        
        # Logging
        LOGGING = {{
            'version': 1,
            'disable_existing_loggers': False,
            'handlers': {{
                'console': {{
                    'class': 'logging.StreamHandler',
                }},
            }},
            'loggers': {{
                'django': {{
                    'handlers': ['console'],
                    'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
                }},
            }},
        }}
    """))
    
    # README
    write_file(heroku_dir / "README.md", textwrap.dedent(f"""
        # Heroku Deployment
        
        ## Quick Deployment
        
        ```bash
        # Make script executable
        chmod +x deploy/heroku/deploy.sh
        
        # Run deployment
        ./deploy/heroku/deploy.sh
        ```
        
        ## Manual Deployment
        
        1. **Install Heroku CLI:**
        ```bash
        # macOS
        brew tap heroku/brew && brew install heroku
        
        # Ubuntu
        curl https://cli-assets.heroku.com/install.sh | sh
        
        # Windows: Download from https://devcenter.heroku.com/articles/heroku-cli
        ```
        
        2. **Login to Heroku:**
        ```bash
        heroku login
        ```
        
        3. **Create Heroku app:**
        ```bash
        heroku create {project_name}-unique-name
        ```
        
        4. **Add buildpacks:**
        ```bash
        heroku buildpacks:add heroku/python
        heroku buildpacks:add heroku/nodejs
        ```
        
        5. **Add PostgreSQL:**
        ```bash
        heroku addons:create heroku-postgresql:hobby-dev
        ```
        
        6. **Configure environment:**
        ```bash
        heroku config:set SECRET_KEY=$(openssl rand -hex 32)
        heroku config:set DEBUG=False
        heroku config:set ALLOWED_HOSTS=.herokuapp.com
        heroku config:set DJANGO_SETTINGS_MODULE={project_name}.settings
        ```
        
        7. **Deploy:**
        ```bash
        git push heroku main
        
        # Run migrations
        heroku run python manage.py migrate
        
        # Create superuser
        heroku run python manage.py createsuperuser
        
        # Open app
        heroku open
        ```
        
        ## Database Management
        
        Access PostgreSQL console:
        ```bash
        heroku pg:psql
        ```
        
        Backup database:
        ```bash
        heroku pg:backups:capture
        heroku pg:backups:download
        ```
        
        ## Monitoring
        
        View logs:
        ```bash
        heroku logs --tail
        ```
        
        Monitor dynos:
        ```bash
        heroku ps
        ```
        
        View metrics:
        ```bash
        heroku metrics
        ```
        
        ## Scaling
        
        Scale web dynos:
        ```bash
        heroku ps:scale web=2
        ```
        
        Enable auto-scaling:
        ```bash
        heroku features:enable autoscaling
        heroku autoscaling:set web --min=1 --max=3 --p95-response-time=2000
        ```
        
        ## Custom Domains
        
        Add custom domain:
        ```bash
        heroku domains:add www.example.com
        ```
        
        Configure SSL:
        ```bash
        heroku certs:auto:enable
        ```
    """))


def generate_digitalocean_config(base, project_name):
    """Generate DigitalOcean App Platform configurations"""
    do_dir = base / "deploy" / "digitalocean"
    do_dir.mkdir(parents=True, exist_ok=True)
    
    # DigitalOcean App Platform spec
    write_file(do_dir / "do-app-spec.yaml", textwrap.dedent(f"""
        name: {project_name}
        region: nyc
        services:
        - name: web
          github:
            branch: main
            deploy_on_push: true
            repo: YOUR_GITHUB_USER/YOUR_REPO_NAME
          dockerfile_path: Dockerfile.do
          instance_count: 1
          instance_size_slug: basic-xxs
          http_port: 8000
          health_check:
            http_path: /api/v1/health/
            initial_delay_seconds: 10
            period_seconds: 10
            timeout_seconds: 5
            success_threshold: 1
            failure_threshold: 3
          envs:
          - key: SECRET_KEY
            scope: RUN_TIME
            value: $(openssl rand -hex 32)
          - key: DEBUG
            scope: RUN_TIME
            value: "False"
          - key: ALLOWED_HOSTS
            scope: RUN_TIME
            value: ".ondigitalocean.app"
          - key: DATABASE_URL
            scope: RUN_TIME
            type: SECRET
            value: do-db-url
        
        databases:
        - name: {project_name}-db
          engine: PG
          version: "15"
          production: false
          cluster_name: {project_name}-cluster
          db_name: {project_name}
          db_user: django
        
        envs:
        - key: DATABASE_URL
          scope: RUN_AND_BUILD_TIME
          type: SECRET
          value: do-db-url
    """))
    
    # DigitalOcean Dockerfile
    write_file(base / "Dockerfile.do", textwrap.dedent(f"""
        FROM python:3.11-slim
        
        # Install Node.js for frontend build
        RUN apt-get update && apt-get install -y curl gnupg
        RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash -
        RUN apt-get install -y nodejs build-essential
        
        WORKDIR /app
        
        # Install Python dependencies
        COPY requirements.txt .
        RUN pip install --upgrade pip && pip install -r requirements.txt
        
        # Copy and build frontend
        COPY frontend/ ./frontend/
        WORKDIR /app/frontend
        RUN npm install && npm run build
        WORKDIR /app
        
        # Copy application code
        COPY . .
        
        # Collect static files
        RUN python manage.py collectstatic --noinput
        
        # Run migrations (will be run via deploy hook)
        # RUN python manage.py migrate --noinput
        
        # Expose port
        EXPOSE 8000
        
        # Start application
        CMD ["gunicorn", "{project_name}.wsgi:application", "--bind", "0.0.0.0:8000"]
    """))
    
    # Deployment script
    write_file(do_dir / "deploy.sh", textwrap.dedent(f"""#!/bin/bash
        
        # DigitalOcean App Platform Deployment
        
        set -e
        
        echo "🔧 Setting up DigitalOcean deployment..."
        
        # Check if doctl is installed
        if ! command -v doctl &> /dev/null; then
            echo "❌ DigitalOcean CLI not found. Please install: https://docs.digitalocean.com/reference/doctl/how-to/install/"
            exit 1
        fi
        
        # Authenticate with DigitalOcean
        echo "🔐 Authenticating with DigitalOcean..."
        doctl auth init
        
        # Create App Platform app from spec
        echo "🚀 Creating DigitalOcean App..."
        doctl apps create --spec deploy/digitalocean/do-app-spec.yaml
        
        # Get app ID
        APP_ID=$(doctl apps list --format ID --no-header | head -n1)
        
        # Deploy
        echo "📦 Deploying application..."
        doctl apps create-deployment $APP_ID
        
        # Wait for deployment
        echo "⏳ Waiting for deployment to complete..."
        sleep 30
        
        # Get app URL
        APP_URL=$(doctl apps get $APP_ID --format "Live URL" --no-header)
        
        echo "✅ Deployment complete!"
        echo "🌐 Your app is running at: $APP_URL"
        echo ""
        echo "📋 Next steps:"
        echo "1. Set up custom domain in DigitalOcean dashboard"
        echo "2. Configure SSL/TLS certificates"
        echo "3. Set up monitoring and alerts"
    """))
    os.chmod(do_dir / "deploy.sh", 0o755)
    
    # One-click deploy button markdown
    write_file(do_dir / "deploy-button.md", textwrap.dedent(f"""
        [![Deploy to DigitalOcean](https://www.deploytodo.com/do-btn-blue.svg)](https://cloud.digitalocean.com/apps/new?repo=https://github.com/YOUR_USERNAME/{project_name}/tree/main&refcode=YOUR_REFCODE)
        
        ## One-Click Deployment
        
        1. Click the "Deploy to DigitalOcean" button above
        2. Connect your GitHub repository
        3. Configure environment variables:
           - `SECRET_KEY`: Generate a secure key
           - `DEBUG`: Set to `False`
           - `ALLOWED_HOSTS`: Set to `.ondigitalocean.app`
        4. Select region and plan
        5. Click "Launch App"
    """))
    
    # Manual deployment guide
    write_file(do_dir / "manual-deploy.md", textwrap.dedent(f"""
        # Manual DigitalOcean Deployment
        
        ## Option 1: App Platform (Recommended)
        
        1. **Push code to GitHub:**
        ```bash
        git init
        git add .
        git commit -m "Initial commit"
        git branch -M main
        git remote add origin https://github.com/YOUR_USERNAME/{project_name}.git
        git push -u origin main
        ```
        
        2. **Create DigitalOcean App:**
           - Go to DigitalOcean Control Panel
           - Click "Create" → "Apps"
           - Connect your GitHub account
           - Select your repository
        
        3. **Configure app:**
           - **Name:** {project_name}
           - **Region:** Choose closest region
           - **Environment Variables:**
             - `SECRET_KEY`: $(openssl rand -hex 32)
             - `DEBUG`: False
             - `ALLOWED_HOSTS`: .ondigitalocean.app
        
        4. **Add PostgreSQL Database:**
           - Click "Add Resource" → "Database"
           - Choose PostgreSQL
           - Select plan (Starter $15/mo recommended)
        
        5. **Launch:**
           - Click "Launch App"
           - Wait for deployment to complete
        
        ## Option 2: Droplet (VM)
        
        1. **Create Droplet:**
           - Ubuntu 22.04 LTS
           - At least 2GB RAM
           - 50GB SSD
        
        2. **SSH into Droplet:**
        ```bash
        ssh root@your_droplet_ip
        
        # Update system
        apt update && apt upgrade -y
        
        # Install dependencies
        apt install -y python3-pip python3-venv nodejs npm postgresql postgresql-contrib nginx
        
        # Install and configure PostgreSQL
        sudo -u postgres psql -c "CREATE DATABASE {project_name};"
        sudo -u postgres psql -c "CREATE USER django WITH PASSWORD 'secure_password';"
        sudo -u postgres psql -c "ALTER ROLE django SET client_encoding TO 'utf8';"
        sudo -u postgres psql -c "ALTER ROLE django SET default_transaction_isolation TO 'read committed';"
        sudo -u postgres psql -c "ALTER ROLE django SET timezone TO 'UTC';"
        sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE {project_name} TO django;"
        ```
        
        3. **Deploy application:**
        ```bash
        # Clone repository
        git clone https://github.com/YOUR_USERNAME/{project_name}.git
        cd {project_name}
        
        # Setup virtual environment
        python3 -m venv venv
        source venv/bin/activate
        
        # Install dependencies
        pip install -r requirements.txt
        
        # Build frontend
        cd frontend
        npm install
        npm run build
        cd ..
        
        # Configure environment
        echo "SECRET_KEY=$(openssl rand -hex 32)" > .env
        echo "DEBUG=False" >> .env
        echo "ALLOWED_HOSTS=your_domain.com" >> .env
        echo "DATABASE_URL=postgres://django:secure_password@localhost/{project_name}" >> .env
        
        # Run migrations
        python manage.py migrate
        python manage.py collectstatic --noinput
        
        # Setup Gunicorn service
        sudo cp deploy/digitalocean/gunicorn.service /etc/systemd/system/gunicorn-{project_name}.service
        sudo systemctl daemon-reload
        sudo systemctl start gunicorn-{project_name}
        sudo systemctl enable gunicorn-{project_name}
        
        # Setup Nginx
        sudo cp deploy/digitalocean/nginx.conf /etc/nginx/sites-available/{project_name}
        sudo ln -s /etc/nginx/sites-available/{project_name} /etc/nginx/sites-enabled/
        sudo nginx -t
        sudo systemctl restart nginx
        ```
        
        ## Option 3: Kubernetes
        
        See `deploy/digitalocean/kubernetes/` for Kubernetes manifests.
    """))
    
    # Gunicorn systemd service
    write_file(do_dir / "gunicorn.service", textwrap.dedent(f"""
        [Unit]
        Description=gunicorn daemon for {project_name}
        After=network.target postgresql.service
        
        [Service]
        User=www-data
        Group=www-data
        WorkingDirectory=/var/www/{project_name}
        ExecStart=/var/www/{project_name}/venv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/var/www/{project_name}/{project_name}.sock {project_name}.wsgi:application
        
        [Install]
        WantedBy=multi-user.target
    """))
    
    # Nginx configuration
    write_file(do_dir / "nginx.conf", textwrap.dedent(f"""
        server {{
            listen 80;
            server_name your_domain.com www.your_domain.com;
            
            location = /favicon.ico {{ access_log off; log_not_found off; }}
            
            location /static/ {{
                root /var/www/{project_name};
            }}
            
            location /media/ {{
                root /var/www/{project_name};
            }}
            
            location / {{
                include proxy_params;
                proxy_pass http://unix:/var/www/{project_name}/{project_name}.sock;
                proxy_set_header X-Forwarded-Proto $scheme;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header Host $http_host;
                proxy_redirect off;
            }}
            
            client_max_body_size 100M;
        }}
    """))
    
    # README
    write_file(do_dir / "README.md", textwrap.dedent(f"""
        # DigitalOcean Deployment
        
        ## Deployment Options
        
        ### Option 1: App Platform (Easiest)
        
        ```bash
        chmod +x deploy/digitalocean/deploy.sh
        ./deploy/digitalocean/deploy.sh
        ```
        
        Or use the one-click deploy button in `deploy/digitalocean/deploy-button.md`
        
        ### Option 2: Droplet (VM)
        
        See `deploy/digitalocean/manual-deploy.md` for complete instructions.
        
        ### Option 3: Kubernetes
        
        For production workloads, use DigitalOcean Kubernetes.
        
        ## Environment Variables
        
        Required for production:
        
        ```bash
        SECRET_KEY=your-secure-secret-key
        DEBUG=False
        ALLOWED_HOSTS=.ondigitalocean.app,yourdomain.com
        DATABASE_URL=postgres://username:password@host:port/database
        ```
        
        ## Database
        
        DigitalOcean Managed Databases offer:
        - Automated backups
        - Read replicas
        - Connection pooling
        - Monitoring
        
        ## Monitoring
        
        DigitalOcean provides:
        - Built-in metrics and alerts
        - Log forwarding to Logtail
        - Uptime monitoring
        - Cost analysis
        
        ## Scaling
        
        ### Vertical Scaling (App Platform):
        - Upgrade instance size
        
        ### Horizontal Scaling (App Platform):
        - Increase instance count
        
        ### Auto-scaling (Kubernetes):
        - Configure HPA based on CPU/memory
        
        ## Backup
        
        1. Database backups: Automated with Managed Databases
        2. Application backups: Use DigitalOcean Spaces + backup scripts
        3. Regular snapshots: For Droplet deployments
    """))


def generate_cpanel_config(base, project_name):
    """Generate cPanel deployment configurations"""
    cpanel_dir = base / "deploy" / "cpanel"
    cpanel_dir.mkdir(parents=True, exist_ok=True)
    
    # cPanel .htaccess for Python apps
    write_file(cpanel_dir / ".htaccess", textwrap.dedent(f"""
        # cPanel Python Configuration
        Options +ExecCGI
        AddHandler fcgid-script .fcgi
        
        RewriteEngine On
        RewriteCond %{{REQUEST_FILENAME}} !-f
        RewriteRule ^(.*)$ {project_name}.fcgi/$1 [QSA,L]
        
        # Security headers
        Header always set X-Content-Type-Options "nosniff"
        Header always set X-Frame-Options "SAMEORIGIN"
        Header always set X-XSS-Protection "1; mode=block"
        
        # CORS headers for API
        Header set Access-Control-Allow-Origin "*"
        Header set Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS"
        Header set Access-Control-Allow-Headers "Content-Type, Authorization"
        
        # Cache static files
        <FilesMatch "\.(css|js|jpg|jpeg|png|gif|ico|svg|woff|woff2|ttf|eot)$">
            Header set Cache-Control "max-age=31536000, public"
        </FilesMatch>
    """))
    
    # cPanel passenger_wsgi.py
    write_file(cpanel_dir / "passenger_wsgi.py", textwrap.dedent(f"""
        # cPanel Passenger WSGI configuration
        import os
        import sys
        
        # Add your project to the path
        sys.path.insert(0, os.path.dirname(__file__))
        
        # Set environment variables
        os.environ['DJANGO_SETTINGS_MODULE'] = '{project_name}.settings'
        os.environ['PYTHONPATH'] = os.path.dirname(__file__)
        
        # Import Django application
        from django.core.wsgi import get_wsgi_application
        application = get_wsgi_application()
    """))
    
    # cPanel setup script
    write_file(cpanel_dir / "setup.sh", textwrap.dedent(f"""#!/bin/bash
        
        # cPanel Deployment Setup
        
        set -e
        
        echo "🔧 Setting up cPanel deployment..."
        
        # Check if we're in a cPanel environment
        if [ ! -d "/usr/local/cpanel" ]; then
            echo "⚠️  This script is designed for cPanel environments."
            echo "   Some features may not work outside cPanel."
        fi
        
        # Create virtual environment
        echo "🐍 Creating Python virtual environment..."
        python3 -m venv venv
        source venv/bin/activate
        
        # Install dependencies
        echo "📦 Installing Python dependencies..."
        pip install --upgrade pip
        pip install -r requirements.txt
        
        # Build frontend
        echo "🏗️ Building frontend..."
        cd frontend
        npm install
        npm run build
        cd ..
        
        # Configure environment
        echo "⚙️ Setting up environment..."
        cat > .env << EOF
        SECRET_KEY=$(openssl rand -hex 32)
        DEBUG=False
        ALLOWED_HOSTS=yourdomain.com,www.yourdomain.com
        DATABASE_URL=mysql://username:password@localhost/database_name
        EOF
        
        # Setup database
        echo "💾 Setting up database..."
        echo ""
        echo "📋 Manual steps required for database:"
        echo "1. Login to cPanel"
        echo "2. Go to MySQL Databases"
        echo "3. Create new database: {project_name}_db"
        echo "4. Create user and assign to database"
        echo "5. Import database schema if needed"
        echo ""
        
        # Run migrations
        echo "🔄 Running migrations..."
        python manage.py migrate
        
        # Collect static files
        echo "📁 Collecting static files..."
        python manage.py collectstatic --noinput
        
        # Create .htaccess
        echo "🔧 Configuring .htaccess..."
        cp deploy/cpanel/.htaccess .
        
        # Create passenger_wsgi.py
        echo "🚀 Setting up Passenger WSGI..."
        cp deploy/cpanel/passenger_wsgi.py .
        
        # Set permissions
        echo "🔐 Setting file permissions..."
        chmod 755 passenger_wsgi.py
        find . -type f -name "*.py" -exec chmod 644 {{}} \;
        find . -type f -name "*.js" -exec chmod 644 {{}} \;
        find . -type f -name "*.css" -exec chmod 644 {{}} \;
        
        echo ""
        echo "✅ Setup complete!"
        echo ""
        echo "📋 Next steps in cPanel:"
        echo "1. Go to 'Setup Python App'"
        echo "2. Select Python 3.11"
        echo "3. Set application root to your domain's public_html"
        echo "4. Set startup file to: passenger_wsgi.py"
        echo "5. Click 'Run'"
        echo "6. Restart application"
        echo ""
        echo "🌐 Your app will be available at: http://yourdomain.com"
    """))
    os.chmod(cpanel_dir / "setup.sh", 0o755)
    
    # cPanel manual deployment guide
    write_file(cpanel_dir / "manual-guide.md", textwrap.dedent(f"""
        # cPanel Deployment Guide
        
        ## Prerequisites
        
        1. cPanel hosting with Python support
        2. SSH access (recommended)
        3. MySQL/MariaDB database
        4. Node.js support (for frontend build)
        
        ## Deployment Steps
        
        ### Step 1: Upload Files
        
        #### Option A: Git (Recommended)
        ```bash
        # SSH into your cPanel account
        ssh username@yourdomain.com
        
        # Clone repository
        git clone https://github.com/YOUR_USERNAME/{project_name}.git
        cd {project_name}
        ```
        
        #### Option B: File Manager
        1. Login to cPanel
        2. Go to File Manager
        3. Upload all project files to `public_html`
        
        ### Step 2: Setup Python Application
        
        1. In cPanel, search for "Setup Python App"
        2. Click "Setup Python App"
        3. Configure:
           - **Python version:** 3.11 (or highest available)
           - **Application root:** /home/username/public_html
           - **Application URL:** http://yourdomain.com
           - **Application startup file:** passenger_wsgi.py
           - **Application Entry point:** application
        4. Click "Create"
        
        ### Step 3: Database Setup
        
        1. In cPanel, go to "MySQL Databases"
        2. Create new database: `{project_name}_db`
        3. Create user and assign to database
        4. Note database credentials
        
        ### Step 4: Environment Configuration
        
        Create `.env` file in your application root:
        ```bash
        SECRET_KEY=your-generated-secret-key
        DEBUG=False
        ALLOWED_HOSTS=yourdomain.com,www.yourdomain.com
        DATABASE_URL=mysql://username:password@localhost/{project_name}_db
        ```
        
        ### Step 5: Build and Install
        
        ```bash
        # SSH into your account
        cd ~/public_html
        
        # Create virtual environment
        python3 -m venv venv
        source venv/bin/activate
        
        # Install dependencies
        pip install -r requirements.txt
        
        # Build frontend
        cd frontend
        npm install
        npm run build
        cd ..
        
        # Run migrations
        python manage.py migrate
        
        # Collect static files
        python manage.py collectstatic --noinput
        
        # Create superuser
        python manage.py createsuperuser
        ```
        
        ### Step 6: Configure Application
        
        1. Copy configuration files:
        ```bash
        cp deploy/cpanel/.htaccess .
        cp deploy/cpanel/passenger_wsgi.py .
        chmod 755 passenger_wsgi.py
        ```
        
        2. Restart application in cPanel Python App manager
        
        ## Troubleshooting
        
        ### Application not loading
        1. Check error logs in cPanel
        2. Verify Python version matches
        3. Check file permissions
        
        ### Database connection errors
        1. Verify database credentials
        2. Check MySQL user privileges
        3. Ensure database exists
        
        ### Static files not loading
        1. Check .htaccess configuration
        2. Verify static files collected
        3. Check file permissions
        
        ## Performance Tips
        
        1. **Enable caching:** Use cPanel's caching features
        2. **Optimize database:** Regular maintenance
        3. **CDN for static files:** Use Cloudflare
        4. **Gzip compression:** Enable in .htaccess
        5. **Database indexing:** Optimize queries
        
        ## Security
        
        1. **Keep software updated:** Regularly update Python packages
        2. **Secure .env file:** Set permissions to 600
        3. **Disable debug mode:** Always set DEBUG=False in production
        4. **Use HTTPS:** Enable SSL in cPanel
        5. **Regular backups:** Use cPanel backup feature
        
        ## Monitoring
        
        1. **Error logs:** Check in cPanel → Error Log
        2. **Bandwidth usage:** Monitor in cPanel → Bandwidth
        3. **Database usage:** Check in phpMyAdmin
        4. **CPU usage:** Monitor in cPanel → Resource Usage
    """))
    
    # MySQL configuration for Django
    write_file(cpanel_dir / "mysql_config.py", textwrap.dedent(f"""
        # MySQL configuration for cPanel
        DATABASES = {{
            'default': {{
                'ENGINE': 'django.db.backends.mysql',
                'NAME': '{project_name}_db',
                'USER': 'cpanel_username_{project_name}',
                'PASSWORD': 'your_password',
                'HOST': 'localhost',
                'PORT': '3306',
                'OPTIONS': {{
                    'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
                    'charset': 'utf8mb4',
                }},
            }}
        }}
    """))
    
    # README
    write_file(cpanel_dir / "README.md", textwrap.dedent(f"""
        # cPanel Deployment
        
        ## Quick Setup
        
        ```bash
        # SSH into your cPanel account
        ssh username@yourdomain.com
        
        # Clone and setup
        git clone https://github.com/YOUR_USERNAME/{project_name}.git
        cd {project_name}
        
        # Run setup script
        chmod +x deploy/cpanel/setup.sh
        ./deploy/cpanel/setup.sh
        ```
        
        ## Manual Setup
        
        See `deploy/cpanel/manual-guide.md` for complete step-by-step instructions.
        
        ## cPanel Specific Configuration
        
        ### Python Version
        - cPanel typically supports Python 3.6-3.11
        - Use "Setup Python App" in cPanel to select version
        
        ### Database
        - MySQL/MariaDB is standard in cPanel
        - Create database and user in cPanel → MySQL Databases
        - Use `deploy/cpanel/mysql_config.py` for database settings
        
        ### Static Files
        - Static files served from `public_html/staticfiles/`
        - Configured in `.htaccess` for caching
        - Use `python manage.py collectstatic` to gather files
        
        ### Email Configuration
        - Use cPanel's email for Django email backend
        - Configure in settings.py:
        ```python
        EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
        EMAIL_HOST = 'localhost'
        EMAIL_PORT = 25
        EMAIL_USE_TLS = False
        ```
        
        ## Common Issues
        
        ### 1. Permission Denied
        ```bash
        # Fix permissions
        find . -type d -exec chmod 755 {{}} \;
        find . -type f -exec chmod 644 {{}} \;
        chmod 755 passenger_wsgi.py
        ```
        
        ### 2. Module Not Found
        - Check Python version in cPanel matches virtual environment
        - Ensure all packages are installed in venv
        
        ### 3. Database Connection Failed
        - Verify database credentials
        - Check user has correct privileges
        - Ensure database exists
        
        ## Optimization
        
        1. **Enable caching:** Use cPanel's caching
        2. **Database indexing:** Optimize queries
        3. **CDN:** Use Cloudflare for static assets
        4. **Gzip:** Enable compression in .htaccess
        
        ## Backup
        
        1. **Database:** Use cPanel → Backup for SQL dumps
        2. **Files:** Use cPanel → Backup Wizard
        3. **Automated:** Schedule backups in cPanel
    """))


def generate_pythonanywhere_config(base, project_name):
    """Generate PythonAnywhere deployment configurations"""
    pa_dir = base / "deploy" / "pythonanywhere"
    pa_dir.mkdir(parents=True, exist_ok=True)
    
    # PythonAnywhere WSGI configuration
    write_file(pa_dir / "pythonanywhere_wsgi.py", textwrap.dedent(f"""
        # PythonAnywhere WSGI configuration
        import os
        import sys
        
        # Add your project to the Python path
        path = '/home/your_username/{project_name}'
        if path not in sys.path:
            sys.path.append(path)
        
        # Set environment variables
        os.environ['DJANGO_SETTINGS_MODULE'] = '{project_name}.settings'
        
        # Activate virtual environment
        activate_this = '/home/your_username/{project_name}/venv/bin/activate_this.py'
        with open(activate_this) as file_:
            exec(file_.read(), {{'__file__': activate_this}})
        
        # Import Django application
        from django.core.wsgi import get_wsgi_application
        application = get_wsgi_application()
    """))
    
    # PythonAnywhere setup script
    write_file(pa_dir / "setup.sh", textwrap.dedent(f"""#!/bin/bash
        
        # PythonAnywhere Deployment Setup
        
        set -e
        
        echo "🔧 Setting up PythonAnywhere deployment..."
        
        # Check if we're in PythonAnywhere
        if [ ! -d "/home" ]; then
            echo "⚠️  This script is designed for PythonAnywhere."
            echo "   Run this on your PythonAnywhere account via SSH."
        fi
        
        echo ""
        echo "📋 PythonAnywhere Deployment Instructions:"
        echo ""
        echo "1. Open PythonAnywhere dashboard"
        echo "2. Go to 'Consoles' and start a new bash console"
        echo "3. Clone your repository:"
        echo "   git clone https://github.com/YOUR_USERNAME/{project_name}.git"
        echo "   cd {project_name}"
        echo ""
        echo "4. Create virtual environment:"
        echo "   python3 -m venv venv"
        echo "   source venv/bin/activate"
        echo ""
        echo "5. Install dependencies:"
        echo "   pip install --upgrade pip"
        echo "   pip install -r requirements.txt"
        echo ""
        echo "6. Build frontend:"
        echo "   cd frontend"
        echo "   npm install"
        echo "   npm run build"
        echo "   cd .."
        echo ""
        echo "7. Configure environment:"
        echo "   cat > .env << EOF"
        echo "   SECRET_KEY=$(openssl rand -hex 32)"
        echo "   DEBUG=False"
        echo "   ALLOWED_HOSTS=yourusername.pythonanywhere.com"
        echo "   DATABASE_URL=sqlite:///db.sqlite3"
        echo "   EOF"
        echo ""
        echo "8. Run migrations:"
        echo "   python manage.py migrate"
        echo ""
        echo "9. Collect static files:"
        echo "   python manage.py collectstatic --noinput"
        echo ""
        echo "10. Create superuser:"
        echo "    python manage.py createsuperuser"
        echo ""
        echo "11. Web app setup:"
        echo "    - Go to 'Web' tab in PythonAnywhere"
        echo "    - Click 'Add a new web app'"
        echo "    - Choose 'Manual configuration'"
        echo "    - Select Python 3.11"
        echo "    - Set virtualenv to: /home/your_username/{project_name}/venv"
        echo "    - Set working directory to: /home/your_username/{project_name}"
        echo "    - Set WSGI file to: /home/your_username/{project_name}/deploy/pythonanywhere/pythonanywhere_wsgi.py"
        echo ""
        echo "12. Configure static files:"
        echo "    - In Web tab, go to 'Static files'"
        echo "    - Add mapping:"
        echo "      URL: /static/"
        echo "      Directory: /home/your_username/{project_name}/staticfiles"
        echo "    - Add another mapping:"
        echo "      URL: /media/"
        echo "      Directory: /home/your_username/{project_name}/media"
        echo ""
        echo "13. Reload web app"
        echo ""
        echo "✅ Setup complete! Your app will be available at:"
        echo "   https://yourusername.pythonanywhere.com"
    """))
    os.chmod(pa_dir / "setup.sh", 0o755)
    
    # PythonAnywhere database configuration
    write_file(pa_dir / "database_config.py", textwrap.dedent(f"""
        # PythonAnywhere Database Configuration
        
        import os
        
        # MySQL Configuration (Recommended for PythonAnywhere)
        DATABASES = {{
            'default': {{
                'ENGINE': 'django.db.backends.mysql',
                'NAME': 'yourusername${project_name}',
                'USER': 'yourusername',
                'PASSWORD': os.getenv('DB_PASSWORD', ''),
                'HOST': 'yourusername.mysql.pythonanywhere-services.com',
                'PORT': '3306',
                'OPTIONS': {{
                    'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
                    'charset': 'utf8mb4',
                }},
            }}
        }}
        
        # SQLite Configuration (For free accounts)
        # DATABASES = {{
        #     'default': {{
        #         'ENGINE': 'django.db.backends.sqlite3',
        #         'NAME': os.path.join(os.path.dirname(os.path.dirname(__file__)), 'db.sqlite3'),
        #     }}
        # }}
    """))
    
    # PythonAnywhere specific settings
    write_file(pa_dir / "pa_settings.py", textwrap.dedent(f"""
        # PythonAnywhere specific Django settings
        
        import os
        
        # Security settings for PythonAnywhere
        DEBUG = os.environ.get('DEBUG', 'False') == 'True'
        
        # Get PythonAnywhere domain
        PA_DOMAIN = os.environ.get('PA_DOMAIN', 'pythonanywhere.com')
        ALLOWED_HOSTS = [
            f'{{os.environ.get("PA_USERNAME", "yourusername")}}.{{PA_DOMAIN}}',
            f'www.{{os.environ.get("PA_USERNAME", "yourusername")}}.{{PA_DOMAIN}}',
        ]
        
        # Static files configuration for PythonAnywhere
        STATIC_URL = '/static/'
        STATIC_ROOT = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'staticfiles')
        
        # Media files
        MEDIA_URL = '/media/'
        MEDIA_ROOT = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'media')
        
        # HTTPS settings
        SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
        SECURE_SSL_REDIRECT = not DEBUG
        SESSION_COOKIE_SECURE = not DEBUG
        CSRF_COOKIE_SECURE = not DEBUG
        
        # Email configuration (PythonAnywhere SMTP)
        EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
        EMAIL_HOST = 'smtp.pythonanywhere.com'
        EMAIL_HOST_USER = os.environ.get('EMAIL_HOST_USER', '')
        EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_HOST_PASSWORD', '')
        EMAIL_PORT = 587
        EMAIL_USE_TLS = True
        DEFAULT_FROM_EMAIL = f'noreply@{{os.environ.get("PA_USERNAME", "yourusername")}}.{{PA_DOMAIN}}'
        
        # Logging configuration for PythonAnywhere
        LOGGING = {{
            'version': 1,
            'disable_existing_loggers': False,
            'handlers': {{
                'file': {{
                    'level': 'DEBUG',
                    'class': 'logging.FileHandler',
                    'filename': os.path.join(os.path.dirname(os.path.dirname(__file__)), 'django.log'),
                }},
                'console': {{
                    'class': 'logging.StreamHandler',
                }},
            }},
            'loggers': {{
                'django': {{
                    'handlers': ['file', 'console'],
                    'level': 'INFO',
                    'propagate': True,
                }},
            }},
        }}
    """))
    
    # PythonAnywhere deployment guide
    write_file(pa_dir / "deployment-guide.md", textwrap.dedent(f"""
        # PythonAnywhere Deployment Guide
        
        ## Account Types
        
        ### Free Account
        - 512 MB RAM
        - 1 CPU core
        - Limited storage
        - MySQL database only
        - No custom domains
        
        ### Paid Accounts
        - More resources
        - PostgreSQL available
        - Custom domains
        - SSH access
        
        ## Deployment Steps
        
        ### Step 1: Prepare Your Code
        
        1. Ensure all dependencies are in requirements.txt
        2. Build frontend locally: `npm run build`
        3. Test locally before deployment
        
        ### Step 2: Upload to PythonAnywhere
        
        #### Option A: Git (Recommended)
        ```bash
        # SSH into PythonAnywhere
        # Go to Consoles tab, start a bash console
        
        git clone https://github.com/YOUR_USERNAME/{project_name}.git
        cd {project_name}
        ```
        
        #### Option B: Upload files
        1. Go to Files tab
        2. Upload your project files
        3. Extract if necessary
        
        ### Step 3: Setup Virtual Environment
        
        ```bash
        # Create virtual environment
        python3 -m venv venv
        
        # Activate it
        source venv/bin/activate
        
        # Install dependencies
        pip install --upgrade pip
        pip install -r requirements.txt
        ```
        
        ### Step 4: Database Setup
        
        #### For Free Accounts (MySQL):
        1. Go to Databases tab
        2. Create MySQL database
        3. Note database name (username$dbname)
        
        #### For Paid Accounts (PostgreSQL):
        1. Request PostgreSQL in "Databases" tab
        2. Create database and user
        
        ### Step 5: Environment Variables
        
        Create `.env` file:
        ```bash
        SECRET_KEY=your-secure-secret-key
        DEBUG=False
        ALLOWED_HOSTS=yourusername.pythonanywhere.com
        DB_PASSWORD=your_mysql_password
        ```
        
        ### Step 6: Configure Web App
        
        1. Go to Web tab
        2. Click "Add a new web app"
        3. Choose "Manual configuration"
        4. Select Python version (3.11 recommended)
        5. Configure:
           - Virtualenv: /home/your_username/{project_name}/venv
           - Source code: /home/your_username/{project_name}
           - Working directory: /home/your_username/{project_name}
        
        ### Step 7: WSGI Configuration
        
        1. Click on WSGI configuration file link
        2. Replace contents with `deploy/pythonanywhere/pythonanywhere_wsgi.py`
        3. Update paths for your username
        
        ### Step 8: Static Files
        
        1. In Web tab, go to Static files section
        2. Add mapping:
           - URL: /static/
           - Directory: /home/your_username/{project_name}/staticfiles
        3. Add media mapping (if needed):
           - URL: /media/
           - Directory: /home/your_username/{project_name}/media
        
        ### Step 9: Initialize Application
        
        ```bash
        # Run in console
        cd {project_name}
        source venv/bin/activate
        
        # Run migrations
        python manage.py migrate
        
        # Collect static files
        python manage.py collectstatic --noinput
        
        # Create superuser
        python manage.py createsuperuser
        ```
        
        ### Step 10: Reload Web App
        
        1. Go back to Web tab
        2. Click green "Reload" button
        3. Your app is now live!
        
        ## Common Issues
        
        ### 1. Import Errors
        - Check virtual environment is activated
        - Verify all packages installed
        - Check Python version matches
        
        ### 2. Database Connection Failed
        - Verify database credentials
        - Check database exists
        - For MySQL: ensure user has privileges
        
        ### 3. Static Files Not Loading
        - Check static files mapping
        - Run collectstatic again
        - Check file permissions
        
        ### 4. Memory Limits (Free Accounts)
        - Optimize your application
        - Use fewer workers
        - Enable caching
        
        ## Optimization Tips
        
        1. **Enable caching:** Use Django's cache framework
        2. **Database indexing:** Optimize queries
        3. **Static files:** Use CDN if possible
        4. **Gunicorn workers:** Adjust based on memory
        5. **Regular maintenance:** Clear old logs, sessions
        
        ## Scheduled Tasks
        
        Use PythonAnywhere's "Tasks" tab for:
        - Database backups
        - Cache clearing
        - Email sending
        - Regular maintenance
        
        ## Backup
        
        1. **Database:** Export regularly via phpMyAdmin or console
        2. **Files:** Download via Files tab
        3. **Code:** Keep in GitHub for version control
        
        ## Monitoring
        
        1. **Error logs:** View in Web tab → Error logs
        2. **Access logs:** View in Web tab → Access logs
        3. **Resource usage:** Monitor in Account tab
    """))
    
    # README
    write_file(pa_dir / "README.md", textwrap.dedent(f"""
        # PythonAnywhere Deployment
        
        ## Quick Start
        
        ```bash
        # SSH into PythonAnywhere (or use console)
        # Clone your repository
        git clone https://github.com/YOUR_USERNAME/{project_name}.git
        cd {project_name}
        
        # Run setup instructions
        chmod +x deploy/pythonanywhere/setup.sh
        ./deploy/pythonanywhere/setup.sh
        ```
        
        Follow the on-screen instructions to complete setup.
        
        ## Detailed Guide
        
        See `deploy/pythonanywhere/deployment-guide.md` for complete step-by-step instructions.
        
        ## PythonAnywhere Specifics
        
        ### Virtual Environment
        - Must be named `venv` in your project root
        - Activate with `source venv/bin/activate`
        - PythonAnywhere will auto-detect it
        
        ### Database Options
        1. **MySQL:** Default for all accounts
        2. **PostgreSQL:** Available for paid accounts
        3. **SQLite:** Works but not recommended for production
        
        ### Static Files
        - Configure in Web tab → Static files
        - URL: `/static/`
        - Directory: `/home/your_username/{project_name}/staticfiles`
        
        ### Scheduled Tasks
        - Use for backups, maintenance, cron jobs
        - Configure in Tasks tab
        - Can run Python scripts, bash commands
        
        ## Troubleshooting
        
        ### Application Won't Start
        1. Check error logs in Web tab
        2. Verify WSGI configuration
        3. Check virtual environment
        
        ### Database Issues
        1. Verify credentials in `.env`
        2. Check database exists
        3. Test connection from console
        
        ### Static Files 404
        1. Run `python manage.py collectstatic`
        2. Check Static files mapping
        3. Verify file permissions
        
        ## Upgrading
        
        ### Update Code
        ```bash
        git pull origin main
        source venv/bin/activate
        pip install -r requirements.txt
        python manage.py migrate
        python manage.py collectstatic --noinput
        ```
        
        ### Reload Application
        - Go to Web tab
        - Click green Reload button
        
        ## Support
        
        - PythonAnywhere documentation: https://help.pythonanywhere.com/
        - Django on PythonAnywhere: https://help.pythonanywhere.com/pages/Django/
        - Community forums for help
    """))


def generate_deployment_configs(base, project_name):
    """Generate all deployment configurations"""
    print("\n" + "=" * 50)
    print("GENERATING DEPLOYMENT CONFIGURATIONS")
    print("=" * 50)
    
    # Create main deploy directory
    deploy_dir = base / "deploy"
    deploy_dir.mkdir(exist_ok=True)
    
    # Generate configurations for each platform
    print("🚀 Generating Google Cloud configurations...")
    generate_google_cloud_config(base, project_name)
    
    print("🚀 Generating AWS configurations...")
    generate_aws_config(base, project_name)
    
    print("🚀 Generating Heroku configurations...")
    generate_heroku_config(base, project_name)
    
    print("🚀 Generating DigitalOcean configurations...")
    generate_digitalocean_config(base, project_name)
    
    print("🚀 Generating cPanel configurations...")
    generate_cpanel_config(base, project_name)
    
    print("🚀 Generating PythonAnywhere configurations...")
    generate_pythonanywhere_config(base, project_name)
    
    # Generate main deployment README
    write_file(deploy_dir / "README.md", textwrap.dedent(f"""
        # Deployment Guide - {project_name}
        
        This project is configured for deployment on multiple platforms. Choose the one that best fits your needs.
        
        ## Platform Comparison
        
        | Platform | Difficulty | Cost | Best For |
        |----------|------------|------|----------|
        | **Heroku** | ⭐☆☆☆☆ (Easiest) | $$ (Free tier available) | Quick prototypes, small projects |
        | **PythonAnywhere** | ⭐⭐☆☆☆ (Easy) | $ (Free tier available) | Django-focused hosting, beginners |
        | **cPanel** | ⭐⭐⭐☆☆ (Medium) | $$ | Traditional web hosting users |
        | **DigitalOcean** | ⭐⭐⭐⭐☆ (Intermediate) | $$$ | Full control, production apps |
        | **Google Cloud** | ⭐⭐⭐⭐☆ (Intermediate) | $$$$ (Free credits) | Scalable enterprise apps |
        | **AWS** | ⭐⭐⭐⭐⭐ (Advanced) | $$$$ (Free tier) | Large-scale, complex applications |
        
        ## Quick Start Recommendations
        
        ### For Beginners
        - **Heroku:** Simplest deployment, good free tier
        - **PythonAnywhere:** Django-optimized, easy setup
        
        ### For Production
        - **DigitalOcean:** Great balance of control and simplicity
        - **Google Cloud Run:** Serverless, auto-scaling
        
        ### For Enterprise
        - **AWS ECS/EB:** Full AWS ecosystem integration
        - **Google Kubernetes Engine:** Large-scale orchestration
        
        ## Common Configuration
        
        All deployments require:
        
        1. **Environment Variables:**
        ```bash
        SECRET_KEY=your-secure-secret-key
        DEBUG=False
        ALLOWED_HOSTS=yourdomain.com,www.yourdomain.com
        DATABASE_URL=database://connection:string
        ```
        
        2. **Build Steps:**
        ```bash
        # Install dependencies
        pip install -r requirements.txt
        
        # Build frontend
        cd frontend
        npm install
        npm run build
        cd ..
        
        # Database setup
        python manage.py migrate
        
        # Collect static files
        python manage.py collectstatic --noinput
        ```
        
        3. **Security Checklist:**
        - [ ] Set DEBUG=False
        - [ ] Use strong SECRET_KEY
        - [ ] Configure ALLOWED_HOSTS
        - [ ] Enable HTTPS/SSL
        - [ ] Set up proper CORS headers
        - [ ] Configure database backups
        
        ## Platform-Specific Guides
        
        - [Google Cloud](google-cloud/README.md)
        - [AWS](aws/README.md)
        - [Heroku](heroku/README.md)
        - [DigitalOcean](digitalocean/README.md)
        - [cPanel](cpanel/README.md)
        - [PythonAnywhere](pythonanywhere/README.md)
        
        ## Monitoring & Maintenance
        
        ### Essential Monitoring
        1. **Application logs:** Error tracking
        2. **Performance metrics:** Response times, throughput
        3. **Resource usage:** CPU, memory, disk
        4. **Database performance:** Query times, connections
        
        ### Regular Maintenance
        1. **Weekly:** Backup verification
        2. **Monthly:** Dependency updates
        3. **Quarterly:** Security audit
        4. **Annually:** Architecture review
        
        ## Troubleshooting
        
        ### Common Issues
        
        1. **Application won't start:**
           - Check logs for errors
           - Verify environment variables
           - Test database connection
        
        2. **Static files not loading:**
           - Run collectstatic
           - Check static file configuration
           - Verify file permissions
        
        3. **Database connection failed:**
           - Verify credentials
           - Check network access
           - Test connection manually
        
        4. **High memory usage:**
           - Optimize database queries
           - Implement caching
           - Review worker processes
        
        ### Getting Help
        
        1. Check platform-specific documentation
        2. Review application logs
        3. Test locally first
        4. Seek community support
        
        ## Migration Between Platforms
        
        To migrate from one platform to another:
        
        1. **Backup current deployment:**
           ```bash
           # Backup database
           pg_dump database_name > backup.sql
           
           # Backup media files
           tar -czf media_backup.tar.gz media/
           ```
        
        2. **Set up new platform:** Follow platform guide
        
        3. **Restore data:**
           ```bash
           # Restore database
           psql database_name < backup.sql
           
           # Restore media
           tar -xzf media_backup.tar.gz
           ```
        
        4. **Update DNS:** Point domain to new platform
        
        5. **Test thoroughly:** Verify all functionality
        
        6. **Monitor:** Watch for issues after migration
        
        ## Cost Optimization
        
        ### Tips to Reduce Costs
        
        1. **Right-size resources:** Don't over-provision
        2. **Use auto-scaling:** Scale down during low traffic
        3. **Implement caching:** Reduce database load
        4. **Optimize assets:** Compress images, minify code
        5. **Use CDN:** Offload static file serving
        6. **Monitor spending:** Set up budget alerts
        
        ### Free Tier Options
        
        - **Heroku:** Free dyno (sleeps after 30 mins inactivity)
        - **PythonAnywhere:** Free account with limitations
        - **Google Cloud:** $300 free credit for new users
        - **AWS:** 12 months free tier for new accounts
        - **DigitalOcean:** $200 credit for new users (60 days)
    """))
    
    print("\n✅ All deployment configurations generated!")
    print(f"📁 Find them in: {deploy_dir}/")


# ------------------------
# Backend Generator (DRF) - Updated with deployment configs
# ------------------------
def create_backend(project, base):
    print("\n" + "=" * 50)
    print("CREATING DJANGO DRF BACKEND")
    print("=" * 50)

    os.chdir(base)  # critical for venv creation
    print(f"Backend folder created at: {base}")

    secret = generate_secret_key()
    SYSTEM_PYTHON = get_system_python()

    # Step 1: Create virtual environment
    run(f"{SYSTEM_PYTHON} -m venv venv")
    VENV_PYTHON = get_venv_python(base)

    # Step 2: Upgrade pip + install dependencies
    run(f"{VENV_PYTHON} -m pip install --upgrade pip")
    run(f"{VENV_PYTHON} -m pip install {' '.join(PROJECT_REQUIREMENTS)}")

    # Step 3: Create Django project
    run(f"{VENV_PYTHON} -m django startproject {project} .")

    # Step 4: Create API app
    run(f"{VENV_PYTHON} manage.py startapp {API_APP}")

    # Step 5: Write .env
    write_file(
        base / ".env",
        f"""
SECRET_KEY={secret}
DEBUG=True
ALLOWED_HOSTS=*
DATABASE_URL=sqlite:///db.sqlite3
""",
    )

    # Step 6: requirements.txt
    write_file(base / "requirements.txt", "\n".join(PROJECT_REQUIREMENTS))

    # Step 7: Enhanced settings.py with deployment-ready configuration
    settings_content = (
        f"""
from pathlib import Path
import os
from dotenv import load_dotenv
from datetime import timedelta
import dj_database_url

load_dotenv()
BASE_DIR = Path(__file__).resolve().parent.parent

# Security - Deployment Ready
SECRET_KEY = os.getenv("SECRET_KEY")
DEBUG = os.getenv("DEBUG") == "True"
ALLOWED_HOSTS = os.getenv("ALLOWED_HOSTS","*").split(",")

# Deployment security settings
if not DEBUG:
    SECURE_BROWSER_XSS_FILTER = True
    SECURE_CONTENT_TYPE_NOSNIFF = True
    SECURE_HSTS_SECONDS = 31536000  # 1 year
    SECURE_HSTS_INCLUDE_SUBDOMAINS = True
    SECURE_HSTS_PRELOAD = True
    SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
    SECURE_SSL_REDIRECT = True
    SESSION_COOKIE_SECURE = True
    CSRF_COOKIE_SECURE = True

INSTALLED_APPS = [
    "jet",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "corsheaders",
    "rest_framework",
    "drf_yasg",
    "{API_APP}",
]

MIDDLEWARE = [
    "corsheaders.middleware.CorsMiddleware",
    "django.middleware.security.SecurityMiddleware",
    "whitenoise.middleware.WhiteNoiseMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
]

# CORS Configuration - Deployment Ready
CORS_ALLOW_ALL_ORIGINS = DEBUG  # Only in development
if not DEBUG:
    CORS_ALLOWED_ORIGINS = os.getenv("CORS_ALLOWED_ORIGINS", "").split(",")
    CSRF_TRUSTED_ORIGINS = os.getenv("CSRF_TRUSTED_ORIGINS", "").split(",")

ROOT_URLCONF = "{project}.urls"

TEMPLATES = [{{
    "BACKEND": "django.template.backends.django.DjangoTemplates",
    "DIRS": [BASE_DIR / "frontend" / "dist"],
    "APP_DIRS": True,
    "OPTIONS": {{
        "context_processors": [
            "django.template.context_processors.debug",
            "django.template.context_processors.request",
            "django.contrib.auth.context_processors.auth",
            "django.contrib.messages.context_processors.messages",
        ],
    }},
}}]

WSGI_APPLICATION = "{project}.wsgi.application"

# Database Configuration - Deployment Ready
DATABASE_URL = os.getenv("DATABASE_URL")
if DATABASE_URL:
    # Use DATABASE_URL environment variable (for Heroku, Railway, etc.)
    DATABASES = {{
        "default": dj_database_url.config(
            default=DATABASE_URL,
            conn_max_age=600,
            conn_health_checks=True,
        )
    }}
else:
    # Fallback to SQLite for development
    DATABASES = {{
        "default": {{
            "ENGINE": "django.db.backends.sqlite3",
            "NAME": BASE_DIR / "db.sqlite3",
        }}
    }}
"""
        + "\n"
        + "# Database connection pool for production (optional)\n"
        + "# DATABASES['default']['CONN_MAX_AGE'] = 600  # 10 minutes\n"
        + "# DATABASES['default']['CONN_HEALTH_CHECKS'] = True\n"
        + f"""
# Password validation
AUTH_PASSWORD_VALIDATORS = [
    {{"NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator"}},
    {{"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator"}},
    {{"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator"}},
    {{"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator"}},
]

# Internationalization
LANGUAGE_CODE = "en-us"
TIME_ZONE = "UTC"
USE_I18N = True
USE_TZ = True

# Static files (WhiteNoise) - Deployment Ready
STATIC_URL = "/static/"
STATIC_ROOT = BASE_DIR / "staticfiles"
STATICFILES_DIRS = [
    BASE_DIR / "frontend" / "dist",
]

# WhiteNoise configuration for production
STATICFILES_STORAGE = "whitenoise.storage.CompressedManifestStaticFilesStorage"

# Media files
MEDIA_URL = "/media/"
MEDIA_ROOT = BASE_DIR / "media"

DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

# REST Framework Configuration
REST_FRAMEWORK = {{
    "DEFAULT_AUTHENTICATION_CLASSES": [
        "rest_framework_simplejwt.authentication.JWTAuthentication",
    ],
    "DEFAULT_PERMISSION_CLASSES": [
        "rest_framework.permissions.IsAuthenticatedOrReadOnly",
    ],
    "DEFAULT_THROTTLE_CLASSES": [
        "rest_framework.throttling.AnonRateThrottle",
        "rest_framework.throttling.UserRateThrottle"
    ],
    "DEFAULT_THROTTLE_RATES": {{
        "anon": "100/day",
        "user": "1000/day"
    }},
    "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
    "PAGE_SIZE": 20,
    "DEFAULT_RENDERER_CLASSES": [
        "rest_framework.renderers.JSONRenderer",
        "rest_framework.renderers.BrowsableAPIRenderer",  # Disable in production
    ],
}}

# JWT Configuration
SIMPLE_JWT = {{
    "ACCESS_TOKEN_LIFETIME": timedelta(minutes=15),
    "REFRESH_TOKEN_LIFETIME": timedelta(days=1),
    "ROTATE_REFRESH_TOKENS": True,
    "BLACKLIST_AFTER_ROTATION": True,
    "UPDATE_LAST_LOGIN": True,
    "AUTH_HEADER_TYPES": ("Bearer",),
}}

# Email Configuration (for production)
EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend" if not DEBUG else "django.core.mail.backends.console.EmailBackend"
EMAIL_HOST = os.getenv("EMAIL_HOST", "smtp.gmail.com")
EMAIL_PORT = int(os.getenv("EMAIL_PORT", 587))
EMAIL_USE_TLS = os.getenv("EMAIL_USE_TLS", "True") == "True"
EMAIL_HOST_USER = os.getenv("EMAIL_HOST_USER", "")
EMAIL_HOST_PASSWORD = os.getenv("EMAIL_HOST_PASSWORD", "")
DEFAULT_FROM_EMAIL = os.getenv("DEFAULT_FROM_EMAIL", "webmaster@localhost")

# Cache Configuration (for production)
if not DEBUG:
    CACHES = {{
        "default": {{
            "BACKEND": "django.core.cache.backends.redis.RedisCache",
            "LOCATION": os.getenv("REDIS_URL", "redis://127.0.0.1:6379/1"),
        }}
    }}
else:
    CACHES = {{
        "default": {{
            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
        }}
    }}

# Logging Configuration (for production)
LOGGING = {{
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {{
        "verbose": {{
            "format": "%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s"
        }},
        "simple": {{
            "format": "%(levelname)s %(message)s"
        }},
    }},
    "handlers": {{
        "console": {{
            "class": "logging.StreamHandler",
            "formatter": "simple",
        }},
        "file": {{
            "class": "logging.FileHandler",
            "filename": BASE_DIR / "logs/django.log",
            "formatter": "verbose",
        }},
    }},
    "loggers": {{
        "django": {{
            "handlers": ["console", "file"] if not DEBUG else ["console"],
            "level": "INFO",
        }},
        "{API_APP}": {{
            "handlers": ["console", "file"] if not DEBUG else ["console"],
            "level": "DEBUG",
            "propagate": True,
        }},
    }},
}}

# Create logs directory if it doesn't exist
os.makedirs(BASE_DIR / "logs", exist_ok=True)
"""
    )

    write_file(base / project / "settings.py", settings_content)

    # Step 8: Enhanced urls.py with deployment features
    write_file(
        base / project / "urls.py",
        f"""
from django.contrib import admin
from django.urls import path, include, re_path
from django.views.generic import TemplateView
from django.conf import settings
from django.conf.urls.static import static
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView
from drf_yasg.views import get_schema_view
from drf_yasg import openapi
from rest_framework import permissions

schema_view = get_schema_view(
    openapi.Info(
        title="{project} API",
        default_version="v1",
        description="Production-ready API documentation",
        terms_of_service="https://www.google.com/policies/terms/",
        contact=openapi.Contact(email="contact@yourdomain.com"),
        license=openapi.License(name="BSD License"),
    ),
    public=True,
    permission_classes=(permissions.AllowAny,),
)

# API URL patterns
api_patterns = [
    path("v1/", include("{API_APP}.urls")),
    path("auth/token/", TokenObtainPairView.as_view(), name="token_obtain_pair"),
    path("auth/token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
]

# Documentation URL patterns
docs_patterns = [
    path("swagger/", schema_view.with_ui("swagger", cache_timeout=0), name="schema-swagger-ui"),
    path("redoc/", schema_view.with_ui("redoc", cache_timeout=0), name="schema-redoc"),
    path("swagger.json", schema_view.without_ui(cache_timeout=0), name="schema-json"),
]

urlpatterns = [
    path("jet/", include("jet.urls", "jet")),
    path("admin/", admin.site.urls),
    path("api/", include(api_patterns)),
] + docs_patterns

# Serve static and media files in development
if settings.DEBUG:
    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

# Serve frontend for all other routes (SPA routing)
urlpatterns += [
    re_path(r"^.*$", TemplateView.as_view(template_name="index.html")),
]
""",
    )

    # Step 9: Enhanced API app with deployment-ready features
    write_file(
        base / API_APP / "urls.py",
        """
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import HealthView, UserViewSet

router = DefaultRouter()
router.register(r'users', UserViewSet, basename='user')

urlpatterns = [
    path("", include(router.urls)),
    path("health/", HealthView.as_view(), name="health"),
]
""",
    )

    write_file(
        base / API_APP / "views.py",
        """
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import AllowAny, IsAuthenticated
from rest_framework import viewsets, status
from rest_framework.decorators import action
from django.contrib.auth.models import User
from .serializers import UserSerializer
import logging

logger = logging.getLogger(__name__)

class HealthView(APIView):
    permission_classes = [AllowAny]

    def get(self, request):
        logger.info("Health check requested")
        return Response({
            "status": "healthy",
            "service": "api",
            "timestamp": timezone.now().isoformat(),
        })

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [IsAuthenticated]

    @action(detail=False, methods=['get'])
    def me(self, request):
        serializer = self.get_serializer(request.user)
        return Response(serializer.data)

    def get_queryset(self):
        # Only allow users to see themselves unless admin
        user = self.request.user
        if user.is_superuser:
            return User.objects.all()
        return User.objects.filter(id=user.id)

    def perform_create(self, serializer):
        # Log user creation
        user = serializer.save()
        logger.info(f"User created: {user.username}")
""",
    )

    write_file(
        base / API_APP / "serializers.py",
        """
from rest_framework import serializers
from django.contrib.auth.models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name', 'is_staff', 'is_active']
        read_only_fields = ['is_staff', 'is_active']

    def create(self, validated_data):
        user = User.objects.create_user(
            username=validated_data['username'],
            email=validated_data.get('email', ''),
            password=validated_data.get('password', ''),
            first_name=validated_data.get('first_name', ''),
            last_name=validated_data.get('last_name', '')
        )
        return user
""",
    )

    # Step 10: Enhanced deployment files
    write_file(
        base / "Dockerfile",
        f"""
# Multi-stage Docker build for production
FROM node:18-alpine as frontend-builder

WORKDIR /app/frontend

# Copy frontend files
COPY frontend/package*.json ./
RUN npm ci --only=production

COPY frontend/ .
RUN npm run build

# Python backend
FROM python:3.11-slim

# Install system dependencies
RUN apt-get update && apt-get install -y \
    gcc \
    g++ \
    libpq-dev \
    curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Create non-root user
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# Copy requirements and install Python dependencies
COPY --chown=appuser:appuser requirements.txt .
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir -r requirements.txt

# Copy backend code
COPY --chown=appuser:appuser . .

# Copy built frontend from frontend-builder stage
COPY --chown=appuser:appuser --from=frontend-builder /app/frontend/dist ./frontend/dist

# Collect static files
RUN python manage.py collectstatic --noinput

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8000/api/v1/health/ || exit 1

# Run the application
CMD ["gunicorn", "{project}.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "3", "--threads", "2", "--access-logfile", "-"]
""",
    )

    write_file(
        base / "docker-compose.yml",
        f"""
version: "3.9"

services:
  web:
    build: .
    ports:
      - "8000:8000"
    env_file:
      - .env.production
    environment:
      - DATABASE_URL=postgres://postgres:password@db:5432/{project}
      - REDIS_URL=redis://redis:6379/0
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/health/"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    networks:
      - app-network
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB={project}
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data
    networks:
      - app-network
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./deploy/nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./staticfiles:/static
      - ./media:/media
      - ./deploy/nginx/ssl:/etc/nginx/ssl
    depends_on:
      - web
    networks:
      - app-network
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

networks:
  app-network:
    driver: bridge
""",
    )

    write_file(
        base / ".dockerignore",
        """
# Python
__pycache__/
*.pyc
*.pyo
*.pyd
.Python
venv/
env/
.pytest_cache/
.coverage
htmlcov/
.pytest_cache/

# Node
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# Frontend build
frontend/dist/

# Django
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal

# IDE
.vscode/
.idea/
*.swp
*.swo

# OS
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
[Tt]humbs.db

# Environment files
.env
.env.local
.env.production
.env.development

# Media and static files
media/
staticfiles/

# Backup files
*.bak
*.backup

# Logs
logs/
*.log
""",
    )

    write_file(base / "Procfile", f"web: gunicorn {project}.wsgi:application --bind 0.0.0.0:$PORT --workers 3 --threads 2")
    write_file(base / "runtime.txt", "python-3.11.6")

    # Step 11: Generate all deployment configurations
    generate_deployment_configs(base, project)

    # Step 12: Initialize and setup
    run(f"{VENV_PYTHON} manage.py migrate")
    run(f"{VENV_PYTHON} manage.py createsuperuser")

    print("\n✅ BACKEND BOOTSTRAP COMPLETE")
    return VENV_PYTHON


# ------------------------
# Frontend Generator (Vite + React) - Updated for deployment
# ------------------------
def create_frontend(base):
    print("\n" + "=" * 50)
    print("CREATING VITE + REACT FRONTEND")
    print("=" * 50)

    CURRENT_DIR = base
    FRONTEND = CURRENT_DIR / "frontend"
    SRC = FRONTEND / "src"

    if FRONTEND.exists():
        print("⚠️ 'frontend' folder exists. Skipping frontend creation.")
        return

    # Initialize Vite project
    run("npm create vite@latest frontend -- --template react-swc-ts", cwd=CURRENT_DIR)
    run("npm install", cwd=FRONTEND)

    # Core dependencies
    deps = [
        "@mui/material",
        "@mui/icons-material",
        "@emotion/react",
        "@emotion/styled",
        "tailwindcss@^4.0.0",
        "@tailwindcss/postcss@^4.0.0",
        "postcss",
        "autoprefixer",
        "zustand",
        "@tanstack/react-query",
        "react-hook-form",
        "@hookform/resolvers",
        "zod",
        "ag-grid-react",
        "ag-grid-community",
        "recharts",
        "react-router-dom",
        "jwt-decode",
        "@formkit/auto-animate",
        "lucide-react",
        "axios",
    ]

    dev_deps = [
        "vite-plugin-checker",
        "vite-tsconfig-paths",
        "vitest",
        "@testing-library/react",
        "@testing-library/jest-dom",
        "eslint",
        "prettier",
        "@types/node",
        "typescript",
    ]

    run(f"npm install {' '.join(deps)}", cwd=FRONTEND)
    run(f"npm install -D {' '.join(dev_deps)}", cwd=FRONTEND)

    # Create frontend deployment configuration
    create_frontend_deployment_config(FRONTEND)

    # ... [rest of the existing frontend creation code remains the same]
    # For brevity, I'm showing the key addition: deployment configuration

    print("\n✅ Frontend deployment configurations generated!")


def create_frontend_deployment_config(frontend_dir):
    """Create frontend deployment configurations"""
    deploy_dir = frontend_dir / "deploy"
    deploy_dir.mkdir(exist_ok=True)
    
    # Netlify configuration
    write_file(deploy_dir / "netlify.toml", textwrap.dedent("""
        [build]
          command = "npm run build"
          publish = "dist"
        
        [build.environment]
          NODE_VERSION = "18"
        
        [[redirects]]
          from = "/*"
          to = "/index.html"
          status = 200
        
        [[headers]]
          for = "/*"
          [headers.values]
            X-Frame-Options = "DENY"
            X-Content-Type-Options = "nosniff"
            Referrer-Policy = "strict-origin-when-cross-origin"
        
        [context.production.environment]
          VITE_API_URL = "https://your-api-domain.com"
    """))
    
    # Vercel configuration
    write_file(deploy_dir / "vercel.json", json.dumps({
        "buildCommand": "npm run build",
        "outputDirectory": "dist",
        "devCommand": "npm run dev",
        "installCommand": "npm install",
        "framework": "vite",
        "rewrites": [
            {
                "source": "/(.*)",
                "destination": "/index.html"
            }
        ],
        "headers": [
            {
                "source": "/(.*)",
                "headers": [
                    {
                        "key": "X-Content-Type-Options",
                        "value": "nosniff"
                    },
                    {
                        "key": "X-Frame-Options",
                        "value": "DENY"
                    },
                    {
                        "key": "Referrer-Policy",
                        "value": "strict-origin-when-cross-origin"
                    }
                ]
            }
        ]
    }, indent=2))
    
    # GitHub Actions for CI/CD
    gh_actions_dir = deploy_dir / ".github" / "workflows"
    gh_actions_dir.mkdir(parents=True, exist_ok=True)
    
    write_file(gh_actions_dir / "deploy.yml", textwrap.dedent("""
        name: Deploy Frontend
        
        on:
          push:
            branches: [ main ]
          pull_request:
            branches: [ main ]
        
        jobs:
          build-and-test:
            runs-on: ubuntu-latest
            
            strategy:
              matrix:
                node-version: [18.x]
            
            steps:
            - uses: actions/checkout@v3
            
            - name: Use Node.js ${{ matrix.node-version }}
              uses: actions/setup-node@v3
              with:
                node-version: ${{ matrix.node-version }}
                cache: 'npm'
                cache-dependency-path: frontend/package-lock.json
            
            - name: Install dependencies
              run: npm ci
              working-directory: frontend
            
            - name: Run tests
              run: npm test
              working-directory: frontend
            
            - name: Build
              run: npm run build
              working-directory: frontend
            
            - name: Upload build artifacts
              uses: actions/upload-artifact@v3
              with:
                name: frontend-build
                path: frontend/dist/
        
          deploy-netlify:
            needs: build-and-test
            runs-on: ubuntu-latest
            if: github.ref == 'refs/heads/main'
            
            steps:
            - uses: actions/checkout@v3
            
            - name: Download build artifacts
              uses: actions/download-artifact@v3
              with:
                name: frontend-build
                path: frontend/dist
            
            - name: Deploy to Netlify
              uses: nwtgck/actions-netlify@v2.0
              with:
                publish-dir: './frontend/dist'
                production-branch: main
                github-token: ${{ secrets.GITHUB_TOKEN }}
                deploy-message: "Deploy from GitHub Actions"
              env:
                NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
                NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
    """))


# ------------------------
# Main Bootstrap - Updated
# ------------------------
def main():
    if len(sys.argv) != 2:
        print("Usage: python bootstrap_fullstack.py <project_name>")
        sys.exit(1)

    project = sys.argv[1]
    base = Path.cwd() / project

    if base.exists():
        print(f"❌ Project folder '{project}' already exists!")
        sys.exit(1)

    base.mkdir(parents=True, exist_ok=True)

    print(f"\n🚀 Creating full-stack project: {project}")
    print(f"📁 Project root: {base}")
    print(f"🌍 Deployment targets: Google Cloud, AWS, Heroku, DigitalOcean, cPanel, PythonAnywhere")

    # Create backend with enhanced deployment configs
    venv_python = create_backend(project, base)

    # Create frontend in backend root
    create_frontend(base)

    # Enhanced README with deployment information
    write_file(
        base / "README.md",
        f"""
# {project} - Full-Stack Production Platform

## 🌟 Features

### Backend (Django DRF)
- ✅ Production-ready Django 4.2 + REST Framework
- ✅ JWT Authentication with refresh tokens
- ✅ CORS configured for deployment
- ✅ PostgreSQL, MySQL, SQLite support
- ✅ Gunicorn + WhiteNoise for production
- ✅ API documentation (Swagger/ReDoc)
- ✅ Rate limiting and throttling
- ✅ Comprehensive logging
- ✅ Email configuration
- ✅ Redis caching ready
- ✅ Health check endpoints
- ✅ Security headers and HTTPS ready

### Frontend (Vite + React + TypeScript)
- ✅ Vite 5 with TypeScript and SWC
- ✅ Tailwind CSS v4 with PostCSS
- ✅ Material-UI components
- ✅ React Query for data fetching
- ✅ Zustand for state management
- ✅ React Hook Form + Zod validation
- ✅ AG Grid for tables
- ✅ Recharts for visualizations
- ✅ React Router v6
- ✅ Axios API client with interceptors
- ✅ JWT authentication flow
- ✅ Responsive design ready

### 🚀 Deployment Ready for:
- **Google Cloud** (App Engine, Cloud Run, GKE)
- **AWS** (Elastic Beanstalk, ECS, EC2)
- **Heroku** (One-click deploy)
- **DigitalOcean** (App Platform, Droplets, Kubernetes)
- **cPanel** (Traditional hosting)
- **PythonAnywhere** (Python-focused hosting)
- **Docker** (Multi-container with PostgreSQL + Redis)
- **Netlify/Vercel** (Frontend only)

## 📁 Project Structure

```
{project}/
├── frontend/                    # Vite + React + TypeScript
│   ├── src/
│   ├── dist/                   # Built frontend
│   ├── deploy/                 # Frontend deployment configs
│   └── package.json
├── api/                        # Django REST API app
├── {project}/                  # Django project settings
├── venv/                       # Python virtual environment
├── deploy/                     # BACKEND DEPLOYMENT CONFIGS
│   ├── google-cloud/          # GCP App Engine, Cloud Run, GKE
│   ├── aws/                   # Elastic Beanstalk, ECS, EC2
│   ├── heroku/                # Heroku app.json, Procfile
│   ├── digitalocean/          # DO App Platform, Droplet
│   ├── cpanel/                # .htaccess, passenger_wsgi
│   └── pythonanywhere/        # PA-specific configs
├── .env                       # Environment variables
├── requirements.txt           # Python dependencies
├── Dockerfile                # Production container
├── docker-compose.yml        # Multi-service setup
└── README.md                # This file
```

## 🚀 Quick Start - Development

### 1. Backend Setup
```bash
cd {project}

# Activate virtual environment
source venv/bin/activate  # Linux/Mac
# venv\\Scripts\\activate  # Windows

# Run development server
python manage.py runserver
```

### 2. Frontend Setup
```bash
cd frontend
npm install
npm run dev
```

### 3. Access Applications
- **Frontend:** http://localhost:5173
- **Backend API:** http://localhost:8000
- **Admin Panel:** http://localhost:8000/admin
- **API Docs:** http://localhost:8000/swagger

## 📡 API Endpoints

- `GET /api/v1/health/` - Health check
- `POST /api/auth/token/` - JWT token obtain
- `POST /api/auth/token/refresh/` - JWT token refresh
- `GET /api/v1/users/` - User management
- `GET /api/v1/users/me/` - Current user

## 🔐 Environment Variables

Create `.env` file:
```bash
# Django
SECRET_KEY=your-secure-secret-key
DEBUG=True  # Set to False in production
ALLOWED_HOSTS=localhost,127.0.0.1
DATABASE_URL=sqlite:///db.sqlite3

# Production database (example for PostgreSQL)
# DATABASE_URL=postgres://user:pass@localhost:5432/dbname

# Email (for production)
# EMAIL_HOST=smtp.gmail.com
# EMAIL_PORT=587
# EMAIL_USE_TLS=True
# EMAIL_HOST_USER=your-email@gmail.com
# EMAIL_HOST_PASSWORD=your-app-password

# Redis (for caching in production)
# REDIS_URL=redis://localhost:6379/1

# CORS (for production)
# CORS_ALLOWED_ORIGINS=https://yourfrontend.com
# CSRF_TRUSTED_ORIGINS=https://yourbackend.com
```

## 🐳 Docker Deployment

### Development
```bash
docker-compose up
```

### Production
```bash
# Build and run
docker-compose -f docker-compose.yml up --build -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down
```

## 🌍 Platform-Specific Deployment

Choose your deployment platform and follow the guide:

### Heroku (Easiest)
```bash
cd {project}
./deploy/heroku/deploy.sh
```

### PythonAnywhere (Beginner-friendly)
```bash
cd {project}
./deploy/pythonanywhere/setup.sh
```

### DigitalOcean (Balanced)
```bash
cd {project}
./deploy/digitalocean/deploy.sh
```

### Google Cloud (Scalable)
```bash
cd {project}
./deploy/google-cloud/deploy.sh
```

### AWS (Enterprise)
```bash
cd {project}
./deploy/aws/deploy-eb.sh  # Elastic Beanstalk
# OR
./deploy/aws/deploy-ecs.sh  # ECS with Fargate
```

### cPanel (Traditional Hosting)
```bash
cd {project}
./deploy/cpanel/setup.sh
```

## 📊 Monitoring & Maintenance

### Essential Monitoring
1. **Application Performance:** Response times, error rates
2. **Resource Usage:** CPU, memory, disk I/O
3. **Database:** Query performance, connections
4. **Logs:** Error tracking, security events

### Regular Tasks
- **Daily:** Check error logs
- **Weekly:** Backup verification
- **Monthly:** Dependency updates, security patches
- **Quarterly:** Performance review, optimization

## 🔒 Security Checklist

### Before Deployment
- [ ] Set `DEBUG=False` in production
- [ ] Generate strong `SECRET_KEY`
- [ ] Configure `ALLOWED_HOSTS`
- [ ] Enable HTTPS/SSL
- [ ] Set up database backups
- [ ] Configure CORS properly
- [ ] Set secure cookies (if using sessions)
- [ ] Implement rate limiting
- [ ] Set security headers

### Ongoing Security
- [ ] Regular dependency updates
- [ ] Security patch monitoring
- [ ] Log monitoring for suspicious activity
- [ ] Regular security audits
- [ ] Penetration testing (for critical apps)

## 🚨 Troubleshooting

### Common Issues

#### 1. Database Connection Failed
```bash
# Check database service
docker-compose ps

# Test database connection
python manage.py dbshell

# Check environment variables
echo $DATABASE_URL
```

#### 2. Static Files Not Loading
```bash
# Collect static files
python manage.py collectstatic --noinput

# Check static file configuration
python manage.py findstatic --verbosity 2 css/styles.css
```

#### 3. Frontend Build Fails
```bash
cd frontend

# Clean install
rm -rf node_modules package-lock.json
npm install

# Check Node.js version
node --version  # Should be 18+

# Build with verbose output
npm run build -- --debug
```

#### 4. High Memory Usage
- Reduce Gunicorn workers: `--workers 2`
- Implement caching with Redis
- Optimize database queries
- Use CDN for static assets

### Getting Help

1. **Check logs:**
```bash
# Django logs
tail -f logs/django.log

# Docker logs
docker-compose logs -f

# System logs
journalctl -u your-service
```

2. **Debug mode:** Set `DEBUG=True` temporarily
3. **Community:** Stack Overflow, Django Forum, GitHub Issues
4. **Documentation:** Platform-specific docs in `deploy/` folders

## 📈 Performance Optimization

### Backend
1. **Database:**
   - Add indexes for frequent queries
   - Use `select_related` and `prefetch_related`
   - Implement database connection pooling

2. **Caching:**
   - Use Redis for session and template caching
   - Implement query caching
   - Cache API responses where appropriate

3. **Static Files:**
   - Use WhiteNoise with compression
   - Implement CDN (CloudFront, Cloudflare)
   - Enable browser caching

### Frontend
1. **Code Splitting:** Lazy load routes and components
2. **Asset Optimization:** Compress images, minify code
3. **Caching:** Service workers for offline support
4. **CDN:** Use for libraries and assets

## 🔄 Updating & Maintenance

### Update Dependencies
```bash
# Backend
source venv/bin/activate
pip install --upgrade -r requirements.txt
python manage.py migrate

# Frontend
cd frontend
npm update
npm run build
```

### Database Migrations
```bash
# Create migrations
python manage.py makemigrations

# Apply migrations
python manage.py migrate

# Rollback if needed
python manage.py migrate app_name previous_migration
```

### Backup Strategy
```bash
# Database backup
pg_dump database_name > backup_$(date +%Y%m%d).sql

# Media files backup
tar -czf media_backup_$(date +%Y%m%d).tar.gz media/

# Code backup
git push origin main
```

## 🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Make changes with tests
4. Submit a pull request

## 📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

## 🙏 Acknowledgments

- Django REST Framework team
- Vite and React communities
- All deployment platform providers
- Open source contributors

---

**Happy Coding! 🚀**

*For detailed platform-specific instructions, check the `deploy/` directory.*
""",
    )

    print("\n" + "=" * 50)
    print("🎉 FULL-STACK PROJECT CREATION COMPLETE!")
    print("=" * 50)
    print(f"\n📁 Project created at: {base}")
    
    print("\n🚀 DEPLOYMENT CONFIGURATIONS GENERATED FOR:")
    print("   ✓ Google Cloud (App Engine, Cloud Run, GKE)")
    print("   ✓ AWS (Elastic Beanstalk, ECS, EC2)")
    print("   ✓ Heroku (One-click deploy)")
    print("   ✓ DigitalOcean (App Platform, Droplets)")
    print("   ✓ cPanel (Traditional hosting)")
    print("   ✓ PythonAnywhere (Python-focused hosting)")
    print("   ✓ Docker (Multi-container production ready)")
    
    print("\n📋 NEXT STEPS:")
    print(f"1. cd {project}")
    print("2. Activate virtual environment:")
    print("   - Linux/Mac: source venv/bin/activate")
    print("   - Windows: venv\\Scripts\\activate")
    print("3. Start backend: python manage.py runserver")
    print("4. Start frontend (new terminal):")
    print("   cd frontend && npm run dev")
    
    print("\n🌐 Quick Deployment Options:")
    print("   Heroku:      ./deploy/heroku/deploy.sh")
    print("   PythonAnywhere: ./deploy/pythonanywhere/setup.sh")
    print("   DigitalOcean: ./deploy/digitalocean/deploy.sh")
    
    print("\n📚 Detailed deployment guides in: deploy/ directory")
    print("\nHappy coding! 🚀")


if __name__ == "__main__":
    main()