import os
import sys

# Ensure backend root is always on python path (for Vercel serverless & local runners)
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from contextlib import asynccontextmanager
from datetime import datetime, timezone
import logging
from fastapi import FastAPI, Header, HTTPException, status
from fastapi.middleware.cors import CORSMiddleware

from config import settings
from database import init_db
from routers import accounts, dns, domains, cloudflare, hosting, users, settings as settings_router
from scheduler import (
    start_scheduler,
    sync_all_domains_job,
    snapshot_dns_records_job,
    send_expiry_alerts_job,
    live_dns_health_check_job,
)

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger = logging.getLogger("domain-platform")


@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup
    logger.info("Initializing database schema...")
    try:
        await init_db()
        logger.info("Database schema initialized.")
    except Exception as e:
        logger.error(f"Failed to initialize database: {e}")

    logger.info(f"Starting application in '{settings.DEPLOY_ENV}' mode")
    start_scheduler()
    yield
    # Shutdown
    logger.info("Shutting down application...")


app = FastAPI(
    title="Domain Management Platform API",
    description="Manage multi-registrar accounts, track expiring domains, and monitor DNS history & health.",
    version="1.0.0",
    lifespan=lifespan,
)

# Enable CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Include Routers
app.include_router(accounts.router)
app.include_router(domains.router)
app.include_router(dns.router)
app.include_router(cloudflare.router)
app.include_router(hosting.router)
app.include_router(users.router)
app.include_router(settings_router.router)


@app.get("/health", tags=["system"])
@app.get("/api/health", tags=["system"])
async def health_check():
    """Health check endpoint."""
    return {
        "status": "healthy",
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "deploy_env": settings.DEPLOY_ENV,
    }


@app.post("/api/cron/{job_name}", tags=["cron"])
async def trigger_cron_job(
    job_name: str,
    x_cron_secret: str = Header(None, alias="X-Cron-Secret"),
):
    """
    Trigger scheduled jobs manually or via Vercel Cron / external webhook.
    Protected by CRON_SECRET header.
    """
    if settings.CRON_SECRET and x_cron_secret != settings.CRON_SECRET:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid Cron Secret")

    if job_name == "sync-domains":
        count = await sync_all_domains_job()
        return {"job": job_name, "status": "completed", "synced_count": count}
    elif job_name == "snapshot-dns":
        count = await snapshot_dns_records_job()
        return {"job": job_name, "status": "completed", "snapshot_count": count}
    elif job_name == "expiry-alerts":
        count = await send_expiry_alerts_job()
        return {"job": job_name, "status": "completed", "alerts_sent": count}
    elif job_name == "dns-health":
        count = await live_dns_health_check_job()
        return {"job": job_name, "status": "completed", "checks_run": count}
    else:
        raise HTTPException(
            status_code=400,
            detail=f"Unknown job '{job_name}'. Valid jobs: sync-domains, snapshot-dns, expiry-alerts, dns-health",
        )