class EmailTemplateService:
    def __init__(self, templates_dir: str = "templates"):
        """
        Initialize the email template service with Jinja2

        Args:
            templates_dir: Directory containing email templates
        """
        template_path = Path(__file__).parent / templates_dir
        self.env = Environment(
            loader=FileSystemLoader(template_path),
            autoescape=True,  # Auto-escape HTML for security
            trim_blocks=True,
            lstrip_blocks=True
        )

    def render_template(self, template_name: str, **context) -> str:
        """
        Render an email template with the given context

        Args:
            template_name: Name of the template file
            **context: Variables to pass to the template

        Returns:
            Rendered HTML string
        """
        template = self.env.get_template(template_name)
        return template.render(**context)

async def send_email(to_email: str, subject: str, html_content: str, from_email: str) -> None:
    """
    Send an email using SendGrid

    Args:
        to_email: Recipient email address
        subject: Email subject line
        html_content: HTML content of the email
        from_email: Sender email address
    """
    if not app_settings.SENDGRID_API_KEY:
        print("Warning: SendGrid API key not set, email not sent")
        return

    message = Mail(
        from_email=from_email,
        to_emails=to_email,
        subject=subject,
        html_content=html_content
    )

    try:
        sg = SendGridAPIClient(app_settings.SENDGRID_API_KEY)
        response = sg.send(message)
        print(f"SendGrid response code: {response.status_code}")
    except Exception as e:
        print(f"SendGrid error: {str(e)}")

# Send verification email
async def send_verification_email(email: str, token: str) -> None:
    verification_link = f"{app_settings.BACKEND_URL}/auth/verify-email?token={token}"
    subject = "Confirm Your Email - Name"

    context = {
        'verification_link': verification_link,
        'expires_in': '30 minutes',
        'support_email': app_settings.SUPPORT_EMAIL,
        'company_name': app_settings.COMPANY_NAME,
        'company_address': None,
    }

    html_content = email_template_service.render_template(
        "verify_user_email.html",
        **context
    )

    await send_email(
        to_email=email,
        subject=subject,
        html_content=html_content,
        from_email=app_settings.FROM_EMAIL
    )

# Send password reset email
async def send_password_reset_email(
    email: str,
    token: str,
    user_name: Optional[str] = None
) -> None:
    reset_link = f"{app_settings.FRONTEND_URL}/change-password?token={token}"
    subject = "Request to reset your Password"

    context = {
        'reset_link': reset_link,
        'user_name': user_name,
        'expires_in': '15 minutes',
        'support_email': app_settings.SUPPORT_EMAIL,
        'company_name': app_settings.COMPANY_NAME,
        'company_address': None,
    }

    html_content = email_template_service.render_template(
        'reset_password_email.html',
        **context
    )

    await send_email(
        to_email=email,
        subject=subject,
        html_content=html_content,
        from_email=app_settings.FROM_EMAIL
    )

@router.post("/create-user", status_code=status.HTTP_201_CREATED)
async def create_user(
    db: db_dependency,
    create_user_request: CreateUserRequest,
    background_tasks: BackgroundTasks
):
    """Register a new user."""
    # ... user creation logic ...

    # Generate verification token
    token = generate_verification_token(create_user_request.email)

    # Add email sending to background tasks
    background_tasks.add_task(
        send_verification_email,
        create_user_request.email,
        token
    )

    return {"message": "User created. Check your email to verify."}

from celery import current_app as celery_app
from .emails import send_email, send_verification_email, send_password_reset_email

@celery_app.task(bind=True, max_retries=3)
def send_email_task(self, to_email: str, subject: str, html_content: str, from_email: str):
    """Celery task for sending emails with retry logic."""
    try:
        # Convert to sync call for Celery
        import asyncio
        asyncio.run(send_email(to_email, subject, html_content, from_email))
    except Exception as exc:
        # Retry with exponential backoff
        raise self.retry(exc=exc, countdown=60 * (2 ** self.request.retries))

@celery_app.task(bind=True, max_retries=3)
def send_verification_email_task(self, email: str, token: str):
    """Celery task for sending verification emails."""
    try:
        import asyncio
        asyncio.run(send_verification_email(email, token))
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60 * (2 ** self.request.retries))

from app.email.tasks import send_verification_email_task

@router.post("/create-user", status_code=status.HTTP_201_CREATED)
async def create_user(
    db: db_dependency,
    create_user_request: CreateUserRequest
):
    """Register a new user."""
    # ... user creation logic ...

    # Generate verification token
    token = generate_verification_token(create_user_request.email)

    # Queue email sending with Celery
    send_verification_email_task.delay(
        create_user_request.email,
        token
    )

    return {"message": "User created. Check your email to verify."}

async def send_bulk_emails(recipients: List[str], subject: str, template_name: str, context: Dict[str, Any]) -> None:
    """Send the same email to multiple recipients."""
    html_content = email_template_service.render_template(template_name, **context)

    for recipient in recipients:
        await send_email(
            to_email=recipient,
            subject=subject,
            html_content=html_content,
            from_email=app_settings.FROM_EMAIL
        )
        # Add delay to respect rate limits
        await asyncio.sleep(0.1)

from sendgrid.helpers.mail import Attachment, FileContent, FileName, FileType, Disposition
import base64

async def send_email_with_attachment(to_email: str, subject: str, html_content: str,
                                   from_email: str, file_path: str, filename: str) -> None:
    """Send email with file attachment."""
    message = Mail(
        from_email=from_email,
        to_emails=to_email,
        subject=subject,
        html_content=html_content
    )

    # Read and encode file
    with open(file_path, 'rb') as file:
        data = file.read()
        encoded_file = base64.b64encode(data).decode()

    # Create attachment
    attachment = Attachment(
        FileContent(encoded_file),
        FileName(filename),
        FileType('application/pdf'),  # Adjust based on file type
        Disposition('attachment')
    )

    message.attachment = attachment

    try:
        sg = SendGridAPIClient(app_settings.SENDGRID_API_KEY)
        response = sg.send(message)
        print(f"Email with attachment sent: {response.status_code}")
    except Exception as e:
        print(f"Error sending email with attachment: {str(e)}")

from celery import Celery
from typing import List, Dict, Any

app = Celery('email_tasks')

@app.task
def send_email_task(to_email: str, subject: str, html_content: str, from_email: str):
    """Celery task for sending emails."""
    # Use synchronous version for Celery
    import asyncio
    asyncio.run(send_email(to_email, subject, html_content, from_email))

@app.task
def send_bulk_emails_task(recipients: List[str], subject: str, template_name: str, context: Dict[str, Any]):
    """Celery task for bulk email sending."""
    html_content = email_template_service.render_template(template_name, **context)

    for recipient in recipients:
        send_email_task.delay(
            recipient,
            subject,
            html_content,
            app_settings.FROM_EMAIL
        )

import pytest
from unittest.mock import Mock, patch
from app.email.emails import EmailTemplateService, send_email

class TestEmailTemplateService:
    def setup_method(self):
        self.email_service = EmailTemplateService()

    def test_render_template_with_context(self):
        """Test template rendering with context variables."""
        # This would require actual template files in test environment
        pass

    @patch('app.email.emails.SendGridAPIClient')
    async def test_send_email_success(self, mock_sendgrid):
        """Test successful email sending."""
        mock_sg = Mock()
        mock_sendgrid.return_value = mock_sg
        mock_sg.send.return_value.status_code = 202

        await send_email(
            to_email="test@example.com",
            subject="Test",
            html_content="<h1>Test</h1>",
            from_email="from@example.com"
        )

        mock_sg.send.assert_called_once()

    @patch('app.email.emails.SendGridAPIClient')
    async def test_send_email_no_api_key(self, mock_sendgrid):
        """Test email sending without API key."""
        with patch('app.email.emails.app_settings.SENDGRID_API_KEY', None):
            await send_email(
                to_email="test@example.com",
                subject="Test",
                html_content="<h1>Test</h1>",
                from_email="from@example.com"
            )

        mock_sendgrid.assert_not_called()

import pytest
from fastapi.testclient import TestClient
from unittest.mock import patch

def test_user_registration_sends_verification_email(test_client: TestClient):
    """Test that user registration triggers verification email."""
    with patch('app.routers.auth.routes.send_verification_email') as mock_send:
        response = test_client.post("/auth/create-user", json={
            "username": "testuser",
            "email": "test@example.com",
            "password": "testpassword123"
        })

        assert response.status_code == 201
        mock_send.assert_called_once()

import logging

# Enable debug logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

async def send_email_debug(to_email: str, subject: str, html_content: str, from_email: str) -> None:
    """Debug version of send_email function."""
    logger.debug(f"Sending email to: {to_email}")
    logger.debug(f"Subject: {subject}")
    logger.debug(f"From: {from_email}")
    logger.debug(f"HTML content length: {len(html_content)}")

    # ... rest of send_email function ...