import os
import time
import asyncio
from urllib.parse import urlparse
from fastapi import APIRouter, Depends
from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession

from bd.database import get_db, get_redis, DATABASE_URL, REDIS_URL
from route.deps import require_admin

router = APIRouter()

MINIO_ENDPOINT   = os.getenv("MINIO_ENDPOINT",   "minio:9000")
MINIO_ACCESS_KEY = os.getenv("MINIO_ACCESS_KEY",  "minioadmin")
MINIO_SECRET_KEY = os.getenv("MINIO_SECRET_KEY",  "minioadmin")
MINIO_BUCKET     = os.getenv("MINIO_BUCKET",      "news-media")
MINIO_PUBLIC_URL = os.getenv("MINIO_PUBLIC_URL",  "http://localhost:9000")


def _parse_db_url(url: str) -> dict:
    """Вытащить host/port/db/user из DATABASE_URL без пароля."""
    try:
        # postgresql+asyncpg://user:pass@host:port/db
        p = urlparse(url.replace("+asyncpg", ""))
        return {
            "host": p.hostname or "?",
            "port": p.port or 5432,
            "database": (p.path or "/").lstrip("/") or "?",
            "user": p.username or "?",
        }
    except Exception:
        return {"host": "?", "port": 5432, "database": "?", "user": "?"}


def _parse_redis_url(url: str) -> dict:
    """Вытащить host/port из REDIS_URL без пароля."""
    try:
        p = urlparse(url)
        return {
            "host": p.hostname or "?",
            "port": p.port or 6379,
            "db": (p.path or "/0").lstrip("/") or "0",
        }
    except Exception:
        return {"host": "?", "port": 6379, "db": "0"}


async def _check_postgres(db: AsyncSession) -> dict:
    info = _parse_db_url(DATABASE_URL)
    t0 = time.monotonic()
    try:
        result = await db.execute(text("SELECT version()"))
        version = result.scalar() or ""
        latency_ms = round((time.monotonic() - t0) * 1000, 1)
        # Извлекаем короткую версию: "PostgreSQL 15.3 ..."
        short_ver = version.split(",")[0] if version else "?"
        return {"ok": True, "latency_ms": latency_ms, "version": short_ver, **info}
    except Exception as e:
        return {"ok": False, "error": str(e), "latency_ms": None, **info}


async def _check_redis() -> dict:
    info = _parse_redis_url(REDIS_URL)
    t0 = time.monotonic()
    try:
        redis = await get_redis()
        pong = await redis.ping()
        latency_ms = round((time.monotonic() - t0) * 1000, 1)
        server_info = await redis.info("server")
        version = server_info.get("redis_version", "?")
        return {"ok": bool(pong), "latency_ms": latency_ms, "version": f"Redis {version}", **info}
    except Exception as e:
        return {"ok": False, "error": str(e), "latency_ms": None, **info}


async def _check_minio() -> dict:
    t0 = time.monotonic()
    try:
        from minio import Minio
        loop = asyncio.get_event_loop()
        client = Minio(MINIO_ENDPOINT, access_key=MINIO_ACCESS_KEY, secret_key=MINIO_SECRET_KEY, secure=False)
        exists = await loop.run_in_executor(None, client.bucket_exists, MINIO_BUCKET)
        latency_ms = round((time.monotonic() - t0) * 1000, 1)
        return {
            "ok": True,
            "latency_ms": latency_ms,
            "endpoint": MINIO_ENDPOINT,
            "bucket": MINIO_BUCKET,
            "public_url": MINIO_PUBLIC_URL,
            "bucket_exists": exists,
        }
    except Exception as e:
        return {
            "ok": False,
            "error": str(e),
            "latency_ms": None,
            "endpoint": MINIO_ENDPOINT,
            "bucket": MINIO_BUCKET,
            "public_url": MINIO_PUBLIC_URL,
        }


@router.get("/status")
async def system_status(db: AsyncSession = Depends(get_db), _: str = Depends(require_admin)):
    pg, redis, minio = await asyncio.gather(
        _check_postgres(db),
        _check_redis(),
        _check_minio(),
    )
    return {
        "postgres": pg,
        "redis":    redis,
        "minio":    minio,
    }