"""Scribe-plugin support endpoints.

Consumed by the Scribe Claude Code plugin (not the web UI). `GET /api/plugin/
context` is curled by the plugin's SessionStart hook to push the operator's
always-on rules + active-project context into the session — Scribe's own push
channel. Auth is the standard `@login_required` path, which accepts a `Bearer
fmcp_<key>` API key (a read-scoped key suffices for this GET).
"""
from __future__ import annotations

from quart import Blueprint, g, jsonify, request

from scribe.auth import admin_required, get_current_user_id, login_required
from scribe.config import Config
from scribe.services import plugin_context as plugin_ctx_svc
from scribe.services import repo_bindings as repo_bindings_svc
from scribe.services.settings import get_admin_setting, set_setting

plugin_bp = Blueprint("plugin", __name__, url_prefix="/api/plugin")

# Setting key for the git URL of the marketplace that serves this plugin (the
# Scribe app's own repo). Instance-global (stored on an admin account) so every
# user's Settings page shows the real, copyable install command.
_MARKETPLACE_KEY = "plugin_marketplace_url"


@plugin_bp.get("/context")
@login_required
async def session_context():
    """Return SessionStart context (always-on rules + active project).

    Query:
        repo (optional str) — the working repo's git remote. The server
            resolves it to the bound project (see services/repo_bindings); an
            unbound repo yields a "bind this repo" hint instead. This is how the
            active project is determined — the plugin never pins a project id.
        project_id (optional int) — explicit override, mainly for manual/ad-hoc
            curl testing; takes precedence over `repo` when set.
    """
    try:
        project_id = int(request.args.get("project_id", 0) or 0)
    except (TypeError, ValueError):
        project_id = 0

    unbound_repo = ""
    repo = (request.args.get("repo") or "").strip()
    if repo and not project_id:
        resolved = await repo_bindings_svc.resolve_project(g.user.id, repo)
        if resolved:
            project_id = resolved
        else:
            unbound_repo = repo_bindings_svc.normalize_repo_key(repo)

    result = await plugin_ctx_svc.build_session_context(
        g.user.id, project_id, unbound_repo=unbound_repo
    )
    return jsonify(result)


@plugin_bp.get("/retrieve")
@login_required
async def autoinject_retrieve():
    """Title-first knowledge auto-inject for the plugin's UserPromptSubmit hook.

    Given the user's prompt (`q`), returns a compact awareness hint — note
    titles + scores only, never bodies — for the top hits that clear the
    per-user gates (see services.plugin_context.build_autoinject_hint). Returns
    empty context (most of the time) when disabled or nothing is relevant.

    Query:
        q (str)            — the user's prompt to retrieve against.
        repo (optional)    — working repo remote; resolved to the bound project
                             to scope the search (mirrors /context). Unbound or
                             absent → searches all the user's notes.
        project_id (opt)   — explicit project scope override (ad-hoc/testing).
        exclude_ids (opt)  — comma-separated note ids already injected this
                             session; skipped so each note injects at most once.
    """
    q = (request.args.get("q") or "").strip()
    try:
        project_id = int(request.args.get("project_id", 0) or 0)
    except (TypeError, ValueError):
        project_id = 0

    repo = (request.args.get("repo") or "").strip()
    if repo and not project_id:
        resolved = await repo_bindings_svc.resolve_project(g.user.id, repo)
        if resolved:
            project_id = resolved

    exclude_ids = [
        int(p) for p in (request.args.get("exclude_ids") or "").split(",")
        if p.strip().isdigit()
    ]

    result = await plugin_ctx_svc.build_autoinject_hint(
        g.user.id, q, project_id=project_id, exclude_ids=exclude_ids
    )
    return jsonify(result)


@plugin_bp.get("/processes")
@login_required
async def process_manifest():
    """Stored Processes as skill-stub specs for the plugin's sync script.

    The plugin's `scribe_sync_processes.sh` (run at SessionStart and via the
    `/scribe:sync` command) curls this and writes one auto-surfacing local skill
    per Process into ~/.claude/skills/. See services/plugin_context.
    build_process_manifest. A read-scoped API key suffices.
    """
    result = await plugin_ctx_svc.build_process_manifest(g.user.id)
    return jsonify(result)


@plugin_bp.get("/marketplace-url")
@login_required
async def get_marketplace_url():
    """The plugin marketplace git URL, readable by any logged-in user so their
    Settings page can show a copyable install command. Falls back to the
    config default (this deployment's own repo) when no admin override is set."""
    url = await get_admin_setting(_MARKETPLACE_KEY, default=Config.PLUGIN_MARKETPLACE_URL)
    return jsonify({"marketplace_url": url})


@plugin_bp.put("/marketplace-url")
@admin_required
async def set_marketplace_url():
    """Admin-set the marketplace git URL (e.g. this app's own repo)."""
    data = await request.get_json() or {}
    url = (data.get("marketplace_url") or "").strip()
    if url:
        scheme = url.split("://")[0].lower() if "://" in url else ""
        if scheme not in ("http", "https"):
            return jsonify({"error": "Marketplace URL must use http or https"}), 400
    await set_setting(get_current_user_id(), _MARKETPLACE_KEY, url)
    return jsonify({"status": "ok"})