from fastapi import FastAPI, BackgroundTasks
from pydantic import BaseModel

app = FastAPI()

# ── The background task function (plain Python function) ──
def send_welcome_email(email: str, username: str):
    # In real code: connect to SMTP, render template, send
    print(f"Sending welcome email to {email} for {username}")
    # imagine: smtp.send(to=email, subject="Welcome!", body=...)

class UserCreate(BaseModel):
    username: str
    email: str

# ── Route: inject BackgroundTasks ──
@app.post("/register", status_code=201)
async def register(
    user: UserCreate,
    background_tasks: BackgroundTasks   # FastAPI injects this
):
    # 1. Save user to DB (pretend)
    new_user = {"id": 1, "username": user.username, "email": user.email}

    # 2. Queue the email — doesn't run yet!
    background_tasks.add_task(send_welcome_email, user.email, user.username)

    # 3. Return immediately — email runs AFTER this
    return {"message": "User created", "user": new_user}

import asyncio

async def send_welcome_email_async(email: str, username: str):
    await asyncio.sleep(0.5)   # simulate async SMTP call
    print(f"[ASYNC] Email sent to {email}")

@app.post("/register-async", status_code=201)
async def register_async(user: UserCreate, background_tasks: BackgroundTasks):
    background_tasks.add_task(send_welcome_email_async, user.email, user.username)
    return {"message": "Registered"}

# pip install fastapi-mail
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig

conf = ConnectionConfig(
    MAIL_USERNAME="you@example.com",
    MAIL_PASSWORD="secret",
    MAIL_FROM="you@example.com",
    MAIL_PORT=587,
    MAIL_SERVER="smtp.gmail.com",
    MAIL_STARTTLS=True,
    MAIL_SSL_TLS=False,
)

async def send_welcome_email(email: str, username: str):
    message = MessageSchema(
        subject="Welcome!",
        recipients=[email],
        body=f"Hi {username}, welcome aboard!",
        subtype="plain"
    )
    fm = FastMail(conf)
    await fm.send_message(message)

@app.post("/register")
async def register(user: UserCreate, bt: BackgroundTasks):
    bt.add_task(send_welcome_email, user.email, user.username)
    return {"status": "ok"}

import asyncio
from fastapi import BackgroundTasks

async def send_reminder_after_delay(email: str, delay_seconds: int):
    await asyncio.sleep(delay_seconds)    # wait before doing work
    print(f"Reminder sent to {email}")

@app.post("/subscribe")
async def subscribe(email: str, bt: BackgroundTasks):
    # Will send a reminder in 1 hour (3600 seconds)
    bt.add_task(send_reminder_after_delay, email, delay_seconds=3600)
    return {"message": "Subscribed! Reminder in 1 hour."}

# pip install apscheduler
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.date import DateTrigger
from datetime import datetime, timedelta, timezone
from contextlib import asynccontextmanager

scheduler = AsyncIOScheduler()

@asynccontextmanager
async def lifespan(app):
    scheduler.start()     # start the scheduler on startup
    yield
    scheduler.shutdown()  # clean up on shutdown

app = FastAPI(lifespan=lifespan)

async def send_reminder(email: str):
    print(f"Reminder sent to {email}")

@app.post("/subscribe")
async def subscribe(email: str):
    # Schedule reminder 1 hour from now
    run_at = datetime.now(timezone.utc) + timedelta(hours=1)
    scheduler.add_job(
        send_reminder,
        trigger=DateTrigger(run_date=run_at),
        args=[email],
        id=f"reminder_{email}"  # unique job ID
    )
    return {"scheduled_for": run_at.isoformat()}

# ── Recurring schedule (cron-style) ──
from apscheduler.triggers.cron import CronTrigger

async def daily_report():
    print("Generating daily report...")

# Add this in lifespan before yield:
# scheduler.add_job(daily_report, CronTrigger(hour=8, minute=0))  # every day at 8am

# pip install arq redis
# Needs: Redis running (docker run -p 6379:6379 redis)
from arq import create_pool
from arq.connections import RedisSettings

# ── Task definition (in tasks.py) ──
async def send_reminder_task(ctx, email: str):
    print(f"Sending reminder to {email}")
    return "done"

# ── Worker settings (in worker.py) ──
class WorkerSettings:
    functions = [send_reminder_task]
    redis_settings = RedisSettings()

# ── FastAPI integration ──
redis_pool = None

@asynccontextmanager
async def lifespan(app):
    global redis_pool
    redis_pool = await create_pool(RedisSettings())
    yield
    await redis_pool.close()

app = FastAPI(lifespan=lifespan)

@app.post("/subscribe")
async def subscribe(email: str):
    # Enqueue with a 1-hour delay (_defer_by in seconds)
    await redis_pool.enqueue_job(
        "send_reminder_task",
        email,
        _defer_by=3600   # delay by 3600 seconds = 1 hour
    )
    return {"queued": True}

# Run the worker separately: python -m arq worker.WorkerSettings