landing/server.py

import time
start_time = time.time()

import os
print(f"os imported in {time.time() - start_time:.3f}s")

from threading import Thread
print(f"threading imported in {time.time() - start_time:.3f}s")

import smtplib
print(f"smtplib imported in {time.time() - start_time:.3f}s")

from email.mime.text import MIMEText
print(f"email imported in {time.time() - start_time:.3f}s")

from flask import Flask, render_template, request, jsonify
print(f"flask imported in {time.time() - start_time:.3f}s")

from dotenv import load_dotenv
print(f"dotenv imported in {time.time() - start_time:.3f}s")

from database import init_db, get_connection, add_email, remove_email
print(f"database imported in {time.time() - start_time:.3f}s")

load_dotenv()
print(f"load_dotenv() completed in {time.time() - start_time:.3f}s")

SMTP_SERVER   = os.getenv('SMTP_SERVER')
SMTP_PORT     = int(os.getenv('SMTP_PORT', 465))
SMTP_USER     = os.getenv('SMTP_USER')
SMTP_PASSWORD = os.getenv('SMTP_PASSWORD')

app = Flask(__name__)

_db_initialized = False
_newsletter_cache = {}
_cache_timestamp = {}
CACHE_DURATION = 300

def ensure_db_initialized():
    """Lazy database initialization - only runs on first database access"""
    global _db_initialized
    if not _db_initialized:
        init_db()
        _db_initialized = True

def get_newsletters_cached():
    """Get newsletters with caching to reduce database hits"""
    current_time = time.time()
    
    if ('newsletters' in _newsletter_cache and 
        current_time - _cache_timestamp.get('newsletters', 0) < CACHE_DURATION):
        return _newsletter_cache['newsletters']
    
    ensure_db_initialized()
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute(
        "SELECT id, subject, body, sent_at "
        "FROM newsletters ORDER BY sent_at DESC"
    )
    rows = cursor.fetchall()
    cursor.close()
    conn.close()
    
    newsletters = [
        {"id": r[0], "subject": r[1], "body": r[2], "sent_at": r[3]}
        for r in rows
    ]
    
    _newsletter_cache['newsletters'] = newsletters
    _cache_timestamp['newsletters'] = current_time
    
    return newsletters

def get_newsletter_by_id_cached(newsletter_id):
    """Get single newsletter with caching"""
    cache_key = f'newsletter_{newsletter_id}'
    current_time = time.time()
    
    if (cache_key in _newsletter_cache and 
        current_time - _cache_timestamp.get(cache_key, 0) < CACHE_DURATION):
        return _newsletter_cache[cache_key]
    
    ensure_db_initialized()
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute(
        "SELECT id, subject, body, sent_at "
        "FROM newsletters WHERE id = %s",
        (newsletter_id,)
    )
    row = cursor.fetchone()
    cursor.close()
    conn.close()
    
    if not row:
        return None
        
    newsletter = {
        "id": row[0],
        "subject": row[1],
        "body": row[2],
        "sent_at": row[3]
    }
    
    _newsletter_cache[cache_key] = newsletter
    _cache_timestamp[cache_key] = current_time
    
    return newsletter

def clear_newsletter_cache():
    """Clear newsletter cache when data is updated"""
    global _newsletter_cache, _cache_timestamp
    keys_to_remove = [k for k in _newsletter_cache.keys() 
                      if k.startswith('newsletter')]
    for key in keys_to_remove:
        _newsletter_cache.pop(key, None)
        _cache_timestamp.pop(key, None)

@app.before_request
def start_timer():
    request._start_time = time.time()

@app.after_request
def log_request(response):
    elapsed = time.time() - getattr(request, '_start_time', time.time())
    app.logger.info(f"{request.method} {request.path} completed in {elapsed:.3f}s")
    return response

def send_confirmation_email(to_address: str, unsubscribe_link: str):
    """
    Sends the HTML confirmation email to `to_address`.
    This runs inside its own SMTP_SSL connection (timeout=10s).
    """
    subject = "Thanks for subscribing!"
    html_body = render_template(
        "confirmation_email.html",
        unsubscribe_link=unsubscribe_link
    )

    msg = MIMEText(html_body, "html", "utf-8")
    msg["Subject"] = subject
    msg["From"]    = SMTP_USER
    msg["To"]      = to_address

    try:
        with smtplib.SMTP_SSL(SMTP_SERVER, SMTP_PORT, timeout=10) as server:
            server.login(SMTP_USER, SMTP_PASSWORD)
            server.sendmail(SMTP_USER, [to_address], msg.as_string())
    except Exception as e:
        app.logger.error(f"Failed to send email to {to_address}: {e}")

def send_confirmation_async(email, unsubscribe_link):
    """
    Wrapper for threading.Thread target.
    """
    send_confirmation_email(email, unsubscribe_link)

@app.route("/", methods=["GET"])
def index():
    """Home page - no database access needed"""
    return render_template("index.html")

@app.route("/subscribe", methods=["POST"])
def subscribe():
    """Subscribe endpoint - lazy loads database only when needed"""
    data = request.get_json() or {}
    email = data.get("email")
    if not email:
        return jsonify(error="No email provided"), 400

    ensure_db_initialized()
    
    if add_email(email):
        unsubscribe_link = f"{request.url_root}unsubscribe?email={email}"

        Thread(
            target=send_confirmation_async,
            args=(email, unsubscribe_link),
            daemon=True
        ).start()

        return jsonify(message="Email has been added"), 201

    return jsonify(error="Email already exists"), 400

@app.route("/unsubscribe", methods=["GET"])
def unsubscribe():
    """Unsubscribe endpoint - lazy loads database only when needed"""
    email = request.args.get("email")
    if not email:
        return "No email specified.", 400

    ensure_db_initialized()
    
    if remove_email(email):
        return f"The email {email} has been unsubscribed.", 200
    return f"Email {email} was not found or has already been unsubscribed.", 400

@app.route("/newsletters", methods=["GET"])
def newsletters():
    """
    List all newsletters (newest first) with caching for better performance.
    """
    newsletters = get_newsletters_cached()
    return render_template("newsletters.html", newsletters=newsletters)

@app.route("/newsletter/<int:newsletter_id>", methods=["GET"])
def newsletter_detail(newsletter_id):
    """
    Show a single newsletter by its ID with caching.
    """
    newsletter = get_newsletter_by_id_cached(newsletter_id)
    
    if not newsletter:
        return "Newsletter not found.", 404

    return render_template("newsletter_detail.html", newsletter=newsletter)

@app.route("/admin/clear-cache", methods=["POST"])
def clear_cache():
    """Admin endpoint to clear newsletter cache"""
    clear_newsletter_cache()
    return jsonify(message="Cache cleared successfully"), 200

if __name__ == "__main__":
    app.run(host="0.0.0.0", debug=True)