name: Pull Request Validation

on:
  pull_request:
    branches: [development, main]
    types: [opened, synchronize, reopened]

jobs:
  code-quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
          
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'
          
      - name: Install dependencies
        run: |
          npm ci
          pip install -r requirements.txt
          
      - name: Run linting
        run: |
          npm run lint
          ruff check .
          black --check .
          
      - name: Type checking
        run: |
          npm run type-check
          mypy .
          
      - name: Security scanning
        uses: github/codeql-action/analyze@v3
        with:
          languages: javascript,python

  unit-tests:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: test
          POSTGRES_DB: reptidex_test
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
          
      redis:
        image: redis:7
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup test environment
        run: |
          npm ci
          pip install -r requirements-test.txt
          
      - name: Run frontend tests
        run: npm run test:coverage
        
      - name: Run backend tests
        run: |
          pytest --cov=src --cov-report=xml --cov-min=80
          
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v4
        with:
          files: ./coverage.xml,./coverage/lcov.info

  build-and-deploy-staging:
    needs: [code-quality, unit-tests]
    runs-on: ubuntu-latest
    if: github.event.pull_request.head.ref != 'main'
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1
          
      - name: Build and push Docker images
        run: |
          # Build all service images
          docker-compose -f docker-compose.staging.yml build
          
          # Push to ECR
          aws ecr get-login-password | docker login --username AWS --password-stdin $ECR_REGISTRY
          docker-compose -f docker-compose.staging.yml push
          
      - name: Deploy to staging
        run: |
          # Update ECS service with new task definitions
          aws ecs update-service --cluster reptidex-staging --service repti-web --force-new-deployment
          
      - name: Run integration tests
        run: |
          # Wait for deployment to complete
          aws ecs wait services-stable --cluster reptidex-staging --services repti-web
          
          # Run integration test suite against staging
          npm run test:integration -- --baseUrl=https://staging.reptidex.com

# Multi-stage build for frontend optimization
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

COPY . .
RUN npm run build

# Production stage
FROM nginx:alpine AS production

# Copy custom nginx configuration
COPY nginx.conf /etc/nginx/nginx.conf
COPY --from=builder /app/dist /usr/share/nginx/html

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

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

FROM python:3.12-slim AS base

# System dependencies
RUN apt-get update && apt-get install -y \
    postgresql-client \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Python environment
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PYTHONPATH=/app

WORKDIR /app

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Application code
COPY . .

# Create non-root user
RUN adduser --disabled-password --gecos '' appuser && \
    chown -R appuser:appuser /app
USER appuser

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

EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "app.wsgi:application"]

FROM python:3.12-slim AS worker

# System dependencies for worker tasks
RUN apt-get update && apt-get install -y \
    imagemagick \
    ffmpeg \
    postgresql-client \
    && rm -rf /var/lib/apt/lists/*

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    C_FORCE_ROOT=1

WORKDIR /app

# Install dependencies
COPY requirements.txt requirements-worker.txt ./
RUN pip install --no-cache-dir -r requirements.txt -r requirements-worker.txt

COPY . .

# Worker-specific health check
HEALTHCHECK --interval=60s --timeout=15s --start-period=60s --retries=3 \
  CMD celery -A app.celery inspect ping || exit 1

CMD ["celery", "-A", "app.celery", "worker", "--loglevel=info", "--concurrency=4"]

#!/bin/bash
# Blue-Green deployment script

# Configuration
CLUSTER="reptidex-production"
SERVICE_NAME="reptidex-web"
NEW_VERSION=$1

# Determine current active environment
ACTIVE_ENV=$(aws elbv2 describe-target-groups \
  --target-group-arns $BLUE_TG_ARN $GREEN_TG_ARN \
  --query 'TargetGroups[?length(Targets) > `0`].TargetGroupName' \
  --output text)

if [[ $ACTIVE_ENV == *"blue"* ]]; then
    INACTIVE_ENV="green"
    INACTIVE_TG_ARN=$GREEN_TG_ARN
else
    INACTIVE_ENV="blue"  
    INACTIVE_TG_ARN=$BLUE_TG_ARN
fi

echo "Deploying version $NEW_VERSION to $INACTIVE_ENV environment"

# Deploy to inactive environment
aws ecs update-service \
  --cluster $CLUSTER \
  --service "${SERVICE_NAME}-${INACTIVE_ENV}" \
  --task-definition "${SERVICE_NAME}:${NEW_VERSION}" \
  --force-new-deployment

# Wait for deployment to stabilize
echo "Waiting for deployment to stabilize..."
aws ecs wait services-stable \
  --cluster $CLUSTER \
  --services "${SERVICE_NAME}-${INACTIVE_ENV}"

# Health check on inactive environment
echo "Running health checks..."
./scripts/health_check.sh "https://${INACTIVE_ENV}.reptidex.com"

if [ $? -eq 0 ]; then
    echo "Health checks passed. Switching traffic..."
    
    # Switch load balancer target group
    aws elbv2 modify-listener \
      --listener-arn $LISTENER_ARN \
      --default-actions Type=forward,TargetGroupArn=$INACTIVE_TG_ARN
      
    echo "Traffic switched to $INACTIVE_ENV environment"
    
    # Run post-deployment validation
    ./scripts/validate_production.sh
    
    if [ $? -eq 0 ]; then
        echo "Deployment successful!"
        
        # Scale down old environment
        aws ecs update-service \
          --cluster $CLUSTER \
          --service "${SERVICE_NAME}-${ACTIVE_ENV}" \
          --desired-count 0
          
    else
        echo "Post-deployment validation failed. Rolling back..."
        # Rollback logic here
        exit 1
    fi
else
    echo "Health checks failed. Deployment aborted."
    exit 1
fi

#!/bin/bash
# health_check.sh

BASE_URL=$1
MAX_ATTEMPTS=30
SLEEP_TIME=10

for i in $(seq 1 $MAX_ATTEMPTS); do
    echo "Health check attempt $i/$MAX_ATTEMPTS"
    
    # Check application health endpoint
    HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "$BASE_URL/api/health")
    
    if [ $HTTP_CODE -eq 200 ]; then
        echo "✅ Health check endpoint passed"
        
        # Check database connectivity
        DB_CHECK=$(curl -s "$BASE_URL/api/health/db" | jq -r '.status')
        if [ "$DB_CHECK" = "healthy" ]; then
            echo "✅ Database connectivity check passed"
            
            # Check Redis connectivity
            REDIS_CHECK=$(curl -s "$BASE_URL/api/health/cache" | jq -r '.status')
            if [ "$REDIS_CHECK" = "healthy" ]; then
                echo "✅ All health checks passed"
                exit 0
            fi
        fi
    fi
    
    echo "❌ Health check failed, retrying in ${SLEEP_TIME}s..."
    sleep $SLEEP_TIME
done

echo "❌ Health checks failed after $MAX_ATTEMPTS attempts"
exit 1