#!/usr/bin/env python3
"""
Art DAG L1 Server

Manages rendering runs and provides access to the cache.
- POST /runs - start a run (recipe + inputs)
- GET /runs/{run_id} - get run status/result
- GET /cache/{content_hash} - get cached content
"""

import hashlib
import json
import os
import uuid
from datetime import datetime, timezone
from pathlib import Path
from typing import Optional

from fastapi import FastAPI, HTTPException, UploadFile, File, Depends, Form, Request
from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel

import redis
import requests as http_requests
from urllib.parse import urlparse

from celery_app import app as celery_app
from tasks import render_effect

# L2 server for auth verification
L2_SERVER = os.environ.get("L2_SERVER", "http://localhost:8200")
L2_DOMAIN = os.environ.get("L2_DOMAIN", "artdag.rose-ash.com")

# Cache directory (use /data/cache in Docker, ~/.artdag/cache locally)
CACHE_DIR = Path(os.environ.get("CACHE_DIR", str(Path.home() / ".artdag" / "cache")))
CACHE_DIR.mkdir(parents=True, exist_ok=True)

# Redis for persistent run storage
REDIS_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379/5')
parsed = urlparse(REDIS_URL)
redis_client = redis.Redis(
    host=parsed.hostname or 'localhost',
    port=parsed.port or 6379,
    db=int(parsed.path.lstrip('/') or 0)
)
RUNS_KEY_PREFIX = "artdag:run:"


def save_run(run: "RunStatus"):
    """Save run to Redis."""
    redis_client.set(f"{RUNS_KEY_PREFIX}{run.run_id}", run.model_dump_json())


def load_run(run_id: str) -> Optional["RunStatus"]:
    """Load run from Redis."""
    data = redis_client.get(f"{RUNS_KEY_PREFIX}{run_id}")
    if data:
        return RunStatus.model_validate_json(data)
    return None


def list_all_runs() -> list["RunStatus"]:
    """List all runs from Redis."""
    runs = []
    for key in redis_client.scan_iter(f"{RUNS_KEY_PREFIX}*"):
        data = redis_client.get(key)
        if data:
            runs.append(RunStatus.model_validate_json(data))
    return sorted(runs, key=lambda r: r.created_at, reverse=True)

app = FastAPI(
    title="Art DAG L1 Server",
    description="Distributed rendering server for Art DAG",
    version="0.1.0"
)


class RunRequest(BaseModel):
    """Request to start a run."""
    recipe: str  # Recipe name (e.g., "dog", "identity")
    inputs: list[str]  # List of content hashes
    output_name: Optional[str] = None


class RunStatus(BaseModel):
    """Status of a run."""
    run_id: str
    status: str  # pending, running, completed, failed
    recipe: str
    inputs: list[str]
    output_name: str
    created_at: str
    completed_at: Optional[str] = None
    output_hash: Optional[str] = None
    error: Optional[str] = None
    celery_task_id: Optional[str] = None
    effects_commit: Optional[str] = None
    effect_url: Optional[str] = None  # URL to effect source code
    username: Optional[str] = None  # Owner of the run (ActivityPub actor ID)
    infrastructure: Optional[dict] = None  # Hardware/software used for rendering


# ============ Auth ============

security = HTTPBearer(auto_error=False)


def verify_token_with_l2(token: str) -> Optional[str]:
    """Verify token with L2 server, return username if valid."""
    try:
        resp = http_requests.post(
            f"{L2_SERVER}/auth/verify",
            headers={"Authorization": f"Bearer {token}"},
            timeout=5
        )
        if resp.status_code == 200:
            return resp.json().get("username")
    except Exception:
        pass
    return None


async def get_optional_user(
    credentials: HTTPAuthorizationCredentials = Depends(security)
) -> Optional[str]:
    """Get username if authenticated, None otherwise."""
    if not credentials:
        return None
    return verify_token_with_l2(credentials.credentials)


async def get_required_user(
    credentials: HTTPAuthorizationCredentials = Depends(security)
) -> str:
    """Get username, raise 401 if not authenticated."""
    if not credentials:
        raise HTTPException(401, "Not authenticated")
    username = verify_token_with_l2(credentials.credentials)
    if not username:
        raise HTTPException(401, "Invalid token")
    return username


def file_hash(path: Path) -> str:
    """Compute SHA3-256 hash of a file."""
    hasher = hashlib.sha3_256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            hasher.update(chunk)
    return hasher.hexdigest()


def cache_file(source: Path) -> str:
    """Copy file to cache, return content hash."""
    content_hash = file_hash(source)
    cache_path = CACHE_DIR / content_hash
    if not cache_path.exists():
        import shutil
        shutil.copy2(source, cache_path)
    return content_hash


@app.get("/api")
async def api_info():
    """Server info (JSON)."""
    return {
        "name": "Art DAG L1 Server",
        "version": "0.1.0",
        "cache_dir": str(CACHE_DIR),
        "runs_count": len(list_all_runs())
    }


HOME_HTML = """
<!DOCTYPE html>
<html>
<head>
    <title>Art DAG L1 Server</title>
    <style>
        * { box-sizing: border-box; }
        body {
            font-family: system-ui, -apple-system, sans-serif;
            margin: 0; padding: 40px;
            background: #111; color: #eee;
            line-height: 1.6;
        }
        .container { max-width: 800px; margin: 0 auto; }
        h1 { color: #fff; border-bottom: 1px solid #333; padding-bottom: 10px; }
        h2 { color: #ccc; margin-top: 30px; }
        a { color: #60a5fa; }
        a:hover { color: #93c5fd; }
        code {
            background: #222; padding: 2px 6px; border-radius: 4px;
            font-family: 'SF Mono', Monaco, monospace;
        }
        pre {
            background: #1a1a1a; padding: 16px; border-radius: 8px;
            overflow-x: auto; border: 1px solid #333;
        }
        pre code { background: none; padding: 0; }
        table { border-collapse: collapse; width: 100%; margin: 16px 0; }
        th, td { border: 1px solid #333; padding: 8px 12px; text-align: left; }
        th { background: #222; }
        .nav {
            background: #1a1a1a; padding: 16px; border-radius: 8px;
            margin-bottom: 30px; display: flex; gap: 20px;
        }
        .nav a {
            font-weight: 500; text-decoration: none;
            padding: 8px 16px; background: #333; border-radius: 4px;
        }
        .nav a:hover { background: #444; }
    </style>
</head>
<body>
    <div class="container">
        <div class="nav">
            <a href="/ui">Runs UI</a>
            <a href="/docs">API Docs</a>
            <a href="/api">API Info</a>
        </div>
        <h1>Art DAG L1 Server</h1>
        <p>L1 rendering server for the Art DAG system. Manages distributed rendering jobs via Celery workers.</p>

        <h2>Dependencies</h2>
        <ul>
            <li><strong>artdag</strong> (GitHub): Core DAG execution engine</li>
            <li><strong>artdag-effects</strong> (rose-ash): Effect implementations</li>
            <li><strong>Redis</strong>: Message broker, result backend, and run persistence</li>
        </ul>

        <h2>API Endpoints</h2>
        <table>
            <tr><th>Method</th><th>Path</th><th>Description</th></tr>
            <tr><td>GET</td><td><code>/ui</code></td><td>Web UI for viewing runs</td></tr>
            <tr><td>POST</td><td><code>/runs</code></td><td>Start a rendering run</td></tr>
            <tr><td>GET</td><td><code>/runs</code></td><td>List all runs</td></tr>
            <tr><td>GET</td><td><code>/runs/{run_id}</code></td><td>Get run status</td></tr>
            <tr><td>GET</td><td><code>/cache</code></td><td>List cached content hashes</td></tr>
            <tr><td>GET</td><td><code>/cache/{hash}</code></td><td>Download cached content</td></tr>
            <tr><td>POST</td><td><code>/cache/upload</code></td><td>Upload file to cache</td></tr>
            <tr><td>GET</td><td><code>/assets</code></td><td>List known assets</td></tr>
        </table>

        <h2>Start a Run</h2>
        <pre><code>curl -X POST /runs \\
  -H "Content-Type: application/json" \\
  -d '{"recipe": "dog", "inputs": ["33268b6e..."]}'</code></pre>

        <h2>Provenance</h2>
        <p>Every render produces a provenance record linking inputs, effects, and infrastructure:</p>
        <pre><code>{
  "output": {"content_hash": "..."},
  "inputs": [...],
  "effects": [...],
  "infrastructure": {...}
}</code></pre>
    </div>
</body>
</html>
"""


@app.get("/", response_class=HTMLResponse)
async def root():
    """Home page."""
    return HOME_HTML


@app.post("/runs", response_model=RunStatus)
async def create_run(request: RunRequest, username: str = Depends(get_required_user)):
    """Start a new rendering run. Requires authentication."""
    run_id = str(uuid.uuid4())

    # Generate output name if not provided
    output_name = request.output_name or f"{request.recipe}-{run_id[:8]}"

    # Format username as ActivityPub actor ID
    actor_id = f"@{username}@{L2_DOMAIN}"

    # Create run record
    run = RunStatus(
        run_id=run_id,
        status="pending",
        recipe=request.recipe,
        inputs=request.inputs,
        output_name=output_name,
        created_at=datetime.now(timezone.utc).isoformat(),
        username=actor_id
    )

    # Submit to Celery
    # For now, we only support single-input recipes
    if len(request.inputs) != 1:
        raise HTTPException(400, "Currently only single-input recipes supported")

    input_hash = request.inputs[0]

    task = render_effect.delay(input_hash, request.recipe, output_name)
    run.celery_task_id = task.id
    run.status = "running"

    save_run(run)
    return run


@app.get("/runs/{run_id}", response_model=RunStatus)
async def get_run(run_id: str):
    """Get status of a run."""
    run = load_run(run_id)
    if not run:
        raise HTTPException(404, f"Run {run_id} not found")

    # Check Celery task status if running
    if run.status == "running" and run.celery_task_id:
        task = celery_app.AsyncResult(run.celery_task_id)

        if task.ready():
            if task.successful():
                result = task.result
                run.status = "completed"
                run.completed_at = datetime.now(timezone.utc).isoformat()
                run.output_hash = result.get("output", {}).get("content_hash")

                # Extract effects info from provenance
                effects = result.get("effects", [])
                if effects:
                    run.effects_commit = effects[0].get("repo_commit")
                    run.effect_url = effects[0].get("repo_url")

                # Extract infrastructure info
                run.infrastructure = result.get("infrastructure")

                # Cache the output
                output_path = Path(result.get("output", {}).get("local_path", ""))
                if output_path.exists():
                    cache_file(output_path)
            else:
                run.status = "failed"
                run.error = str(task.result)

            # Save updated status
            save_run(run)

    return run


@app.get("/runs")
async def list_runs():
    """List all runs."""
    return list_all_runs()


@app.get("/cache/{content_hash}")
async def get_cached(content_hash: str):
    """Get cached content by hash."""
    cache_path = CACHE_DIR / content_hash

    if not cache_path.exists():
        raise HTTPException(404, f"Content {content_hash} not in cache")

    return FileResponse(cache_path)


@app.get("/ui/cache/{content_hash}", response_class=HTMLResponse)
async def ui_cache_view(content_hash: str, request: Request):
    """View cached content with appropriate display."""
    current_user = get_user_from_cookie(request)
    if not current_user:
        return HTMLResponse(f'''
<!DOCTYPE html>
<html>
<head><title>Login Required | Art DAG L1</title><style>{UI_CSS}</style></head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <div class="run"><p><a href="/ui/login">Login</a> to view cached content.</p></div>
</body>
</html>
''', status_code=401)

    # Check user has access to this file
    user_hashes = get_user_cache_hashes(current_user)
    if content_hash not in user_hashes:
        return HTMLResponse('<h1>Access denied</h1>', status_code=403)

    cache_path = CACHE_DIR / content_hash

    if not cache_path.exists():
        return HTMLResponse(f"""
<!DOCTYPE html>
<html>
<head><title>Not Found | Art DAG L1</title><style>{UI_CSS}</style></head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <a href="/ui" class="back-btn">&larr; Back to runs</a>
    <div class="run"><p>Content not found: {content_hash}</p></div>
</body>
</html>
""", status_code=404)

    media_type = detect_media_type(cache_path)
    file_size = cache_path.stat().st_size
    size_str = f"{file_size:,} bytes"
    if file_size > 1024*1024:
        size_str = f"{file_size/(1024*1024):.1f} MB"
    elif file_size > 1024:
        size_str = f"{file_size/1024:.1f} KB"

    html = f"""
<!DOCTYPE html>
<html>
<head>
    <title>{content_hash[:16]}... | Art DAG L1</title>
    <style>{UI_CSS}</style>
</head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <a href="/ui" class="back-btn">&larr; Back to runs</a>

    <div class="run">
        <div class="run-header">
            <div>
                <span class="run-recipe">{media_type.capitalize()}</span>
                <span class="run-id">{content_hash[:32]}...</span>
            </div>
            <a href="/cache/{content_hash}" download class="status completed" style="text-decoration:none;">Download</a>
        </div>

        <div class="media-container" style="margin: 20px 0;">
"""

    if media_type == "video":
        html += f'<video src="/cache/{content_hash}" controls autoplay muted loop style="max-width:100%;max-height:500px;"></video>'
    elif media_type == "image":
        html += f'<img src="/cache/{content_hash}" alt="{content_hash}" style="max-width:100%;max-height:500px;">'
    else:
        html += f'<p>Unknown file type. <a href="/cache/{content_hash}" download>Download file</a></p>'

    html += f"""
        </div>

        <div class="provenance">
            <h2>Details</h2>
            <div class="prov-item">
                <div class="prov-label">Content Hash (SHA3-256)</div>
                <div class="prov-value">{content_hash}</div>
            </div>
            <div class="prov-item">
                <div class="prov-label">Type</div>
                <div class="prov-value">{media_type}</div>
            </div>
            <div class="prov-item">
                <div class="prov-label">Size</div>
                <div class="prov-value">{size_str}</div>
            </div>
            <div class="prov-item">
                <div class="prov-label">Raw URL</div>
                <div class="prov-value"><a href="/cache/{content_hash}">/cache/{content_hash}</a></div>
            </div>
        </div>
    </div>
</body>
</html>
"""
    return html


@app.get("/cache")
async def list_cache():
    """List cached content hashes."""
    return [f.name for f in CACHE_DIR.iterdir() if f.is_file()]


# Known assets (bootstrap data)
KNOWN_ASSETS = {
    "cat": "33268b6e167deaf018cc538de12dbe562612b33e89a749391cef855b320a269b",
}


@app.get("/assets")
async def list_assets():
    """List known assets."""
    return KNOWN_ASSETS


@app.post("/cache/import")
async def import_to_cache(path: str):
    """Import a local file to cache."""
    source = Path(path)
    if not source.exists():
        raise HTTPException(404, f"File not found: {path}")

    content_hash = cache_file(source)
    return {"content_hash": content_hash, "cached": True}


def save_cache_meta(content_hash: str, uploader: str = None, filename: str = None, **updates):
    """Save or update metadata for a cached file."""
    meta_path = CACHE_DIR / f"{content_hash}.meta.json"

    # Load existing or create new
    if meta_path.exists():
        with open(meta_path) as f:
            meta = json.load(f)
    else:
        meta = {
            "uploader": uploader,
            "uploaded_at": datetime.now(timezone.utc).isoformat(),
            "filename": filename
        }

    # Apply updates (but never change uploader or uploaded_at)
    for key, value in updates.items():
        if key not in ("uploader", "uploaded_at"):
            meta[key] = value

    with open(meta_path, "w") as f:
        json.dump(meta, f, indent=2)

    return meta


def load_cache_meta(content_hash: str) -> dict:
    """Load metadata for a cached file."""
    meta_path = CACHE_DIR / f"{content_hash}.meta.json"
    if meta_path.exists():
        with open(meta_path) as f:
            return json.load(f)
    return {}


# User data storage (folders, collections)
USER_DATA_DIR = CACHE_DIR / ".user-data"


def load_user_data(username: str) -> dict:
    """Load user's folders and collections."""
    USER_DATA_DIR.mkdir(parents=True, exist_ok=True)
    # Normalize username (remove @ prefix if present)
    safe_name = username.replace("@", "").replace("/", "_")
    user_file = USER_DATA_DIR / f"{safe_name}.json"
    if user_file.exists():
        with open(user_file) as f:
            return json.load(f)
    return {"folders": ["/"], "collections": []}


def save_user_data(username: str, data: dict):
    """Save user's folders and collections."""
    USER_DATA_DIR.mkdir(parents=True, exist_ok=True)
    safe_name = username.replace("@", "").replace("/", "_")
    user_file = USER_DATA_DIR / f"{safe_name}.json"
    with open(user_file, "w") as f:
        json.dump(data, f, indent=2)


def get_user_cache_hashes(username: str) -> set:
    """Get all cache hashes owned by or associated with a user."""
    actor_id = f"@{username}@{L2_DOMAIN}"
    hashes = set()

    # Files uploaded by user
    if CACHE_DIR.exists():
        for f in CACHE_DIR.iterdir():
            if f.name.endswith('.meta.json'):
                meta = load_cache_meta(f.name.replace('.meta.json', ''))
                if meta.get("uploader") in (username, actor_id):
                    hashes.add(f.name.replace('.meta.json', ''))

    # Files from user's runs (inputs and outputs)
    for run in list_all_runs():
        if run.username in (username, actor_id):
            hashes.update(run.inputs)
            if run.output_hash:
                hashes.add(run.output_hash)

    return hashes


@app.post("/cache/upload")
async def upload_to_cache(file: UploadFile = File(...), username: str = Depends(get_required_user)):
    """Upload a file to cache. Requires authentication."""
    # Write to temp file first
    import tempfile
    with tempfile.NamedTemporaryFile(delete=False) as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = Path(tmp.name)

    # Hash and move to cache
    content_hash = file_hash(tmp_path)
    cache_path = CACHE_DIR / content_hash

    if not cache_path.exists():
        import shutil
        shutil.move(str(tmp_path), cache_path)
    else:
        tmp_path.unlink()

    # Save uploader metadata
    actor_id = f"@{username}@{L2_DOMAIN}"
    save_cache_meta(content_hash, actor_id, file.filename)

    return {"content_hash": content_hash, "filename": file.filename, "size": len(content)}


class CacheMetaUpdate(BaseModel):
    """Request to update cache metadata."""
    origin: Optional[dict] = None  # {"type": "self"|"external", "url": "...", "note": "..."}
    description: Optional[str] = None
    tags: Optional[list[str]] = None
    folder: Optional[str] = None
    collections: Optional[list[str]] = None


class PublishRequest(BaseModel):
    """Request to publish a cache item to L2."""
    asset_name: str
    asset_type: str = "image"  # image, video, etc.


@app.get("/cache/{content_hash}/meta")
async def get_cache_meta(content_hash: str, username: str = Depends(get_required_user)):
    """Get metadata for a cached file."""
    # Check file exists
    cache_path = CACHE_DIR / content_hash
    if not cache_path.exists():
        raise HTTPException(404, "Content not found")

    # Check ownership
    user_hashes = get_user_cache_hashes(username)
    if content_hash not in user_hashes:
        raise HTTPException(403, "Access denied")

    return load_cache_meta(content_hash)


@app.patch("/cache/{content_hash}/meta")
async def update_cache_meta(content_hash: str, update: CacheMetaUpdate, username: str = Depends(get_required_user)):
    """Update metadata for a cached file."""
    # Check file exists
    cache_path = CACHE_DIR / content_hash
    if not cache_path.exists():
        raise HTTPException(404, "Content not found")

    # Check ownership
    user_hashes = get_user_cache_hashes(username)
    if content_hash not in user_hashes:
        raise HTTPException(403, "Access denied")

    # Build update dict from non-None fields
    updates = {}
    if update.origin is not None:
        updates["origin"] = update.origin
    if update.description is not None:
        updates["description"] = update.description
    if update.tags is not None:
        updates["tags"] = update.tags
    if update.folder is not None:
        # Ensure folder exists in user's folder list
        user_data = load_user_data(username)
        if update.folder not in user_data["folders"]:
            raise HTTPException(400, f"Folder does not exist: {update.folder}")
        updates["folder"] = update.folder
    if update.collections is not None:
        # Validate collections exist
        user_data = load_user_data(username)
        existing = {c["name"] for c in user_data["collections"]}
        for col in update.collections:
            if col not in existing:
                raise HTTPException(400, f"Collection does not exist: {col}")
        updates["collections"] = update.collections

    meta = save_cache_meta(content_hash, **updates)
    return meta


@app.post("/cache/{content_hash}/publish")
async def publish_cache_to_l2(
    content_hash: str,
    req: PublishRequest,
    request: Request,
    username: str = Depends(get_required_user)
):
    """
    Publish a cache item to L2 (ActivityPub).

    Requires origin to be set in metadata before publishing.
    """
    # Check file exists
    cache_path = CACHE_DIR / content_hash
    if not cache_path.exists():
        raise HTTPException(404, "Content not found")

    # Check ownership
    user_hashes = get_user_cache_hashes(username)
    if content_hash not in user_hashes:
        raise HTTPException(403, "Access denied")

    # Load metadata
    meta = load_cache_meta(content_hash)

    # Check origin is set
    origin = meta.get("origin")
    if not origin or "type" not in origin:
        raise HTTPException(400, "Origin must be set before publishing. Use --origin self or --origin-url <url>")

    # Get auth token to pass to L2
    token = request.cookies.get("auth_token")
    if not token:
        # Try from header
        auth_header = request.headers.get("Authorization", "")
        if auth_header.startswith("Bearer "):
            token = auth_header[7:]

    if not token:
        raise HTTPException(401, "Authentication token required")

    # Call L2 publish-cache endpoint
    try:
        resp = http_requests.post(
            f"{L2_SERVER}/registry/publish-cache",
            headers={"Authorization": f"Bearer {token}"},
            json={
                "content_hash": content_hash,
                "asset_name": req.asset_name,
                "asset_type": req.asset_type,
                "origin": origin,
                "description": meta.get("description"),
                "tags": meta.get("tags", []),
                "metadata": {
                    "filename": meta.get("filename"),
                    "folder": meta.get("folder"),
                    "collections": meta.get("collections", [])
                }
            },
            timeout=10
        )
        resp.raise_for_status()
        l2_result = resp.json()
    except http_requests.exceptions.HTTPError as e:
        error_detail = ""
        try:
            error_detail = e.response.json().get("detail", str(e))
        except Exception:
            error_detail = str(e)
        raise HTTPException(400, f"L2 publish failed: {error_detail}")
    except Exception as e:
        raise HTTPException(500, f"L2 publish failed: {e}")

    # Update local metadata with publish status
    publish_info = {
        "to_l2": True,
        "asset_name": req.asset_name,
        "published_at": datetime.now(timezone.utc).isoformat(),
        "last_synced_at": datetime.now(timezone.utc).isoformat()
    }
    save_cache_meta(content_hash, published=publish_info)

    return {
        "published": True,
        "asset_name": req.asset_name,
        "l2_result": l2_result
    }


@app.patch("/cache/{content_hash}/republish")
async def republish_cache_to_l2(
    content_hash: str,
    request: Request,
    username: str = Depends(get_required_user)
):
    """
    Re-publish (update) a cache item on L2 after metadata changes.

    Only works for already-published items.
    """
    # Check file exists
    cache_path = CACHE_DIR / content_hash
    if not cache_path.exists():
        raise HTTPException(404, "Content not found")

    # Check ownership
    user_hashes = get_user_cache_hashes(username)
    if content_hash not in user_hashes:
        raise HTTPException(403, "Access denied")

    # Load metadata
    meta = load_cache_meta(content_hash)

    # Check already published
    published = meta.get("published", {})
    if not published.get("to_l2"):
        raise HTTPException(400, "Item not published yet. Use publish first.")

    asset_name = published.get("asset_name")
    if not asset_name:
        raise HTTPException(400, "No asset name found in publish info")

    # Get auth token
    token = request.cookies.get("auth_token")
    if not token:
        auth_header = request.headers.get("Authorization", "")
        if auth_header.startswith("Bearer "):
            token = auth_header[7:]

    if not token:
        raise HTTPException(401, "Authentication token required")

    # Call L2 update endpoint
    try:
        resp = http_requests.patch(
            f"{L2_SERVER}/registry/{asset_name}",
            headers={"Authorization": f"Bearer {token}"},
            json={
                "description": meta.get("description"),
                "tags": meta.get("tags"),
                "origin": meta.get("origin"),
                "metadata": {
                    "filename": meta.get("filename"),
                    "folder": meta.get("folder"),
                    "collections": meta.get("collections", [])
                }
            },
            timeout=10
        )
        resp.raise_for_status()
        l2_result = resp.json()
    except http_requests.exceptions.HTTPError as e:
        error_detail = ""
        try:
            error_detail = e.response.json().get("detail", str(e))
        except Exception:
            error_detail = str(e)
        raise HTTPException(400, f"L2 update failed: {error_detail}")
    except Exception as e:
        raise HTTPException(500, f"L2 update failed: {e}")

    # Update local metadata
    published["last_synced_at"] = datetime.now(timezone.utc).isoformat()
    save_cache_meta(content_hash, published=published)

    return {
        "updated": True,
        "asset_name": asset_name,
        "l2_result": l2_result
    }


# ============ Folder & Collection Management ============

@app.get("/user/folders")
async def list_folders(username: str = Depends(get_required_user)):
    """List user's folders."""
    user_data = load_user_data(username)
    return {"folders": user_data["folders"]}


@app.post("/user/folders")
async def create_folder(folder_path: str, username: str = Depends(get_required_user)):
    """Create a new folder."""
    user_data = load_user_data(username)

    # Validate path format
    if not folder_path.startswith("/"):
        raise HTTPException(400, "Folder path must start with /")

    # Check parent exists
    parent = "/".join(folder_path.rsplit("/", 1)[:-1]) or "/"
    if parent != "/" and parent not in user_data["folders"]:
        raise HTTPException(400, f"Parent folder does not exist: {parent}")

    # Check doesn't already exist
    if folder_path in user_data["folders"]:
        raise HTTPException(400, f"Folder already exists: {folder_path}")

    user_data["folders"].append(folder_path)
    user_data["folders"].sort()
    save_user_data(username, user_data)

    return {"folder": folder_path, "created": True}


@app.delete("/user/folders")
async def delete_folder(folder_path: str, username: str = Depends(get_required_user)):
    """Delete a folder (must be empty)."""
    if folder_path == "/":
        raise HTTPException(400, "Cannot delete root folder")

    user_data = load_user_data(username)

    if folder_path not in user_data["folders"]:
        raise HTTPException(404, "Folder not found")

    # Check no subfolders
    for f in user_data["folders"]:
        if f.startswith(folder_path + "/"):
            raise HTTPException(400, f"Folder has subfolders: {f}")

    # Check no items in folder
    user_hashes = get_user_cache_hashes(username)
    for h in user_hashes:
        meta = load_cache_meta(h)
        if meta.get("folder") == folder_path:
            raise HTTPException(400, "Folder is not empty")

    user_data["folders"].remove(folder_path)
    save_user_data(username, user_data)

    return {"folder": folder_path, "deleted": True}


@app.get("/user/collections")
async def list_collections(username: str = Depends(get_required_user)):
    """List user's collections."""
    user_data = load_user_data(username)
    return {"collections": user_data["collections"]}


@app.post("/user/collections")
async def create_collection(name: str, username: str = Depends(get_required_user)):
    """Create a new collection."""
    user_data = load_user_data(username)

    # Check doesn't already exist
    for col in user_data["collections"]:
        if col["name"] == name:
            raise HTTPException(400, f"Collection already exists: {name}")

    user_data["collections"].append({
        "name": name,
        "created_at": datetime.now(timezone.utc).isoformat()
    })
    save_user_data(username, user_data)

    return {"collection": name, "created": True}


@app.delete("/user/collections")
async def delete_collection(name: str, username: str = Depends(get_required_user)):
    """Delete a collection."""
    user_data = load_user_data(username)

    # Find and remove
    for i, col in enumerate(user_data["collections"]):
        if col["name"] == name:
            user_data["collections"].pop(i)
            save_user_data(username, user_data)

            # Remove from all cache items
            user_hashes = get_user_cache_hashes(username)
            for h in user_hashes:
                meta = load_cache_meta(h)
                if name in meta.get("collections", []):
                    meta["collections"].remove(name)
                    save_cache_meta(h, **{k: v for k, v in meta.items() if k not in ("uploader", "uploaded_at")})

            return {"collection": name, "deleted": True}

    raise HTTPException(404, "Collection not found")


def detect_media_type(cache_path: Path) -> str:
    """Detect if file is image or video based on magic bytes."""
    with open(cache_path, "rb") as f:
        header = f.read(32)

    # Video signatures
    if header[:4] == b'\x1a\x45\xdf\xa3':  # WebM/MKV
        return "video"
    if header[4:8] == b'ftyp':  # MP4/MOV
        return "video"
    if header[:4] == b'RIFF' and header[8:12] == b'AVI ':  # AVI
        return "video"

    # Image signatures
    if header[:8] == b'\x89PNG\r\n\x1a\n':  # PNG
        return "image"
    if header[:2] == b'\xff\xd8':  # JPEG
        return "image"
    if header[:6] in (b'GIF87a', b'GIF89a'):  # GIF
        return "image"
    if header[:4] == b'RIFF' and header[8:12] == b'WEBP':  # WebP
        return "image"

    return "unknown"


def get_user_from_cookie(request) -> Optional[str]:
    """Get username from auth cookie."""
    token = request.cookies.get("auth_token")
    if not token:
        return None
    return verify_token_with_l2(token)


UI_CSS = """
        * { box-sizing: border-box; }
        body {
            font-family: system-ui, -apple-system, sans-serif;
            margin: 0; padding: 24px;
            background: #111; color: #eee;
            font-size: 16px;
        }
        h1 { margin: 0 0 24px 0; color: #fff; font-size: 28px; }
        h2 { color: #ccc; margin: 24px 0 12px 0; font-size: 20px; }
        a { color: #60a5fa; text-decoration: none; }
        a:hover { color: #93c5fd; text-decoration: underline; }
        .runs { display: flex; flex-direction: column; gap: 16px; max-width: 900px; }
        .run {
            background: #222; border-radius: 8px; padding: 20px;
            border: 1px solid #333;
        }
        .run-link { display: block; text-decoration: none; color: inherit; max-width: 900px; }
        .run-link:hover .run { border-color: #555; background: #282828; }
        .run-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 14px; }
        .run-id { font-family: monospace; font-size: 14px; color: #888; margin-left: 12px; }
        .run-recipe { font-weight: bold; font-size: 22px; color: #fff; }
        .status {
            padding: 6px 14px; border-radius: 12px; font-size: 14px; font-weight: 500;
        }
        .status.completed { background: #1a4d1a; color: #4ade80; }
        .status.running { background: #4d4d1a; color: #facc15; }
        .status.failed { background: #4d1a1a; color: #f87171; }
        .status.pending { background: #333; color: #888; }
        .media-row { display: flex; gap: 20px; margin-top: 16px; flex-wrap: wrap; justify-content: flex-start; }
        .media-box { flex: 0 1 auto; min-width: 200px; max-width: 400px; }
        .media-box label { font-size: 13px; color: #888; display: block; margin-bottom: 6px; }
        .media-container { }
        .media-container img, .media-container video {
            max-width: 100%; max-height: 300px; border-radius: 4px;
        }
        @media (max-width: 600px) {
            .media-row { flex-direction: column; }
            .media-box { min-width: 100%; max-width: 100%; }
        }
        .hash { font-family: monospace; font-size: 13px; color: #666; }
        .hash a { color: #888; }
        .hash a:hover { color: #60a5fa; }
        .info { font-size: 15px; color: #aaa; }
        .refresh-btn, .back-btn {
            background: #333; color: #fff; border: none; padding: 10px 20px;
            border-radius: 4px; cursor: pointer; margin-bottom: 20px;
            text-decoration: none; display: inline-block; font-size: 15px;
        }
        .refresh-btn:hover, .back-btn:hover { background: #444; }
        .no-runs { color: #666; font-style: italic; font-size: 16px; }
        .provenance { background: #1a1a1a; border-radius: 8px; padding: 20px; margin-top: 20px; max-width: 700px; }
        .prov-item { margin: 12px 0; }
        .prov-label { color: #888; font-size: 14px; margin-bottom: 4px; }
        .prov-value { font-family: monospace; font-size: 15px; word-break: break-all; }
        code { background: #222; padding: 2px 6px; border-radius: 4px; }
"""

def render_ui_html(username: Optional[str] = None, tab: str = "runs") -> str:
    """Render main UI HTML with optional user context."""
    user_info = ""
    if username:
        user_info = f'''
        <div style="float:right;font-size:14px;color:#888;">
            Logged in as <strong>{username}</strong>
            <a href="/ui/logout" style="margin-left:12px;">Logout</a>
        </div>
        '''
    else:
        user_info = '''
        <div style="float:right;font-size:14px;">
            <a href="/ui/login">Login</a>
        </div>
        '''

    runs_active = "active" if tab == "runs" else ""
    cache_active = "active" if tab == "cache" else ""

    runs_content = ""
    cache_content = ""
    if tab == "runs":
        runs_content = '''
        <div id="content" hx-get="/ui/runs" hx-trigger="load" hx-swap="innerHTML">
            Loading...
        </div>
        '''
    else:
        cache_content = '''
        <div id="content" hx-get="/ui/cache-list" hx-trigger="load" hx-swap="innerHTML">
            Loading...
        </div>
        '''

    return f"""
<!DOCTYPE html>
<html>
<head>
    <title>Art DAG L1 Server</title>
    <script src="https://unpkg.com/htmx.org@1.9.10"></script>
    <style>{UI_CSS}
    .nav-tabs {{ margin-bottom: 20px; }}
    .nav-tabs a {{
        padding: 10px 20px;
        margin-right: 8px;
        background: #333;
        border-radius: 4px 4px 0 0;
        color: #888;
    }}
    .nav-tabs a.active {{ background: #1a1a1a; color: #fff; }}
    .nav-tabs a:hover {{ color: #fff; }}
    </style>
</head>
<body>
    {user_info}
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <div class="nav-tabs">
        <a href="/ui" class="{runs_active}">Runs</a>
        <a href="/ui?tab=cache" class="{cache_active}">Cache</a>
    </div>
    {runs_content}
    {cache_content}
</body>
</html>
"""


UI_LOGIN_HTML = """
<!DOCTYPE html>
<html>
<head>
    <title>Login | Art DAG L1 Server</title>
    <style>""" + UI_CSS + """
        .login-form { max-width: 400px; }
        .login-form input {
            width: 100%; padding: 12px; margin: 8px 0;
            background: #222; border: 1px solid #333; border-radius: 4px;
            color: #eee; font-size: 15px;
        }
        .login-form button {
            width: 100%; padding: 12px; margin-top: 12px;
            background: #2563eb; color: #fff; border: none; border-radius: 4px;
            font-size: 15px; cursor: pointer;
        }
        .login-form button:hover { background: #1d4ed8; }
        .error { color: #f87171; margin-top: 12px; }
        .tabs { margin-bottom: 20px; }
        .tabs a { padding: 8px 16px; margin-right: 8px; background: #333; border-radius: 4px; }
        .tabs a.active { background: #2563eb; }
    </style>
</head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <a href="/ui" class="back-btn">&larr; Back</a>

    <div class="run login-form">
        <div class="tabs">
            <a href="/ui/login" class="active">Login</a>
            <a href="/ui/register">Register</a>
        </div>
        <form method="POST" action="/ui/login">
            <input type="text" name="username" placeholder="Username" required>
            <input type="password" name="password" placeholder="Password" required>
            <button type="submit">Login</button>
        </form>
    </div>
</body>
</html>
"""


UI_REGISTER_HTML = """
<!DOCTYPE html>
<html>
<head>
    <title>Register | Art DAG L1 Server</title>
    <style>""" + UI_CSS + """
        .login-form { max-width: 400px; }
        .login-form input {
            width: 100%; padding: 12px; margin: 8px 0;
            background: #222; border: 1px solid #333; border-radius: 4px;
            color: #eee; font-size: 15px;
        }
        .login-form button {
            width: 100%; padding: 12px; margin-top: 12px;
            background: #2563eb; color: #fff; border: none; border-radius: 4px;
            font-size: 15px; cursor: pointer;
        }
        .login-form button:hover { background: #1d4ed8; }
        .error { color: #f87171; margin-top: 12px; }
        .tabs { margin-bottom: 20px; }
        .tabs a { padding: 8px 16px; margin-right: 8px; background: #333; border-radius: 4px; }
        .tabs a.active { background: #2563eb; }
    </style>
</head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <a href="/ui" class="back-btn">&larr; Back</a>

    <div class="run login-form">
        <div class="tabs">
            <a href="/ui/login">Login</a>
            <a href="/ui/register" class="active">Register</a>
        </div>
        <form method="POST" action="/ui/register">
            <input type="text" name="username" placeholder="Username" required>
            <input type="password" name="password" placeholder="Password" required>
            <input type="email" name="email" placeholder="Email (optional)">
            <button type="submit">Register</button>
        </form>
    </div>
</body>
</html>
"""


@app.get("/ui", response_class=HTMLResponse)
async def ui_index(request: Request, tab: str = "runs"):
    """Web UI for viewing runs and cache."""
    username = get_user_from_cookie(request)
    return render_ui_html(username, tab)


@app.get("/ui/login", response_class=HTMLResponse)
async def ui_login_page():
    """Login page."""
    return UI_LOGIN_HTML


@app.post("/ui/login")
async def ui_login(username: str = Form(...), password: str = Form(...)):
    """Process login form."""
    try:
        resp = http_requests.post(
            f"{L2_SERVER}/auth/login",
            json={"username": username, "password": password},
            timeout=5
        )
        if resp.status_code == 200:
            token = resp.json().get("access_token")
            response = RedirectResponse(url="/ui", status_code=303)
            response.set_cookie("auth_token", token, httponly=True, max_age=30*24*60*60)
            return response
    except Exception:
        pass

    return HTMLResponse(UI_LOGIN_HTML.replace(
        '</form>',
        '<p class="error">Invalid username or password</p></form>'
    ))


@app.get("/ui/register", response_class=HTMLResponse)
async def ui_register_page():
    """Register page."""
    return UI_REGISTER_HTML


@app.post("/ui/register")
async def ui_register(
    username: str = Form(...),
    password: str = Form(...),
    email: str = Form(None)
):
    """Process registration form."""
    try:
        resp = http_requests.post(
            f"{L2_SERVER}/auth/register",
            json={"username": username, "password": password, "email": email},
            timeout=5
        )
        if resp.status_code == 200:
            token = resp.json().get("access_token")
            response = RedirectResponse(url="/ui", status_code=303)
            response.set_cookie("auth_token", token, httponly=True, max_age=30*24*60*60)
            return response
        elif resp.status_code == 400:
            error = resp.json().get("detail", "Registration failed")
            return HTMLResponse(UI_REGISTER_HTML.replace(
                '</form>',
                f'<p class="error">{error}</p></form>'
            ))
    except Exception as e:
        return HTMLResponse(UI_REGISTER_HTML.replace(
            '</form>',
            f'<p class="error">Registration failed: {e}</p></form>'
        ))


@app.get("/ui/logout")
async def ui_logout():
    """Logout - clear cookie."""
    response = RedirectResponse(url="/ui", status_code=303)
    response.delete_cookie("auth_token")
    return response


@app.get("/ui/runs", response_class=HTMLResponse)
async def ui_runs(request: Request):
    """HTMX partial: list of runs."""
    current_user = get_user_from_cookie(request)
    runs = list_all_runs()

    # Require login to see runs
    if not current_user:
        return '<p class="no-runs"><a href="/ui/login">Login</a> to see your runs.</p>'

    # Filter runs by user - match both plain username and ActivityPub format (@user@domain)
    actor_id = f"@{current_user}@{L2_DOMAIN}"
    runs = [r for r in runs if r.username in (current_user, actor_id)]

    if not runs:
        return '<p class="no-runs">You have no runs yet. Use the CLI to start a run.</p>'

    html_parts = ['<div class="runs">']

    for run in runs[:20]:  # Limit to 20 most recent
        status_class = run.status
        effect_url = f"https://git.rose-ash.com/art-dag/effects/src/branch/main/{run.recipe}"
        owner_badge = f'<span style="font-size:11px;color:#666;margin-left:8px;">by {run.username or "anonymous"}</span>' if not current_user else ''

        html_parts.append(f'''
        <a href="/ui/detail/{run.run_id}" class="run-link">
        <div class="run" hx-get="/ui/run/{run.run_id}" hx-trigger="every 2s[this.querySelector('.status.running')]" hx-swap="outerHTML">
            <div class="run-header">
                <div>
                    <span class="run-recipe">{run.recipe}</span>
                    <span class="run-id">{run.run_id}</span>{owner_badge}
                </div>
                <span class="status {status_class}">{run.status}</span>
            </div>
            <div class="info">
                Created: {run.created_at[:19].replace('T', ' ')}
            </div>
        ''')

        # Show input and output side by side
        has_input = run.inputs and (CACHE_DIR / run.inputs[0]).exists()
        has_output = run.status == "completed" and run.output_hash and (CACHE_DIR / run.output_hash).exists()

        if has_input or has_output:
            html_parts.append('<div class="media-row">')

            # Input box
            if has_input:
                input_hash = run.inputs[0]
                input_media_type = detect_media_type(CACHE_DIR / input_hash)
                html_parts.append(f'''
                <div class="media-box">
                    <label>Input: {input_hash[:24]}...</label>
                    <div class="media-container">
                ''')
                if input_media_type == "video":
                    html_parts.append(f'<video src="/cache/{input_hash}" controls muted loop></video>')
                elif input_media_type == "image":
                    html_parts.append(f'<img src="/cache/{input_hash}" alt="input">')
                html_parts.append('</div></div>')

            # Output box
            if has_output:
                output_hash = run.output_hash
                output_media_type = detect_media_type(CACHE_DIR / output_hash)
                html_parts.append(f'''
                <div class="media-box">
                    <label>Output: {output_hash[:24]}...</label>
                    <div class="media-container">
                ''')
                if output_media_type == "video":
                    html_parts.append(f'<video src="/cache/{output_hash}" controls autoplay muted loop></video>')
                elif output_media_type == "image":
                    html_parts.append(f'<img src="/cache/{output_hash}" alt="output">')
                html_parts.append('</div></div>')

            html_parts.append('</div>')

        # Show error if failed
        if run.status == "failed" and run.error:
            html_parts.append(f'<div class="info" style="color: #f87171;">Error: {run.error}</div>')

        html_parts.append('</div></a>')

    html_parts.append('</div>')
    return '\n'.join(html_parts)


@app.get("/ui/cache-list", response_class=HTMLResponse)
async def ui_cache_list(
    request: Request,
    folder: Optional[str] = None,
    collection: Optional[str] = None,
    tag: Optional[str] = None
):
    """HTMX partial: list of cached items with optional filtering."""
    current_user = get_user_from_cookie(request)

    # Require login to see cache
    if not current_user:
        return '<p class="no-runs"><a href="/ui/login">Login</a> to see cached content.</p>'

    # Get hashes owned by/associated with this user
    user_hashes = get_user_cache_hashes(current_user)

    # Get cache items that belong to the user
    cache_items = []
    if CACHE_DIR.exists():
        for f in CACHE_DIR.iterdir():
            if f.is_file() and not f.name.endswith('.provenance.json') and not f.name.endswith('.meta.json'):
                if f.name in user_hashes:
                    # Load metadata for filtering
                    meta = load_cache_meta(f.name)

                    # Apply folder filter
                    if folder:
                        item_folder = meta.get("folder", "/")
                        if folder != "/" and not item_folder.startswith(folder):
                            continue
                        if folder == "/" and item_folder != "/":
                            continue

                    # Apply collection filter
                    if collection:
                        if collection not in meta.get("collections", []):
                            continue

                    # Apply tag filter
                    if tag:
                        if tag not in meta.get("tags", []):
                            continue

                    stat = f.stat()
                    cache_items.append({
                        "hash": f.name,
                        "size": stat.st_size,
                        "mtime": stat.st_mtime,
                        "meta": meta
                    })

    # Sort by modification time (newest first)
    cache_items.sort(key=lambda x: x["mtime"], reverse=True)

    if not cache_items:
        filter_msg = ""
        if folder:
            filter_msg = f" in folder {folder}"
        elif collection:
            filter_msg = f" in collection '{collection}'"
        elif tag:
            filter_msg = f" with tag '{tag}'"
        return f'<p class="no-runs">No cached files{filter_msg}. Upload files or run effects to see them here.</p>'

    html_parts = ['<div class="runs">']

    for item in cache_items[:50]:  # Limit to 50 items
        content_hash = item["hash"]
        cache_path = CACHE_DIR / content_hash
        media_type = detect_media_type(cache_path)

        # Format size
        size = item["size"]
        if size > 1024*1024:
            size_str = f"{size/(1024*1024):.1f} MB"
        elif size > 1024:
            size_str = f"{size/1024:.1f} KB"
        else:
            size_str = f"{size} bytes"

        html_parts.append(f'''
        <a href="/ui/cache/{content_hash}" class="run-link">
        <div class="run">
            <div class="run-header">
                <div>
                    <span class="run-recipe">{media_type}</span>
                    <span class="run-id">{content_hash}</span>
                </div>
                <span class="status completed">{size_str}</span>
            </div>
            <div class="media-row">
                <div class="media-box" style="max-width: 300px;">
                    <div class="media-container">
        ''')

        if media_type == "video":
            html_parts.append(f'<video src="/cache/{content_hash}" controls muted loop style="max-height:150px;"></video>')
        elif media_type == "image":
            html_parts.append(f'<img src="/cache/{content_hash}" alt="{content_hash[:16]}" style="max-height:150px;">')
        else:
            html_parts.append(f'<p>Unknown file type</p>')

        html_parts.append('''
                    </div>
                </div>
            </div>
        </div>
        </a>
        ''')

    html_parts.append('</div>')
    return '\n'.join(html_parts)


@app.get("/ui/detail/{run_id}", response_class=HTMLResponse)
async def ui_detail_page(run_id: str, request: Request):
    """Full detail page for a run."""
    current_user = get_user_from_cookie(request)
    if not current_user:
        return HTMLResponse(f'''
<!DOCTYPE html>
<html>
<head><title>Login Required | Art DAG L1</title><style>{UI_CSS}</style></head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <div class="run"><p><a href="/ui/login">Login</a> to view run details.</p></div>
</body>
</html>
''', status_code=401)

    run = load_run(run_id)
    if not run:
        return HTMLResponse('<h1>Run not found</h1>', status_code=404)

    # Check user owns this run
    actor_id = f"@{current_user}@{L2_DOMAIN}"
    if run.username not in (current_user, actor_id):
        return HTMLResponse('<h1>Access denied</h1>', status_code=403)

    # Check Celery task status if running
    if run.status == "running" and run.celery_task_id:
        task = celery_app.AsyncResult(run.celery_task_id)
        if task.ready():
            if task.successful():
                result = task.result
                run.status = "completed"
                run.completed_at = datetime.now(timezone.utc).isoformat()
                run.output_hash = result.get("output", {}).get("content_hash")
                # Extract effects info from provenance
                effects = result.get("effects", [])
                if effects:
                    run.effects_commit = effects[0].get("repo_commit")
                    run.effect_url = effects[0].get("repo_url")
                # Extract infrastructure info
                run.infrastructure = result.get("infrastructure")
                output_path = Path(result.get("output", {}).get("local_path", ""))
                if output_path.exists():
                    cache_file(output_path)
            else:
                run.status = "failed"
                run.error = str(task.result)
            save_run(run)

    # Use stored effect URL or build fallback
    if run.effect_url:
        effect_url = run.effect_url
    elif run.effects_commit and run.effects_commit != "unknown":
        effect_url = f"https://git.rose-ash.com/art-dag/effects/src/commit/{run.effects_commit}/{run.recipe}"
    else:
        effect_url = f"https://git.rose-ash.com/art-dag/effects/src/branch/main/{run.recipe}"
    status_class = run.status

    html = f"""
<!DOCTYPE html>
<html>
<head>
    <title>{run.recipe} - {run.run_id[:8]} | Art DAG L1</title>
    <style>{UI_CSS}</style>
</head>
<body>
    <h1><a href="/ui" style="color: inherit;">Art DAG L1 Server</a></h1>
    <a href="/ui" class="back-btn">&larr; Back to runs</a>

    <div class="run">
        <div class="run-header">
            <div>
                <a href="{effect_url}" target="_blank" class="run-recipe">{run.recipe}</a>
                <span class="run-id">{run.run_id}</span>
            </div>
            <span class="status {status_class}">{run.status}</span>
        </div>
"""

    # Media row
    has_input = run.inputs and (CACHE_DIR / run.inputs[0]).exists()
    has_output = run.status == "completed" and run.output_hash and (CACHE_DIR / run.output_hash).exists()

    if has_input or has_output:
        html += '<div class="media-row">'

        if has_input:
            input_hash = run.inputs[0]
            input_media_type = detect_media_type(CACHE_DIR / input_hash)
            html += f'''
            <div class="media-box">
                <label>Input: <a href="/ui/cache/{input_hash}">{input_hash[:24]}...</a></label>
                <div class="media-container">
            '''
            if input_media_type == "video":
                html += f'<video src="/cache/{input_hash}" controls muted loop></video>'
            elif input_media_type == "image":
                html += f'<img src="/cache/{input_hash}" alt="input">'
            html += '</div></div>'

        if has_output:
            output_hash = run.output_hash
            output_media_type = detect_media_type(CACHE_DIR / output_hash)
            html += f'''
            <div class="media-box">
                <label>Output: <a href="/ui/cache/{output_hash}">{output_hash[:24]}...</a></label>
                <div class="media-container">
            '''
            if output_media_type == "video":
                html += f'<video src="/cache/{output_hash}" controls autoplay muted loop></video>'
            elif output_media_type == "image":
                html += f'<img src="/cache/{output_hash}" alt="output">'
            html += '</div></div>'

        html += '</div>'

    # Provenance section
    html += f'''
    <div class="provenance">
        <h2>Provenance</h2>
        <div class="prov-item">
            <div class="prov-label">Owner</div>
            <div class="prov-value">{run.username or "anonymous"}</div>
        </div>
        <div class="prov-item">
            <div class="prov-label">Effect</div>
            <div class="prov-value"><a href="{effect_url}" target="_blank">{run.recipe}</a></div>
        </div>
        <div class="prov-item">
            <div class="prov-label">Effects Commit</div>
            <div class="prov-value">{run.effects_commit or "N/A"}</div>
        </div>
        <div class="prov-item">
            <div class="prov-label">Input(s)</div>
            <div class="prov-value">
    '''
    for inp in run.inputs:
        html += f'<a href="/ui/cache/{inp}">{inp}</a><br>'
    html += f'''
            </div>
        </div>
    '''

    if run.output_hash:
        html += f'''
        <div class="prov-item">
            <div class="prov-label">Output</div>
            <div class="prov-value"><a href="/ui/cache/{run.output_hash}">{run.output_hash}</a></div>
        </div>
        '''

    # Infrastructure section
    if run.infrastructure:
        software = run.infrastructure.get("software", {})
        hardware = run.infrastructure.get("hardware", {})
        html += f'''
        <div class="prov-item">
            <div class="prov-label">Infrastructure</div>
            <div class="prov-value">
                Software: {software.get("name", "unknown")} ({software.get("content_hash", "unknown")[:16]}...)<br>
                Hardware: {hardware.get("name", "unknown")} ({hardware.get("content_hash", "unknown")[:16]}...)
            </div>
        </div>
        '''

    html += f'''
        <div class="prov-item">
            <div class="prov-label">Run ID</div>
            <div class="prov-value">{run.run_id}</div>
        </div>
        <div class="prov-item">
            <div class="prov-label">Created</div>
            <div class="prov-value">{run.created_at}</div>
        </div>
    '''

    if run.completed_at:
        html += f'''
        <div class="prov-item">
            <div class="prov-label">Completed</div>
            <div class="prov-value">{run.completed_at}</div>
        </div>
        '''

    if run.error:
        html += f'''
        <div class="prov-item">
            <div class="prov-label">Error</div>
            <div class="prov-value" style="color: #f87171;">{run.error}</div>
        </div>
        '''

    # Raw JSON provenance
    provenance_json = json.dumps({
        "run_id": run.run_id,
        "status": run.status,
        "recipe": run.recipe,
        "effects_commit": run.effects_commit,
        "effect_url": run.effect_url or effect_url,
        "inputs": run.inputs,
        "output_hash": run.output_hash,
        "output_name": run.output_name,
        "created_at": run.created_at,
        "completed_at": run.completed_at,
        "username": run.username,
        "infrastructure": run.infrastructure,
        "error": run.error
    }, indent=2)

    html += f'''
        <h2>Raw JSON</h2>
        <pre style="background:#0a0a0a;padding:16px;border-radius:8px;overflow-x:auto;font-size:13px;"><code>{provenance_json}</code></pre>
    </div>
    </div>
</body>
</html>
'''
    return html


@app.get("/ui/run/{run_id}", response_class=HTMLResponse)
async def ui_run_partial(run_id: str):
    """HTMX partial: single run (for polling updates)."""
    run = load_run(run_id)
    if not run:
        return '<div class="run">Run not found</div>'

    # Check Celery task status if running
    if run.status == "running" and run.celery_task_id:
        task = celery_app.AsyncResult(run.celery_task_id)
        if task.ready():
            if task.successful():
                result = task.result
                run.status = "completed"
                run.completed_at = datetime.now(timezone.utc).isoformat()
                run.output_hash = result.get("output", {}).get("content_hash")
                # Extract effects info from provenance
                effects = result.get("effects", [])
                if effects:
                    run.effects_commit = effects[0].get("repo_commit")
                    run.effect_url = effects[0].get("repo_url")
                # Extract infrastructure info
                run.infrastructure = result.get("infrastructure")
                output_path = Path(result.get("output", {}).get("local_path", ""))
                if output_path.exists():
                    cache_file(output_path)
            else:
                run.status = "failed"
                run.error = str(task.result)
            save_run(run)

    status_class = run.status
    poll_attr = 'hx-get="/ui/run/{}" hx-trigger="every 2s" hx-swap="outerHTML"'.format(run_id) if run.status == "running" else ""

    html = f'''
    <div class="run" {poll_attr}>
        <div class="run-header">
            <div>
                <span class="run-recipe">{run.recipe}</span>
                <span class="run-id">{run.run_id}</span>
            </div>
            <span class="status {status_class}">{run.status}</span>
        </div>
        <div class="info">
            Created: {run.created_at[:19].replace('T', ' ')}
        </div>
    '''

    # Show input and output side by side
    has_input = run.inputs and (CACHE_DIR / run.inputs[0]).exists()
    has_output = run.status == "completed" and run.output_hash and (CACHE_DIR / run.output_hash).exists()

    if has_input or has_output:
        html += '<div class="media-row">'

        if has_input:
            input_hash = run.inputs[0]
            input_media_type = detect_media_type(CACHE_DIR / input_hash)
            html += f'<div class="media-box"><label>Input: <a href="/ui/cache/{input_hash}">{input_hash[:24]}...</a></label><div class="media-container">'
            if input_media_type == "video":
                html += f'<video src="/cache/{input_hash}" controls muted loop></video>'
            elif input_media_type == "image":
                html += f'<img src="/cache/{input_hash}" alt="input">'
            html += '</div></div>'

        if has_output:
            output_hash = run.output_hash
            output_media_type = detect_media_type(CACHE_DIR / output_hash)
            html += f'<div class="media-box"><label>Output: <a href="/ui/cache/{output_hash}">{output_hash[:24]}...</a></label><div class="media-container">'
            if output_media_type == "video":
                html += f'<video src="/cache/{output_hash}" controls autoplay muted loop></video>'
            elif output_media_type == "image":
                html += f'<img src="/cache/{output_hash}" alt="output">'
            html += '</div></div>'

        html += '</div>'

    if run.status == "failed" and run.error:
        html += f'<div class="info" style="color: #f87171;">Error: {run.error}</div>'

    html += '</div>'
    return html


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8100)