DataTable(
    id: str,
    model: list[dict] | None = None,
    rows: list[dict] | None = None,
    page: int = 0,
    page_size: int = 25,
    total_rows: int = 0,
    remote_service: str | dict | None = None,
    pagination: bool | None = None,
    on_page_change: str | None = None,
    on_cell_edit: str | None = None,
    on_row_add: str | None = None,
    on_row_delete: str | None = None,
    on_filter_change: str | None = None,
    show_row_numbers: bool = False,
    selectable: bool = False,
    row_actions: list[dict] | None = None,
    selection_actions: list[dict] | None = None,
    paginated: bool = True,
    virtual: bool = False,
    auto_refresh: int | None = None,
    sort_field: str | None = None,
    sort_direction: str = "asc",
)

model = [
    {"field": "id", "header": "ID", "type": "int", "width": 70, "editable": False, "sortable": True},
    {"field": "name", "header": "Name", "type": "str", "editable": True, "filterable": True, "filter_type": "text"},
    {"field": "role", "header": "Role", "type": "enum", "editable": True, "filterable": True, "filter_type": "select", "options": ["Admin", "Editor", "Viewer"]},
    {"field": "active", "header": "Active", "type": "bool", "editable": True, "filterable": True, "filter_type": "boolean"},
    {"field": "joined", "header": "Joined", "type": "str", "transform": "date|%Y-%m-%d"},
    {"field": "tags", "header": "Tags", "type": "str", "transform": "join_list|, |upper"},
]

rows = [
    {
        "id": 101,
        "name": "Ada Lovelace",
        "role": "Admin",
        "status": "active",
        "team": "Platform",
        "spend": 1840,
        "selectable": True,
    },
    {
        "id": 104,
        "name": "Margaret Hamilton",
        "role": "Admin",
        "status": "locked",
        "team": "Platform",
        "spend": 2110,
        "selectable": False,
    },
]

{"item": row, "item_index": row_index, "tableId": table_id}

{"selected_ids": [...], "selected_rows": [...], "tableId": table_id}

{
    "page": 0,
    "pageSize": 25,
    "filters": {"status": "active"},
    "sort": {"field": "name", "direction": "asc"},
    "sortField": "name",
    "sortDirection": "asc",
    "tableId": "users_table",
    "autoRefresh": True,  # only on auto-refresh
}

from __future__ import annotations

from typing import Any

from democrai.sdk.decorators import action


def _table_id(ctx: dict[str, Any], default: str = "objective_mappings_table") -> str:
    return str(ctx.get("tableId") or ctx.get("table_id") or default).strip()


def _page(ctx: dict[str, Any]) -> int:
    return max(0, int(ctx.get("page", 0) or 0))


def _page_size(ctx: dict[str, Any]) -> int:
    return max(1, min(int(ctx.get("pageSize", 25) or 25), 200))


def _filters(ctx: dict[str, Any]) -> dict[str, Any]:
    raw = ctx.get("filters") or {}
    if not isinstance(raw, dict):
        return {}
    return {
        str(key): value
        for key, value in raw.items()
        if value is not None and value != ""
    }


def _sort(ctx: dict[str, Any], default_field: str = "name") -> dict[str, str]:
    raw = ctx.get("sort") or {}
    if not isinstance(raw, dict):
        raw = {}
    field = str(raw.get("field") or raw.get("sortField") or default_field).strip()
    direction = str(raw.get("direction") or raw.get("sortDirection") or "asc").lower()
    return {"field": field or default_field, "direction": "desc" if direction == "desc" else "asc"}


def _surface_id(ctx: dict[str, Any]) -> str:
    return str(ctx.get("_surface_id") or "main").strip() or "main"


def _refresh_table(module_sdk, ctx: dict[str, Any]):
    table_id = _table_id(ctx)
    page = _page(ctx)
    page_size = _page_size(ctx)
    filters = _filters(ctx)
    sort = _sort(ctx)

    listing = module_sdk.models.objective_mappings.list(
        page=page,
        page_size=page_size,
        filters=filters,
        sort=sort,
    )
    rows = list(listing.get("rows") or [])
    total_rows = int(listing.get("total_rows") or 0)
    resolved_page = int(listing.get("page") or page)
    resolved_page_size = int(listing.get("page_size") or page_size)
    resolved_sort = dict(listing.get("sort") or sort)
    surface_id = _surface_id(ctx)

    return module_sdk.effects.respond(
        module_sdk.effects.ui_property_update(table_id, "rows", rows, action="set", surface_id=surface_id),
        module_sdk.effects.ui_property_update(table_id, "page", resolved_page, surface_id=surface_id),
        module_sdk.effects.ui_property_update(table_id, "page_size", resolved_page_size, surface_id=surface_id),
        module_sdk.effects.ui_property_update(table_id, "total_rows", total_rows, surface_id=surface_id),
        module_sdk.effects.ui_property_update(table_id, "sort", resolved_sort, surface_id=surface_id),
    )


@action("list_objective_mappings")
async def list_objective_mappings(ctx: dict, session: dict, module_sdk):
    del session
    return _refresh_table(module_sdk, ctx)


@action("create_objective_mapping")
async def create_objective_mapping(ctx: dict, session: dict, module_sdk):
    del session
    payload = {
        "objective": str(ctx.get("objective") or "support_triage"),
        "capability": str(ctx.get("capability") or "chat"),
        "priority": int(ctx.get("priority", 100) or 100),
    }
    module_sdk.models.objective_mappings.create(payload)
    return _refresh_table(module_sdk, {**ctx, "page": 0})


@action("update_objective_mapping")
async def update_objective_mapping(ctx: dict, session: dict, module_sdk):
    del session
    item = dict(ctx.get("item") or {})
    row_id = int(item.get("id") or 0)
    payload = {
        "objective": str(item.get("objective") or ctx.get("objective") or ""),
        "capability": str(item.get("capability") or ctx.get("capability") or ""),
        "priority": int(ctx.get("priority", item.get("priority", 100)) or 100),
    }
    module_sdk.models.objective_mappings.update(row_id, payload)
    return _refresh_table(module_sdk, ctx)


@action("delete_objective_mapping")
async def delete_objective_mapping(ctx: dict, session: dict, module_sdk):
    del session
    item = dict(ctx.get("item") or {})
    row_id = int(item.get("id") or 0)
    module_sdk.models.objective_mappings.delete(row_id)
    return _refresh_table(module_sdk, ctx)


@action("delete_selected_objective_mappings")
async def delete_selected_objective_mappings(ctx: dict, session: dict, module_sdk):
    del session
    for row_id in ctx.get("selected_ids", []):
        module_sdk.models.objective_mappings.delete(int(row_id))
    return _refresh_table(module_sdk, ctx)