"""System routes nested under /api/projects/<project_id>/systems, plus the
project's open-issues list. A System is a per-project, reusable subsystem/area
that records (notes/tasks/issues) associate with."""
import logging

from quart import Blueprint, jsonify, request

from scribe.auth import login_required, get_current_user_id
from scribe.routes.utils import not_found
from scribe.services import systems as systems_svc
from scribe.services.access import can_write_project
from scribe.services.projects import get_project_for_user

logger = logging.getLogger(__name__)

systems_bp = Blueprint("systems", __name__, url_prefix="/api/projects")


def _truthy(v: str | None) -> bool:
    return (v or "").lower() in ("1", "true", "yes")


def _split_records(records: list) -> tuple[list, list, list]:
    issues, tasks, notes = [], [], []
    for r in records:
        d = r.to_dict()
        if r.status is None:
            notes.append(d)
        elif r.task_kind == "issue":
            issues.append(d)
        else:
            tasks.append(d)
    return issues, tasks, notes


@systems_bp.route("/<int:project_id>/systems", methods=["GET"])
@login_required
async def list_systems_route(project_id: int):
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    systems = await systems_svc.list_systems(
        uid, project_id, include_archived=_truthy(request.args.get("include_archived")),
    )
    counts = await systems_svc.open_issue_counts_by_system(uid, project_id)
    out = []
    for s in systems:
        d = s.to_dict()
        d["open_issue_count"] = counts.get(s.id, 0)
        out.append(d)
    return jsonify({"systems": out})


@systems_bp.route("/<int:project_id>/systems", methods=["POST"])
@login_required
async def create_system_route(project_id: int):
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    if not await can_write_project(uid, project_id):
        return jsonify({"error": "Permission denied"}), 403
    data = await request.get_json() or {}
    if not (data.get("name") or "").strip():
        return jsonify({"error": "name is required"}), 400
    system = await systems_svc.create_system(
        uid, project_id=project_id, name=data["name"],
        description=data.get("description"), color=data.get("color"),
        order_index=data.get("order_index", 0),
    )
    if system is None:
        return jsonify({"error": "Permission denied"}), 403
    return jsonify(system.to_dict()), 201


@systems_bp.route("/<int:project_id>/systems/<int:system_id>", methods=["GET"])
@login_required
async def get_system_route(project_id: int, system_id: int):
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    system = await systems_svc.get_system(uid, system_id)
    if system is None or system.project_id != project_id:
        return not_found("System")
    issues, tasks, notes = _split_records(
        await systems_svc.list_records_for_system(uid, system_id)
    )
    data = system.to_dict()
    data["issues"], data["tasks"], data["notes"] = issues, tasks, notes
    return jsonify(data)


@systems_bp.route("/<int:project_id>/systems/<int:system_id>", methods=["PATCH"])
@login_required
async def update_system_route(project_id: int, system_id: int):
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    if not await can_write_project(uid, project_id):
        return jsonify({"error": "Permission denied"}), 403
    system = await systems_svc.get_system(uid, system_id)
    if system is None or system.project_id != project_id:
        return not_found("System")
    data = await request.get_json() or {}
    allowed = {"name", "description", "color", "status", "order_index"}
    fields = {k: v for k, v in data.items() if k in allowed}
    if "status" in fields and fields["status"] not in ("active", "archived"):
        return jsonify({"error": "status must be 'active' or 'archived'"}), 400
    updated = await systems_svc.update_system(uid, system_id, **fields)
    if updated is None:
        return not_found("System")
    return jsonify(updated.to_dict())


@systems_bp.route("/<int:project_id>/systems/<int:system_id>", methods=["DELETE"])
@login_required
async def delete_system_route(project_id: int, system_id: int):
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    if not await can_write_project(uid, project_id):
        return jsonify({"error": "Permission denied"}), 403
    system = await systems_svc.get_system(uid, system_id)
    if system is None or system.project_id != project_id:
        return not_found("System")
    await systems_svc.delete_system(uid, system_id)
    return "", 204


@systems_bp.route("/<int:project_id>/systems/<int:system_id>/records", methods=["GET"])
@login_required
async def system_records_route(project_id: int, system_id: int):
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    system = await systems_svc.get_system(uid, system_id)
    if system is None or system.project_id != project_id:
        return not_found("System")
    records = await systems_svc.list_records_for_system(
        uid, system_id,
        kind=request.args.get("kind") or None,
        open_only=_truthy(request.args.get("open_only")),
    )
    return jsonify({"records": [r.to_dict() for r in records]})


@systems_bp.route("/<int:project_id>/issues", methods=["GET"])
@login_required
async def project_issues_route(project_id: int):
    """A project's issues (open by default — pass open_only=false for all)."""
    uid = get_current_user_id()
    if await get_project_for_user(uid, project_id) is None:
        return not_found("Project")
    open_only = request.args.get("open_only", "true").lower() in ("1", "true", "yes")
    issues = await systems_svc.list_issues(uid, project_id, open_only=open_only)
    return jsonify({"issues": [n.to_dict() for n in issues]})
