Kairo-Jinkendo/backend/services/initiatives.py

"""Initiative (Vorhaben) service — tenant-scoped CRUD."""

from __future__ import annotations

from typing import Any, Literal, Optional

from psycopg2.extras import RealDictCursor

from db import get_connection
from entity_archetypes import validate_archetype_key
from services.audit import log_audit

InitiativeStatus = Literal["active", "paused", "completed", "archived"]
Priority = Literal["low", "normal", "high"]

INITIATIVE_STATUSES = frozenset({"active", "paused", "completed", "archived"})
PRIORITIES = frozenset({"low", "normal", "high"})

_INITIATIVE_COLUMNS = """
    id, tenant_id, title, goal, vision, target_state_summary, archetype_key,
    status, priority, portfolio_rank, owner_actor_id, created_at, updated_at
"""


def _serialize_row(row: dict[str, Any]) -> dict[str, Any]:
    result = dict(row)
    for key in ("id", "tenant_id", "owner_actor_id"):
        if result.get(key):
            result[key] = str(result[key])
    if result.get("created_at"):
        result["created_at"] = result["created_at"].isoformat()
    if result.get("updated_at"):
        result["updated_at"] = result["updated_at"].isoformat()
    return result


def _validate_initiative_status(status: str) -> None:
    if status not in INITIATIVE_STATUSES:
        raise ValueError(f"Ungültiger Initiative-Status: {status}")


def _validate_priority(priority: str) -> None:
    if priority not in PRIORITIES:
        raise ValueError(f"Ungültige Priorität: {priority}")


def _actor_in_tenant(*, tenant_id: str, actor_id: str) -> bool:
    conn = get_connection()
    try:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT 1 FROM actors WHERE id = %s AND tenant_id = %s AND is_active = TRUE",
                (actor_id, tenant_id),
            )
            return cur.fetchone() is not None
    finally:
        conn.close()


def _validate_archetype_key(archetype_key: str) -> None:
    validate_archetype_key(entity_type="initiative", archetype_key=archetype_key)


def create_initiative(
    *,
    tenant_id: str,
    title: str,
    owner_actor_id: str,
    goal: str = "",
    vision: str = "",
    target_state_summary: str = "",
    archetype_key: str = "initiative.generic",
    status: InitiativeStatus = "active",
    priority: Priority = "normal",
    user_id: Optional[str] = None,
    method_profile_key: Optional[str] = None,
    apply_starter_kit: bool = True,
) -> dict[str, Any]:
    title = title.strip()
    if not title:
        raise ValueError("Titel ist erforderlich")
    _validate_initiative_status(status)
    _validate_priority(priority)
    _validate_archetype_key(archetype_key)
    if not _actor_in_tenant(tenant_id=tenant_id, actor_id=owner_actor_id):
        raise ValueError("Owner-Actor gehört nicht zum Tenant")

    conn = get_connection()
    try:
        with conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                """
                SELECT COALESCE(MAX(portfolio_rank), -1) + 1 AS next_rank
                FROM initiatives
                WHERE tenant_id = %s
                """,
                (tenant_id,),
            )
            next_rank = int(cur.fetchone()["next_rank"])
            cur.execute(
                f"""
                INSERT INTO initiatives (
                    tenant_id, title, goal, vision, target_state_summary, archetype_key,
                    status, priority, portfolio_rank, owner_actor_id
                )
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                RETURNING {_INITIATIVE_COLUMNS}
                """,
                (
                    tenant_id,
                    title,
                    goal,
                    vision,
                    target_state_summary,
                    archetype_key,
                    status,
                    priority,
                    next_rank,
                    owner_actor_id,
                ),
            )
            row = _serialize_row(dict(cur.fetchone()))
        conn.commit()
    finally:
        conn.close()

    log_audit(
        "initiative.created",
        user_id=user_id,
        tenant_id=tenant_id,
        details={"initiative_id": row["id"], "title": title, "status": status},
    )
    from services.steering_context import create_context_for_new_initiative

    create_context_for_new_initiative(
        tenant_id=tenant_id,
        initiative_id=row["id"],
        user_id=user_id,
        archetype_key=archetype_key,
        method_profile_key=method_profile_key,
    )
    if apply_starter_kit:
        from services.archetype_starter_kit import apply_starter_kit

        starter = apply_starter_kit(
            tenant_id=tenant_id,
            initiative_id=row["id"],
            archetype_key=archetype_key,
            owner_actor_id=owner_actor_id,
            user_id=user_id,
        )
        row["starter_kit"] = starter
    return row


def list_initiatives(*, tenant_id: str) -> list[dict[str, Any]]:
    conn = get_connection()
    try:
        with conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                f"""
                SELECT {_INITIATIVE_COLUMNS}
                FROM initiatives
                WHERE tenant_id = %s
                ORDER BY portfolio_rank ASC NULLS LAST, updated_at DESC, title
                """,
                (tenant_id,),
            )
            return [_serialize_row(dict(row)) for row in cur.fetchall()]
    finally:
        conn.close()


def get_initiative(*, tenant_id: str, initiative_id: str) -> Optional[dict[str, Any]]:
    conn = get_connection()
    try:
        with conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                f"""
                SELECT {_INITIATIVE_COLUMNS}
                FROM initiatives
                WHERE id = %s AND tenant_id = %s
                """,
                (initiative_id, tenant_id),
            )
            row = cur.fetchone()
            return _serialize_row(dict(row)) if row else None
    finally:
        conn.close()


def update_initiative(
    *,
    tenant_id: str,
    initiative_id: str,
    user_id: Optional[str] = None,
    title: Optional[str] = None,
    goal: Optional[str] = None,
    vision: Optional[str] = None,
    target_state_summary: Optional[str] = None,
    archetype_key: Optional[str] = None,
    status: Optional[InitiativeStatus] = None,
    priority: Optional[Priority] = None,
    owner_actor_id: Optional[str] = None,
) -> Optional[dict[str, Any]]:
    existing = get_initiative(tenant_id=tenant_id, initiative_id=initiative_id)
    if not existing:
        return None

    updates: list[str] = []
    params: list[Any] = []
    old_status = existing["status"]

    if title is not None:
        title = title.strip()
        if not title:
            raise ValueError("Titel ist erforderlich")
        updates.append("title = %s")
        params.append(title)
    if goal is not None:
        updates.append("goal = %s")
        params.append(goal)
    if vision is not None:
        updates.append("vision = %s")
        params.append(vision)
    if target_state_summary is not None:
        updates.append("target_state_summary = %s")
        params.append(target_state_summary)
    if archetype_key is not None:
        _validate_archetype_key(archetype_key)
        updates.append("archetype_key = %s")
        params.append(archetype_key)
    if status is not None:
        _validate_initiative_status(status)
        updates.append("status = %s")
        params.append(status)
    if priority is not None:
        _validate_priority(priority)
        updates.append("priority = %s")
        params.append(priority)
    if owner_actor_id is not None:
        if not _actor_in_tenant(tenant_id=tenant_id, actor_id=owner_actor_id):
            raise ValueError("Owner-Actor gehört nicht zum Tenant")
        updates.append("owner_actor_id = %s")
        params.append(owner_actor_id)

    if not updates:
        return existing

    updates.append("updated_at = NOW()")
    params.extend([initiative_id, tenant_id])

    conn = get_connection()
    try:
        with conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                f"""
                UPDATE initiatives
                SET {", ".join(updates)}
                WHERE id = %s AND tenant_id = %s
                RETURNING {_INITIATIVE_COLUMNS}
                """,
                params,
            )
            row = cur.fetchone()
            if not row:
                return None
            result = _serialize_row(dict(row))
        conn.commit()
    finally:
        conn.close()

    log_audit(
        "initiative.updated",
        user_id=user_id,
        tenant_id=tenant_id,
        details={"initiative_id": initiative_id, "fields": updates},
    )
    if status is not None and status != old_status:
        log_audit(
            "initiative.status_changed",
            user_id=user_id,
            tenant_id=tenant_id,
            details={
                "initiative_id": initiative_id,
                "from_status": old_status,
                "to_status": status,
            },
        )
    return result


def delete_initiative(
    *,
    tenant_id: str,
    initiative_id: str,
    user_id: Optional[str] = None,
) -> bool:
    conn = get_connection()
    try:
        with conn.cursor() as cur:
            cur.execute(
                "DELETE FROM initiatives WHERE id = %s AND tenant_id = %s RETURNING id",
                (initiative_id, tenant_id),
            )
            deleted = cur.fetchone() is not None
        conn.commit()
    finally:
        conn.close()

    if deleted:
        log_audit(
            "initiative.deleted",
            user_id=user_id,
            tenant_id=tenant_id,
            details={"initiative_id": initiative_id},
        )
    return deleted


def load_portfolio_rank_map(*, tenant_id: str) -> dict[str, Optional[int]]:
    conn = get_connection()
    try:
        with conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                """
                SELECT id, portfolio_rank
                FROM initiatives
                WHERE tenant_id = %s
                """,
                (tenant_id,),
            )
            return {
                str(row["id"]): row["portfolio_rank"]
                for row in cur.fetchall()
            }
    finally:
        conn.close()


def reorder_portfolio(
    *,
    tenant_id: str,
    initiative_ids: list[str],
    user_id: Optional[str] = None,
) -> list[dict[str, Any]]:
    """Setzt portfolio_rank für alle übergebenen Initiativen (0 = höchste Prio)."""
    if not initiative_ids:
        raise ValueError("initiative_ids darf nicht leer sein")

    unique_ids = list(dict.fromkeys(initiative_ids))
    conn = get_connection()
    try:
        with conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                """
                SELECT id
                FROM initiatives
                WHERE tenant_id = %s
                ORDER BY portfolio_rank ASC NULLS LAST, updated_at DESC, title
                """,
                (tenant_id,),
            )
            all_ids = [str(row["id"]) for row in cur.fetchall()]
            all_set = set(all_ids)
            if set(unique_ids) - all_set:
                raise ValueError("Unbekannte Initiative im Tenant")
            if len(unique_ids) != len(all_ids):
                raise ValueError("Alle Initiativen des Tenants müssen enthalten sein")

            for rank, initiative_id in enumerate(unique_ids):
                cur.execute(
                    """
                    UPDATE initiatives
                    SET portfolio_rank = %s, updated_at = NOW()
                    WHERE id = %s AND tenant_id = %s
                    """,
                    (rank, initiative_id, tenant_id),
                )

            cur.execute(
                f"""
                SELECT {_INITIATIVE_COLUMNS}
                FROM initiatives
                WHERE tenant_id = %s
                ORDER BY portfolio_rank ASC NULLS LAST, updated_at DESC, title
                """,
                (tenant_id,),
            )
            rows = [_serialize_row(dict(row)) for row in cur.fetchall()]
        conn.commit()
    finally:
        conn.close()

    log_audit(
        "portfolio.reordered",
        user_id=user_id,
        tenant_id=tenant_id,
        details={"initiative_ids": unique_ids},
    )
    return rows