"""Admin routes for blog module — HTML views with Jinja2 templates."""

import os
import json
from datetime import datetime, timedelta
from typing import Optional
from pathlib import Path

from fastapi import APIRouter, Request, Query, HTTPException, Depends
from fastapi.responses import HTMLResponse, RedirectResponse
from starlette.templating import Jinja2Templates as StarletteJinja2Templates
from starlette.staticfiles import StaticFiles

from shared.session_auth import require_auth, get_session, is_authenticated

from .models import CreatePostRequest
from .service import (
    list_posts, get_post, create_post, update_post, preview_markdown,
    PostNotFoundError, DuplicateSlugError
)
from .storage import POSTS_DIR, DATA_DIR


# Path to templates - shared across projects
TEMPLATES_DIR = Path("/home/hoffmann_admin/.openclaw/shared/project-docs/blog/templates")
ADMIN_TEMPLATES_DIR = TEMPLATES_DIR / "admin"
STATIC_DIR = Path("/home/hoffmann_admin/.openclaw/workspace-socrates/hoffdesk-api/static")

# Ensure static directory exists
STATIC_DIR.mkdir(parents=True, exist_ok=True)

# Copy/link admin.css if it doesn't exist
ADMIN_CSS_SOURCE = Path("/home/hoffmann_admin/.openclaw/shared/project-docs/blog/admin.css")
ADMIN_CSS_DEST = STATIC_DIR / "admin.css"

# Custom Jinja2 filters
def relative_time_filter(dt: Optional[datetime]) -> str:
    """Convert datetime to relative time string."""
    if dt is None:
        return "never"
    
    now = datetime.now(dt.tzinfo) if dt.tzinfo else datetime.now()
    diff = now - dt
    
    if diff < timedelta(seconds=10):
        return "just now"
    elif diff < timedelta(minutes=1):
        return f"{int(diff.seconds)} seconds ago"
    elif diff < timedelta(hours=1):
        return f"{int(diff.seconds / 60)} minutes ago"
    elif diff < timedelta(days=1):
        return f"{int(diff.seconds / 3600)} hours ago"
    elif diff < timedelta(days=7):
        return f"{diff.days} days ago"
    elif diff < timedelta(days=30):
        return f"{int(diff.days / 7)} weeks ago"
    else:
        return dt.strftime("%b %d, %Y")


def filesize_filter(size_bytes: int) -> str:
    """Convert bytes to human readable format."""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if size_bytes < 1024:
            return f"{size_bytes:.1f} {unit}"
        size_bytes /= 1024
    return f"{size_bytes:.1f} TB"


# Create templates instance using jinja2 directly
from jinja2 import Environment, FileSystemLoader

jinja_env = Environment(loader=FileSystemLoader(str(ADMIN_TEMPLATES_DIR)))
jinja_env.filters['relative_time'] = relative_time_filter
jinja_env.filters['filesize'] = filesize_filter


admin_router = APIRouter()


def render_template(template_name: str, context: dict) -> HTMLResponse:
    """Render a Jinja2 template to HTML response."""
    template = jinja_env.get_template(template_name)
    html = template.render(**context)
    return HTMLResponse(content=html)


def _get_user_info(request: Request) -> dict:
    """Get current user info for template context."""
    session = get_session(request)
    if session:
        return {
            "user_id": session.get("user_id", "admin"),
            "user_email": session.get("user_email", "admin@hoffdesk.local"),
        }
    return {"user_id": "admin", "user_email": "admin@hoffdesk.local"}


@admin_router.get("/login", response_class=HTMLResponse)
def admin_login_page(request: Request):
    """Show login page if not authenticated."""
    if is_authenticated(request):
        return RedirectResponse(url="/admin/blog/")
    # Redirect to unified login
    return RedirectResponse(url="/login?redirect=/admin/blog/", status_code=302)


@admin_router.post("/login")
async def admin_login_post(request: Request):
    """Handle login form submission - deprecated, use /auth/login."""
    return RedirectResponse(url="/login?redirect=/admin/blog/", status_code=302)


@admin_router.get("/", response_class=HTMLResponse)
def admin_dashboard(request: Request):
    """Admin dashboard with stats and recent posts."""
    # Check auth (session middleware handles redirect, but double-check here)
    if not is_authenticated(request):
        return RedirectResponse(url="/login?redirect=/admin/blog/", status_code=302)
    
    # Get stats
    all_posts = list_posts(page=1, per_page=1000, status=None, include_content=False)
    published_posts = list_posts(page=1, per_page=1000, status="published", include_content=False)
    
    # Calculate stats
    total = all_posts.total
    published = published_posts.total
    drafts = total - published
    
    # Get new this week
    one_week_ago = datetime.now() - timedelta(days=7)
    new_this_week = sum(
        1 for p in all_posts.posts 
        if hasattr(p, 'created_at') and p.created_at and p.created_at > one_week_ago
    )
    
    stats = {
        "total_posts": total,
        "published": published,
        "drafts": drafts,
        "new_this_week": new_this_week,
        "published_change": 0,
    }
    
    # Get recent posts (last 5) - need full PostDetail for updated_at and status
    recent_posts = []
    for post_summary in all_posts.posts[:10]:  # Get first 10 then sort
        try:
            full_post = get_post(post_summary.slug, require_published=False)
            recent_posts.append(full_post)
        except PostNotFoundError:
            pass
    
    recent_posts = sorted(recent_posts, key=lambda p: p.updated_at, reverse=True)[:5]
    
    user_info = _get_user_info(request)
    
    return render_template(
        "admin_dashboard.html.j2",
        {
            "request": request,
            "stats": stats,
            "recent_posts": recent_posts,
            "draft_count": drafts,
            "published_count": published,
            "total_count": total,
            "last_deploy": None,
            "deploy_status": None,
            **user_info,
        }
    )


def get_post_counts() -> dict:
    """Get draft, published, and total post counts for sidebar."""
    all_posts = list_posts(page=1, per_page=1000, status=None, include_content=False)
    published_posts = list_posts(page=1, per_page=1000, status="published", include_content=False)
    return {
        "total_count": all_posts.total,
        "published_count": published_posts.total,
        "draft_count": all_posts.total - published_posts.total,
    }


@admin_router.get("/posts", response_class=HTMLResponse)
def admin_post_list(
    request: Request,
    page: int = Query(1, ge=1),
    status: Optional[str] = Query(None, description="Filter by status"),
):
    """Admin post list with filtering."""
    if not is_authenticated(request):
        return RedirectResponse(url="/login?redirect=/admin/blog/posts", status_code=302)
    
    # Determine status filter
    status_filter = None if status == "all" else status
    
    # Get posts with full details for template
    result = list_posts(
        page=page,
        per_page=20,
        status=status_filter,
        include_content=True  # Need full PostDetail for updated_at
    )
    
    counts = get_post_counts()
    user_info = _get_user_info(request)
    
    context = {
        "request": request,
        "posts": result.posts,
        "current_status": status,
        "current_page": page,
        "total_pages": result.total_pages,
        **counts,
        **user_info,
    }
    
    # If HTMX request, return just the content partial
    if request.headers.get("HX-Request") == "true":
        return render_template("components/post_list_content.html.j2", context)
    
    return render_template("admin_post_list.html.j2", context)


@admin_router.get("/posts/new", response_class=HTMLResponse)
def admin_new_post(request: Request):
    """New post editor page."""
    if not is_authenticated(request):
        return RedirectResponse(url="/login?redirect=/admin/blog/posts/new", status_code=302)
    
    counts = get_post_counts()
    user_info = _get_user_info(request)
    
    return render_template(
        "admin_editor.html.j2",
        {
            "request": request,
            "post": None,
            **counts,
            **user_info,
        }
    )


@admin_router.get("/posts/{slug}/edit", response_class=HTMLResponse)
def admin_edit_post(request: Request, slug: str):
    """Edit post page."""
    if not is_authenticated(request):
        return RedirectResponse(url=f"/login?redirect=/admin/blog/posts/{slug}/edit", status_code=302)
    
    try:
        post = get_post(slug, require_published=False)
    except PostNotFoundError:
        raise HTTPException(status_code=404, detail="Post not found")
    
    counts = get_post_counts()
    user_info = _get_user_info(request)
    
    return render_template(
        "admin_editor.html.j2",
        {
            "request": request,
            "post": post,
            **counts,
            **user_info,
        }
    )


@admin_router.get("/images", response_class=HTMLResponse)
def admin_images(
    request: Request,
    post: Optional[str] = Query(None, description="Filter by post slug")
):
    """Image browser page."""
    if not is_authenticated(request):
        return RedirectResponse(url="/login?redirect=/admin/blog/images", status_code=302)
    
    # Get all posts for the dropdown
    all_posts = list_posts(page=1, per_page=1000, status=None, include_content=False)
    
    # Scan for images in post directories
    images = []
    
    for post_summary in all_posts.posts:
        if post and post_summary.slug != post:
            continue
            
        post_dir = POSTS_DIR / post_summary.slug / "images"
        if post_dir.exists():
            for img_path in post_dir.iterdir():
                if img_path.is_file():
                    stat = img_path.stat()
                    images.append({
                        "name": img_path.name,
                        "url": f"/blog/{post_summary.slug}/images/{img_path.name}",
                        "thumb_url": f"/blog/{post_summary.slug}/images/{img_path.name}",
                        "size": stat.st_size,
                        "post_slug": post_summary.slug,
                    })
    
    counts = get_post_counts()
    user_info = _get_user_info(request)
    
    return render_template(
        "admin_images.html.j2",
        {
            "request": request,
            "images": images,
            "posts": all_posts.posts,
            "current_post": post,
            **counts,
            **user_info,
        }
    )


@admin_router.post("/posts/preview", response_class=HTMLResponse)
async def admin_preview(request: Request):
    """Preview markdown content (HTMX endpoint)."""
    if not is_authenticated(request):
        return RedirectResponse(url="/login?redirect=/admin/blog/", status_code=302)
    
    from urllib.parse import unquote_plus
    
    # Get content from request body
    body = await request.body()
    content = body.decode('utf-8') if body else ""
    
    # Strip 'content=' prefix if present (form encoded)
    if content.startswith('content='):
        content = content[8:]  # Remove 'content='
    
    # URL decode
    content = unquote_plus(content)
    
    # Render markdown
    result = preview_markdown(content)
    
    return HTMLResponse(content=result.content_html)


def setup_admin_static(app):
    """Set up static file serving for admin assets."""
    # Ensure CSS files are linked
    css_sources = [
        (Path("/home/hoffmann_admin/.openclaw/shared/project-docs/blog/admin.css"), "admin.css"),
        (Path("/home/hoffmann_admin/.openclaw/shared/project-docs/blog/static/pipeline.css"), "pipeline.css"),
    ]
    for src, dest_name in css_sources:
        dest = STATIC_DIR / dest_name
        if src.exists() and not dest.exists():
            import shutil
            shutil.copy(src, dest)
    
    # Mount static files
    app.mount("/blog/admin/static", StaticFiles(directory=str(STATIC_DIR)), name="admin_static")