ERP/bot/app/handlers/material.py

"""Add-material flow: name + canonical unit (required)."""
import logging

from app import drafts as draft_store
from app import matching
from app import observability as obs
from app.api.client import ApiError
from app.drafts import (
    KIND_MATERIAL, merge_material_patch, material_missing, new_material_payload,
)
from app.keyboards import pick_buttons, simple_review_keyboard
from app.nlu import normalize_text
from app.texts import ERR_GENERIC, esc, material_committed_report, material_review_text

logger = logging.getLogger("bot.material")


async def handle_entities(ctx, chat_id, user, patch: dict, source: str | None,
                          trace_id: str | None = None,
                          jev_map: dict | None = None) -> None:
    draft = await draft_store.get_active(chat_id, KIND_MATERIAL)
    if draft is not None:
        payload = draft.payload
        merge_material_patch(payload, patch)
    else:
        payload = new_material_payload()
        merge_material_patch(payload, patch)
        draft = await draft_store.create(chat_id, KIND_MATERIAL, payload, source=source)
    await obs.link_draft(trace_id, draft.id, draft.kind)
    await resolve_payload(ctx, payload, trace_id, jev_map)
    await draft_store.save_payload(draft, missing={"fields": material_missing(payload)})
    await render(ctx, chat_id, draft, fresh=draft.review_message_id is None, trace_id=trace_id)


async def resolve_payload(ctx, payload: dict, trace_id: str | None = None,
                          jev_map: dict | None = None) -> None:
    options = payload.setdefault("options", {})
    if not payload.get("canonical_unit_id") and payload.get("unit_name"):
        hit = matching.lookup(jev_map, payload["unit_name"])
        if hit is not None:
            if hit["status"] == "exact":
                payload["canonical_unit_id"] = hit["id"]
                payload["unit_name"] = hit["name"]
                options.pop("unit", None)
            elif hit["status"] == "ambiguity" and hit.get("candidates"):
                options["unit"] = [{"id": c["id"], "name": c["name"]}
                                   for c in hit["candidates"][:6]]
            elif hit["status"] == "new":
                options.pop("unit", None)
        else:
            try:
                units = await ctx.resolver.units()
            except Exception:
                units = []
            norm_u = normalize_text(payload["unit_name"])
            exact = [u for u in units if normalize_text(u.name) == norm_u or (u.extra or {}).get("code") == norm_u]
            if len(exact) == 1:
                payload["canonical_unit_id"] = exact[0].id
                payload["unit_name"] = exact[0].name
                options.pop("unit", None)
            else:
                options.pop("unit", None)


async def apply_pick(ctx, chat_id, user, draft, field: str, choice: dict) -> None:
    if field == "unit":
        draft.payload["canonical_unit_id"] = choice["id"]
        draft.payload["unit_name"] = choice["name"]
        draft.payload.setdefault("options", {}).pop("unit", None)
    await draft_store.save_payload(draft, missing={"fields": material_missing(draft.payload)})
    await render(ctx, chat_id, draft, fresh=False)


def _keyboard(payload: dict, draft_id: str) -> dict:
    rows: list[list[dict]] = []
    options = (payload.get("options") or {}).get("unit") or []
    if options:
        rows += pick_buttons(draft_id, "unit", [o["name"] for o in options[:6]])
    return simple_review_keyboard(draft_id, KIND_MATERIAL, rows)


async def render(ctx, chat_id, draft, fresh: bool = True, trace_id: str | None = None) -> None:
    payload = draft.payload
    missing = material_missing(payload)
    text = material_review_text(payload, missing)
    keyboard = _keyboard(payload, draft.id)
    if fresh:
        message = await ctx.send(chat_id, text, reply_markup=keyboard)
        draft.review_message_id = (message or {}).get("message_id")
        await draft_store.save_payload(draft, missing={"fields": missing},
                                       review_message_id=draft.review_message_id)
    else:
        await ctx.edit(chat_id, draft.review_message_id, text, reply_markup=keyboard)
        await draft_store.save_payload(draft, missing={"fields": missing})
    await obs.event(trace_id or await obs.latest_trace_for_draft(draft.id), "draft.render",
                    payload={"fresh": fresh, "missing": [m.get("key") for m in missing if not m.get("ok")]})


async def commit(ctx, chat_id, user, draft, trace_id: str | None = None) -> None:
    payload = draft.payload
    trace_id = trace_id or await obs.latest_trace_for_draft(draft.id)
    await resolve_payload(ctx, payload, trace_id)
    missing = {m["key"]: m["ok"] for m in material_missing(payload)}
    problems = [label for key, label, ok in [
        ("name", "نام کالا", missing.get("name")),
        ("unit", "واحد اصلی", missing.get("unit")),
    ] if not ok]
    if problems:
        await ctx.send(chat_id, "ثبت ممکن نیست؛ اول این‌ها را مشخص کن:\n" +
                       "\n".join(f"❌ {esc(p)}" for p in problems))
        return
    body = {"name": payload["name"], "canonical_unit_id": int(payload["canonical_unit_id"])}
    if payload.get("topic"):
        body["topic"] = payload["topic"]
    try:
        created = await ctx.api.create_material(body, actor_id=user.actor_id)
    except ApiError as exc:
        await ctx.send(chat_id, ERR_GENERIC.format(detail=esc(exc.message)))
        return
    await draft_store.set_status(draft.id, "committed")
    await obs.event(trace_id, "draft.commit", payload={"kind": "material",
                                                       "material_id": (created or {}).get("id")})
    await obs.set_trace_status(trace_id, "committed")
    ctx.resolver.invalidate()
    await ctx.send(chat_id, material_committed_report(created))