from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    # checkboxHQ API
    CHECKBOXHQ_API_KEY: str
    CHECKBOXHQ_BASE_URL: str = "https://api.checkboxhq.com"

    # Database
    DATABASE_URL: str

    # Redis for Celery (job queue)
    REDIS_URL: str = "redis://localhost:6379/0"

    # Validation rules
    REJECT_DISPOSABLE: bool = True
    REJECT_INVALID_MX: bool = True
    REJECT_PUBLIC_PROVIDERS: bool = False  # Usually False for B2C

    # Rate limiting
    CHECKBOXHQ_RATE_LIMIT: int = 90  # Stay under 100/min

    class Config:
        env_file = ".env"

settings = Settings()

from fastapi import APIRouter, HTTPException, Depends
from sqlalchemy.orm import Session
from pydantic import BaseModel, EmailStr
from ..database import get_db
from ..tasks import validate_email_async
import bcrypt

router = APIRouter()

class SignupRequest(BaseModel):
    email: EmailStr  # Pydantic validates email format
    password: str
    name: str

class SignupResponse(BaseModel):
    id: int
    email: str
    name: str
    validation_status: str
    message: str

@router.post("/signup", response_model=SignupResponse)
async def signup(request: SignupRequest, db: Session = Depends(get_db)):
    """
    Create user account and queue email validation.
    User gets immediate access while validation runs in background.
    """

    # 1. Check if email already exists
    existing_user = db.query(User).filter(
        User.email == request.email.lower()
    ).first()

    if existing_user:
        raise HTTPException(
            status_code=400,
            detail="Email already registered"
        )

    # 2. Hash password
    password_hash = bcrypt.hashpw(
        request.password.encode('utf-8'),
        bcrypt.gensalt()
    ).decode('utf-8')

    # 3. Create user with pending validation
    user = User(
        email=request.email.lower(),
        password_hash=password_hash,
        name=request.name,
        email_validation_status="pending",
        account_status="active"  # Allow immediate access
    )

    db.add(user)
    db.commit()
    db.refresh(user)

    # 4. Queue async validation (doesn't block response)
    validate_email_async.delay(user.id, user.email)

    # 5. Return immediately
    return SignupResponse(
        id=user.id,
        email=user.email,
        name=user.name,
        validation_status="pending",
        message="Account created successfully. Email validation in progress."
    )

from celery import Celery
import httpx
from sqlalchemy.orm import Session
from config import settings
from models import User
import logging
from datetime import datetime
import time

# Initialize Celery
celery_app = Celery(
    'checkboxhq_tasks',
    broker=settings.REDIS_URL,
    backend=settings.REDIS_URL
)

# Configure Celery
celery_app.conf.update(
    task_serializer='json',
    result_serializer='json',
    accept_content=['json'],
    timezone='UTC',
    enable_utc=True,
)

logger = logging.getLogger(__name__)

@celery_app.task(
    bind=True,
    max_retries=3,
    default_retry_delay=60  # Wait 60 seconds before retry
)
def validate_email_async(self, user_id: int, email: str):
    """
    Validate email using checkboxHQ API.

    Strategy:
    1. Check if disposable (1 credit)
    2. If not disposable, verify DNS (2 credits)
    3. Optionally check public provider (1 credit)

    Total: 3 credits per email (or 1 if disposable)
    """

    db = get_db_session()

    try:
        # Get user
        user = db.query(User).filter(User.id == user_id).first()
        if not user:
            logger.error(f"User {user_id} not found")
            return

        # Update status
        user.email_validation_status = "validating"
        db.commit()

        # === STEP 1: Check Disposable (1 credit) ===
        logger.info(f"Checking disposable for {email}")
        disposable_result = check_disposable(email)

        # Save disposable check results
        user.is_disposable = disposable_result['is_disposable']
        user.disposable_provider = disposable_result.get('provider')
        db.commit()

        # Reject if disposable
        if disposable_result['is_disposable'] and settings.REJECT_DISPOSABLE:
            user.email_validation_status = "invalid_disposable"
            user.validated_at = datetime.utcnow()
            db.commit()

            handle_invalid_email(user, "disposable")
            logger.warning(f"Rejected disposable email: {email}")
            return

        # === STEP 2: Verify DNS (2 credits) ===
        logger.info(f"Verifying DNS for {email}")

        # Rate limiting: Sleep if needed to stay under 100/min
        time.sleep(0.65)  # ~92 requests/min to be safe

        dns_result = verify_dns(email)

        # Save DNS results
        user.has_mx_record = dns_result['has_mx_record']
        user.mx_records = dns_result.get('mx_records')
        user.has_a_record = dns_result['has_a_record']
        user.a_records = dns_result.get('a_records')
        user.email_provider = dns_result.get('provider')
        db.commit()

        # Reject if no MX record
        if not dns_result['has_mx_record'] and settings.REJECT_INVALID_MX:
            user.email_validation_status = "invalid_no_mx"
            user.validated_at = datetime.utcnow()
            db.commit()

            handle_invalid_email(user, "no_mx_record")
            logger.warning(f"Rejected email without MX: {email}")
            return

        # Warn if no A record (domain has no website)
        if not dns_result['has_a_record']:
            logger.warning(f"No A record for {email} - domain has no website")

        # === STEP 3: Check Public Provider (optional, 1 credit) ===
        if settings.REJECT_PUBLIC_PROVIDERS:
            logger.info(f"Checking public provider for {email}")

            time.sleep(0.65)  # Rate limiting

            public_result = check_public_provider(email)

            user.is_public_provider = public_result['is_public_provider']
            db.commit()

            if public_result['is_public_provider']:
                user.email_validation_status = "invalid_public"
                user.validated_at = datetime.utcnow()
                db.commit()

                handle_invalid_email(user, "public_provider")
                logger.warning(f"Rejected public provider: {email}")
                return

        # === All checks passed ===
        user.email_validation_status = "valid"
        user.validated_at = datetime.utcnow()
        db.commit()

        logger.info(f"Email validated successfully: {email}")

    except httpx.HTTPStatusError as e:
        if e.response.status_code == 429:
            # Rate limit exceeded - retry after delay
            logger.warning(f"Rate limit hit for {email}, retrying...")
            raise self.retry(countdown=120)  # Wait 2 minutes
        else:
            logger.error(f"HTTP error validating {email}: {e}")
            raise self.retry(exc=e)

    except Exception as e:
        logger.error(f"Unexpected error validating {email}: {e}")
        user.email_validation_status = "failed"
        user.validation_error = str(e)
        db.commit()

    finally:
        db.close()


def check_disposable(email: str) -> dict:
    """Call checkboxHQ disposable check endpoint (1 credit)"""

    response = httpx.post(
        f"{settings.CHECKBOXHQ_BASE_URL}/api/v1/verify_disposable/",
        json={"email": email},
        headers={"x-api-key": settings.CHECKBOXHQ_API_KEY},
        timeout=10.0
    )
    response.raise_for_status()
    return response.json()


def verify_dns(email: str) -> dict:
    """Call checkboxHQ DNS verification endpoint (2 credits)"""

    response = httpx.post(
        f"{settings.CHECKBOXHQ_BASE_URL}/api/v1/verify_dns/",
        json={"email": email},
        headers={"x-api-key": settings.CHECKBOXHQ_API_KEY},
        timeout=10.0
    )
    response.raise_for_status()
    return response.json()


def check_public_provider(email: str) -> dict:
    """Call checkboxHQ public provider check endpoint (1 credit)"""

    response = httpx.post(
        f"{settings.CHECKBOXHQ_BASE_URL}/api/v1/verify_public_provider/",
        json={"email": email},
        headers={"x-api-key": settings.CHECKBOXHQ_API_KEY},
        timeout=10.0
    )
    response.raise_for_status()
    return response.json()


def handle_invalid_email(user: User, reason: str):
    """
    Take action when email fails validation.

    Options:
    1. Suspend account
    2. Send notification email
    3. Flag for manual review
    4. Delete account
    """

    if reason == "disposable":
        # Option: Suspend account
        user.account_status = "suspended"
        logger.info(f"Suspended account for disposable email: {user.email}")

        # Option: Send notification
        # send_notification(user.email, "Disposable emails not allowed")

    elif reason == "no_mx_record":
        # Email cannot receive messages
        user.account_status = "suspended"
        logger.info(f"Suspended account - no MX record: {user.email}")

    elif reason == "public_provider":
        # Free email provider (if you're blocking them)
        user.account_status = "pending_review"
        logger.info(f"Flagged public provider account: {user.email}")


def get_db_session():
    """Create database session"""
    from database import SessionLocal
    return SessionLocal()

import { useState } from 'react';
import axios from 'axios';

function SignupForm() {
  const [formData, setFormData] = useState({
    email: '',
    password: '',
    name: ''
  });

  const [status, setStatus] = useState({
    loading: false,
    success: false,
    error: null
  });

  const handleSubmit = async (e) => {
    e.preventDefault();
    setStatus({ loading: true, success: false, error: null });

    try {
      const response = await axios.post(
        'https://api.yourapp.com/api/v1/signup',
        formData
      );

      // Success - user created
      setStatus({ loading: false, success: true, error: null });

      // Store token if your API returns one
      if (response.data.token) {
        localStorage.setItem('token', response.data.token);
      }

      // Show success message
      alert('Account created! Email validation in progress.');

      // Redirect to dashboard
      window.location.href = '/dashboard';

    } catch (error) {
      setStatus({
        loading: false,
        success: false,
        error: error.response?.data?.detail || 'Signup failed. Please try again.'
      });
    }
  };

  return (
    <div className="signup-form">
      <h2>Create Account</h2>

      <form onSubmit={handleSubmit}>
        <div className="form-group">
          <label>Email</label>
          <input
            type="email"
            placeholder="[email protected]"
            value={formData.email}
            onChange={(e) => setFormData({
              ...formData,
              email: e.target.value
            })}
            required
          />
        </div>

        <div className="form-group">
          <label>Name</label>
          <input
            type="text"
            placeholder="John Doe"
            value={formData.name}
            onChange={(e) => setFormData({
              ...formData,
              name: e.target.value
            })}
            required
          />
        </div>

        <div className="form-group">
          <label>Password</label>
          <input
            type="password"
            placeholder="••••••••"
            value={formData.password}
            onChange={(e) => setFormData({
              ...formData,
              password: e.target.value
            })}
            required
            minLength={8}
          />
        </div>

        {status.error && (
          <div className="alert alert-error">
            {status.error}
          </div>
        )}

        <button
          type="submit"
          disabled={status.loading}
          className="btn-primary"
        >
          {status.loading ? 'Creating account...' : 'Sign Up'}
        </button>
      </form>

      <p className="signup-note">
        Your email will be validated in the background.
        You can start using your account immediately.
      </p>
    </div>
  );
}

export default SignupForm;

import { useState, useEffect } from 'react';
import axios from 'axios';

function ValidationStatusBanner() {
  const [status, setStatus] = useState(null);

  useEffect(() => {
    checkStatus();

    // Poll every 5 seconds if validation is in progress
    const interval = setInterval(() => {
      if (status === 'pending' || status === 'validating') {
        checkStatus();
      }
    }, 5000);

    return () => clearInterval(interval);
  }, [status]);

  const checkStatus = async () => {
    try {
      const response = await axios.get('/api/v1/user/me', {
        headers: {
          Authorization: `Bearer ${localStorage.getItem('token')}`
        }
      });

      setStatus(response.data.email_validation_status);

    } catch (error) {
      console.error('Failed to check status:', error);
    }
  };

  // Don't show banner if valid
  if (!status || status === 'valid') {
    return null;
  }

  const getBannerContent = () => {
    switch (status) {
      case 'pending':
      case 'validating':
        return {
          icon: '⏳',
          message: 'Verifying your email address...',
          className: 'banner-info'
        };

      case 'invalid_disposable':
        return {
          icon: '⚠️',
          message: 'Your email appears to be temporary. Please update to a permanent email address.',
          className: 'banner-warning'
        };

      case 'invalid_no_mx':
        return {
          icon: '❌',
          message: 'Your email domain cannot receive emails. Please update your email address.',
          className: 'banner-error'
        };

      case 'failed':
        return {
          icon: '❌',
          message: 'Could not verify your email. Please contact support.',
          className: 'banner-error'
        };

      default:
        return null;
    }
  };

  const content = getBannerContent();
  if (!content) return null;

  return (
    <div className={`validation-banner ${content.className}`}>
      <span className="banner-icon">{content.icon}</span>
      <span className="banner-message">{content.message}</span>
      {(status === 'invalid_disposable' || status === 'invalid_no_mx') && (
        <button
          onClick={() => window.location.href = '/settings/email'}
          className="banner-action"
        >
          Update Email
        </button>
      )}
    </div>
  );
}

export default ValidationStatusBanner;

import pytest
from fastapi.testclient import TestClient
from app.main import app
from time import sleep

client = TestClient(app)

def test_valid_email_signup():
    """Test signup with valid email"""
    response = client.post("/api/v1/signup", json={
        "email": "[email protected]",
        "password": "secure123",
        "name": "Test User"
    })

    assert response.status_code == 200
    assert response.json()["validation_status"] == "pending"

    # Wait for async validation (or mock Celery)
    sleep(3)

    # Check database
    user = db.query(User).filter(User.email == "[email protected]").first()
    assert user.email_validation_status == "valid"


def test_disposable_email_rejected():
    """Test disposable email gets rejected"""
    response = client.post("/api/v1/signup", json={
        "email": "[email protected]",
        "password": "secure123",
        "name": "Disposable User"
    })

    assert response.status_code == 200

    sleep(3)

    user = db.query(User).filter(User.email == "[email protected]").first()
    assert user.email_validation_status == "invalid_disposable"
    assert user.is_disposable == True


def test_invalid_mx_rejected():
    """Test email without MX record gets rejected"""
    response = client.post("/api/v1/signup", json={
        "email": "[email protected]",
        "password": "secure123",
        "name": "No MX User"
    })

    assert response.status_code == 200

    sleep(3)

    user = db.query(User).filter(
        User.email == "[email protected]"
    ).first()
    assert user.email_validation_status == "invalid_no_mx"
    assert user.has_mx_record == False


def test_rate_limiting():
    """Test signup rate limiting works"""

    # Make 6 requests quickly (limit is 5/min)
    for i in range(6):
        response = client.post("/api/v1/signup", json={
            "email": f"test{i}@example.com",
            "password": "secure123",
            "name": f"User {i}"
        })

        if i < 5:
            assert response.status_code == 200
        else:
            assert response.status_code == 429  # Rate limited

import asyncio
import httpx

async def signup(session, email):
    response = await session.post(
        'https://api.yourapp.com/api/v1/signup',
        json={
            "email": email,
            "password": "test123",
            "name": "Load Test"
        }
    )
    return response.status_code

async def load_test():
    async with httpx.AsyncClient() as session:
        tasks = [
            signup(session, f"test{i}@example.com")
            for i in range(100)  # 100 concurrent signups
        ]
        results = await asyncio.gather(*tasks)

    print(f"Success: {results.count(200)}")
    print(f"Rate limited: {results.count(429)}")

asyncio.run(load_test())