painters.py

#!/usr/bin/env python3
# Copyright (C) 2019 Checkmk GmbH - License: GNU General Public License v2
# This file is part of Checkmk (https://checkmk.com). It is subject to the terms and
# conditions defined in the file COPYING, which is part of this source code package.

# mypy: disable-error-code="no-any-return"
# mypy: disable-error-code="possibly-undefined"
# mypy: disable-error-code="type-arg"

import abc
import time
from collections.abc import Iterable, Mapping, Sequence
from fnmatch import fnmatch
from pathlib import Path
from typing import Literal, override

import cmk.ccc.version as cmk_version
import cmk.utils.paths
from cmk.discover_plugins import discover_families, PluginGroup
from cmk.gui import sites
from cmk.gui.color import render_color_icon
from cmk.gui.config import Config
from cmk.gui.graphing import (
    get_metric_spec,
    get_temperature_unit,
    metrics_from_api,
    parse_perf_data,
    registered_metric_ids_and_titles,
    RegisteredMetric,
    translate_metrics,
    TranslatedMetric,
    user_specific_unit,
)
from cmk.gui.hooks import request_memoize
from cmk.gui.htmllib.generator import HTMLWriter
from cmk.gui.htmllib.html import html
from cmk.gui.http import Request
from cmk.gui.i18n import _
from cmk.gui.logged_in import LoggedInUser, user
from cmk.gui.painter_options import (
    paint_age,
    paint_age_or_never,
    PainterOption,
    PainterOptionRegistry,
    PainterOptions,
)
from cmk.gui.theme import Theme
from cmk.gui.type_defs import (
    ColumnName,
    HTTPVariables,
    IconNames,
    PainterParameters,
    Row,
    SorterName,
    StaticIcon,
    VisualLinkSpec,
)
from cmk.gui.utils import escaping
from cmk.gui.utils.html import HTML
from cmk.gui.utils.output_funnel import output_funnel
from cmk.gui.utils.popups import MethodAjax
from cmk.gui.utils.temperate_unit import TemperatureUnit
from cmk.gui.valuespec import (
    Checkbox,
    DateFormat,
    Dictionary,
    DictionaryElements,
    DropdownChoice,
    DropdownChoiceEntries,
    Integer,
    ListChoice,
    ListChoiceChoices,
    TextInput,
    ValueSpec,
)
from cmk.gui.view_utils import (
    CellSpec,
    CSSClass,
    determine_must_escape,
    format_plugin_output,
    get_labels,
    render_labels,
    render_tag_groups,
    replace_action_url_macros,
)
from cmk.gui.visual_link import render_link_to_view
from cmk.ruleset_matcher.labels import Labels
from cmk.ruleset_matcher.tags import TagConfig
from cmk.utils import man_pages
from cmk.utils.render import approx_age
from cmk.utils.statename import short_host_state_name, short_service_state_name

from ..v1.helpers import get_perfdata_nth_value, is_stale, paint_stalified
from .base import Cell, Painter
from .helpers import (
    format_labels_for_csv_export,
    get_label_sources,
    get_tag_groups,
    paint_host_list,
    paint_nagiosflag,
    render_cache_info,
    RenderLink,
    tag_choices_for_group,
)
from .registry import PainterRegistry


def register(
    painter_option_registry: PainterOptionRegistry, painter_registry: PainterRegistry
) -> None:
    painter_option_registry.register(PainterOptionTimestampFormat())
    painter_option_registry.register(PainterOptionTimestampDate())
    painter_option_registry.register(PainterOptionMatrixOmitUniform())
    painter_option_registry.register(PainterOptionShowInternalGraphAndMetricIds())
    painter_registry.register(PainterSiteIcon)
    painter_registry.register(PainterSitenamePlain)
    painter_registry.register(PainterSitealias)
    painter_registry.register(PainterServiceState)
    painter_registry.register(PainterSvcPluginOutput)
    painter_registry.register(PainterSvcLongPluginOutput)
    painter_registry.register(PainterSvcPerfData)
    painter_registry.register(PainterSvcMetrics)
    painter_registry.register(PainterSvcPerfVal01)
    painter_registry.register(PainterSvcPerfVal02)
    painter_registry.register(PainterSvcPerfVal03)
    painter_registry.register(PainterSvcPerfVal04)
    painter_registry.register(PainterSvcPerfVal05)
    painter_registry.register(PainterSvcPerfVal06)
    painter_registry.register(PainterSvcPerfVal07)
    painter_registry.register(PainterSvcPerfVal08)
    painter_registry.register(PainterSvcPerfVal09)
    painter_registry.register(PainterSvcPerfVal10)
    painter_registry.register(PainterSvcCheckCommand)
    painter_registry.register(PainterSvcCheckCommandExpanded)
    painter_registry.register(PainterSvcNotesURL)
    painter_registry.register(PainterSvcContacts)
    painter_registry.register(PainterSvcContactGroups)
    painter_registry.register(PainterServiceDescription)
    painter_registry.register(PainterServiceDisplayName)
    painter_registry.register(PainterSvcStateAge)
    painter_registry.register(PainterSvcCheckAge)
    painter_registry.register(PainterSvcCheckCacheInfo)
    painter_registry.register(PainterSvcNextCheck)
    painter_registry.register(PainterSvcLastTimeOk)
    painter_registry.register(PainterSvcNextNotification)
    painter_registry.register(PainterSvcNotificationPostponementReason)
    painter_registry.register(PainterSvcLastNotification)
    painter_registry.register(PainterSvcNotificationNumber)
    painter_registry.register(PainterSvcCheckLatency)
    painter_registry.register(PainterSvcCheckDuration)
    painter_registry.register(PainterSvcAttempt)
    painter_registry.register(PainterSvcNormalInterval)
    painter_registry.register(PainterSvcRetryInterval)
    painter_registry.register(PainterSvcCheckInterval)
    painter_registry.register(PainterSvcCheckType)
    painter_registry.register(PainterSvcInDowntime)
    painter_registry.register(PainterSvcInNotifper)
    painter_registry.register(PainterSvcNotifper)
    painter_registry.register(PainterSvcCheckPeriod)
    painter_registry.register(PainterSvcFlapping)
    painter_registry.register(PainterSvcNotificationsEnabled)
    painter_registry.register(PainterSvcIsActive)
    painter_registry.register(PainterSvcGroupMemberlist)
    painter_registry.register(PainterCheckManpage)
    painter_registry.register(PainterSvcComments)
    painter_registry.register(PainterSvcAcknowledged)
    painter_registry.register(PainterSvcCustomNotes)
    painter_registry.register(PainterSvcStaleness)
    painter_registry.register(PainterSvcIsStale)
    painter_registry.register(PainterServiceCustomVariables)
    painter_registry.register(PainterServiceCustomVariable)
    painter_registry.register(PainterHostCustomVariable)
    painter_registry.register(PainterHostState)
    painter_registry.register(PainterHostStateOnechar)
    painter_registry.register(PainterHostPluginOutput)
    painter_registry.register(PainterHostPerfData)
    painter_registry.register(PainterHostCheckCommand)
    painter_registry.register(PainterHostCheckCommandExpanded)
    painter_registry.register(PainterHostNotesURL)
    painter_registry.register(PainterHostStateAge)
    painter_registry.register(PainterHostCheckAge)
    painter_registry.register(PainterHostNextCheck)
    painter_registry.register(PainterHostNextNotification)
    painter_registry.register(PainterHostNotificationPostponementReason)
    painter_registry.register(PainterHostLastNotification)
    painter_registry.register(PainterHostCheckLatency)
    painter_registry.register(PainterHostCheckDuration)
    painter_registry.register(PainterHostAttempt)
    painter_registry.register(PainterHostNormalInterval)
    painter_registry.register(PainterHostRetryInterval)
    painter_registry.register(PainterHostCheckInterval)
    painter_registry.register(PainterHostCheckType)
    painter_registry.register(PainterHostInNotifper)
    painter_registry.register(PainterHostNotifper)
    painter_registry.register(PainterHostNotificationNumber)
    painter_registry.register(PainterHostFlapping)
    painter_registry.register(PainterHostIsActive)
    painter_registry.register(PainterHostNotificationsEnabled)
    painter_registry.register(PainterHostBlack)
    painter_registry.register(PainterHostWithState)
    painter_registry.register(PainterHost)
    painter_registry.register(PainterAlias)
    painter_registry.register(PainterHostAddress)
    painter_registry.register(PainterHostIpv4Address)
    painter_registry.register(PainterHostIpv6Address)
    painter_registry.register(PainterHostAddresses)
    painter_registry.register(PainterHostAddressesAdditional)
    painter_registry.register(PainterHostAddressFamily)
    painter_registry.register(PainterHostAddressFamilies)
    painter_registry.register(PainterNumServices)
    painter_registry.register(PainterNumServicesOk)
    painter_registry.register(PainterNumProblems)
    painter_registry.register(PainterNumServicesWarn)
    painter_registry.register(PainterNumServicesCrit)
    painter_registry.register(PainterNumServicesUnknown)
    painter_registry.register(PainterNumServicesPending)
    painter_registry.register(PainterHostServices)
    painter_registry.register(PainterHostParents)
    painter_registry.register(PainterHostChilds)
    painter_registry.register(PainterHostGroupMemberlist)
    painter_registry.register(PainterHostContacts)
    painter_registry.register(PainterHostContactGroups)
    painter_registry.register(PainterHostCustomNotes)
    painter_registry.register(PainterHostComments)
    painter_registry.register(PainterHostInDowntime)
    painter_registry.register(PainterHostAcknowledged)
    painter_registry.register(PainterHostStaleness)
    painter_registry.register(PainterHostIsStale)
    painter_registry.register(PainterHostCustomVariables)
    painter_registry.register(PainterServiceDiscoveryState)
    painter_registry.register(PainterServiceDiscoveryCheck)
    painter_registry.register(PainterServiceDiscoveryService)
    painter_registry.register(PainterHostgroupHosts)
    painter_registry.register(PainterHgNumServices)
    painter_registry.register(PainterHgNumServicesOk)
    painter_registry.register(PainterHgNumServicesWarn)
    painter_registry.register(PainterHgNumServicesCrit)
    painter_registry.register(PainterHgNumServicesUnknown)
    painter_registry.register(PainterHgNumServicesPending)
    painter_registry.register(PainterHgNumHostsUp)
    painter_registry.register(PainterHgNumHostsDown)
    painter_registry.register(PainterHgNumHostsUnreach)
    painter_registry.register(PainterHgNumHostsPending)
    painter_registry.register(PainterHgName)
    painter_registry.register(PainterHgAlias)
    painter_registry.register(PainterSgServices)
    painter_registry.register(PainterSgNumServices)
    painter_registry.register(PainterSgNumServicesOk)
    painter_registry.register(PainterSgNumServicesWarn)
    painter_registry.register(PainterSgNumServicesCrit)
    painter_registry.register(PainterSgNumServicesUnknown)
    painter_registry.register(PainterSgNumServicesPending)
    painter_registry.register(PainterSgName)
    painter_registry.register(PainterSgAlias)
    painter_registry.register(PainterCommentId)
    painter_registry.register(PainterCommentAuthor)
    painter_registry.register(PainterCommentComment)
    painter_registry.register(PainterCommentWhat)
    painter_registry.register(PainterCommentTime)
    painter_registry.register(PainterCommentExpires)
    painter_registry.register(PainterCommentEntryType)
    painter_registry.register(PainterDowntimeId)
    painter_registry.register(PainterDowntimeAuthor)
    painter_registry.register(PainterDowntimeComment)
    painter_registry.register(PainterDowntimeFixed)
    painter_registry.register(PainterDowntimeOrigin)
    painter_registry.register(PainterDowntimeWhat)
    painter_registry.register(PainterDowntimeType)
    painter_registry.register(PainterDowntimeEntryTime)
    painter_registry.register(PainterDowntimeStartTime)
    painter_registry.register(PainterDowntimeEndTime)
    painter_registry.register(PainterDowntimeDuration)
    painter_registry.register(PainterLogDetailsHistory)
    painter_registry.register(PainterLogMessage)
    painter_registry.register(PainterLogPluginOutput)
    painter_registry.register(PainterLogWhat)
    painter_registry.register(PainterLogAttempt)
    painter_registry.register(PainterLogStateType)
    painter_registry.register(PainterLogStateInfo)
    painter_registry.register(PainterLogType)
    painter_registry.register(PainterLogContactName)
    painter_registry.register(PainterLogCommand)
    painter_registry.register(PainterLogIcon)
    painter_registry.register(PainterLogOptions)
    painter_registry.register(PainterLogComment)
    painter_registry.register(PainterLogTime)
    painter_registry.register(PainterLogLineno)
    painter_registry.register(PainterLogDate)
    painter_registry.register(PainterLogState)
    painter_registry.register(PainterAlertStatsOk)
    painter_registry.register(PainterAlertStatsWarn)
    painter_registry.register(PainterAlertStatsCrit)
    painter_registry.register(PainterAlertStatsUnknown)
    painter_registry.register(PainterAlertStatsProblem)
    painter_registry.register(PainterHostTags)
    painter_registry.register(PainterHostTagsWithTitles)
    painter_registry.register(PainterServiceTags)
    painter_registry.register(PainterServiceTagsWithTitles)
    painter_registry.register(PainterHostLabels)
    painter_registry.register(PainterServiceLabels)
    painter_registry.register(PainterHostDockerNode)
    painter_registry.register(PainterHostSpecificMetric)
    painter_registry.register(PainterServiceSpecificMetric)
    painter_registry.register(PainterHostKubernetesCluster)
    painter_registry.register(PainterHostKubernetesNamespace)
    painter_registry.register(PainterHostKubernetesDeployment)
    painter_registry.register(PainterHostKubernetesDaemonset)
    painter_registry.register(PainterHostKubernetesStatefulset)
    painter_registry.register(PainterHostKubernetesNode)


#   .--Painter Options-----------------------------------------------------.
#   |                   ____       _       _                               |
#   |                  |  _ \ __ _(_)_ __ | |_ ___ _ __                    |
#   |                  | |_) / _` | | '_ \| __/ _ \ '__|                   |
#   |                  |  __/ (_| | | | | | ||  __/ |                      |
#   |                  |_|   \__,_|_|_| |_|\__\___|_|                      |
#   |                                                                      |
#   |                   ___        _   _                                   |
#   |                  / _ \ _ __ | |_(_) ___  _ __  ___                   |
#   |                 | | | | '_ \| __| |/ _ \| '_ \/ __|                  |
#   |                 | |_| | |_) | |_| | (_) | | | \__ \                  |
#   |                  \___/| .__/ \__|_|\___/|_| |_|___/                  |
#   |                       |_|                                            |
#   +----------------------------------------------------------------------+
#   | Painter options influence how painters render their data. Painter    |
#   | options are stored together with "refresh" and "columns" as "View    |
#   | options".                                                            |
#   '----------------------------------------------------------------------'


class PainterOptionShowInternalGraphAndMetricIds(PainterOption):
    def __init__(self) -> None:
        super().__init__(
            ident="show_internal_graph_and_metric_ids",
            valuespec=Checkbox(
                title=_("Show internal graph and metric IDs"),
                default_value=False,
            ),
        )


class PainterOptionTimestampFormat(PainterOption):
    def __init__(self) -> None:
        super().__init__(ident="ts_format")

    @property
    @override
    def valuespec(self) -> ValueSpec:
        return DropdownChoice(
            title=_("Timestamp format"),
            default_value=self.config.default_ts_format,
            encode_value=False,
            choices=[
                ("mixed", _("Mixed")),
                ("abs", _("Absolute")),
                ("rel", _("Relative")),
                ("both", _("Both")),
                ("epoch", _("Unix timestamp (epoch)")),
            ],
        )


class PainterOptionTimestampDate(PainterOption):
    def __init__(self) -> None:
        super().__init__(ident="ts_date", valuespec=DateFormat())


class PainterOptionMatrixOmitUniform(PainterOption):
    def __init__(self) -> None:
        super().__init__(
            ident="matrix_omit_uniform",
            valuespec=DropdownChoice(
                title=_("Find differences..."),
                choices=[
                    (False, _("Always show all rows")),
                    (True, _("Omit rows where all columns are identical")),
                ],
            ),
        )


# .
#   .--Helpers-------------------------------------------------------------.
#   |                  _   _      _                                        |
#   |                 | | | | ___| |_ __   ___ _ __ ___                    |
#   |                 | |_| |/ _ \ | '_ \ / _ \ '__/ __|                   |
#   |                 |  _  |  __/ | |_) |  __/ |  \__ \                   |
#   |                 |_| |_|\___|_| .__/ \___|_|  |___/                   |
#   |                              |_|                                     |
#   '----------------------------------------------------------------------'


# This helper function returns the value of the given custom var
def paint_custom_var(what: str, key: CSSClass, row: Row, choices: list | None = None) -> CellSpec:
    if choices is None:
        choices = []

    if what:
        what += "_"

    custom_vars = dict(
        zip(row[what + "custom_variable_names"], row[what + "custom_variable_values"])
    )

    if key in custom_vars:
        custom_val = custom_vars[key]
        if choices:
            custom_val = dict(choices).get(int(custom_val), custom_val)
        return key, custom_val

    return key, ""


def _paint_future_time(
    timestamp: int,
    *,
    request: Request,
    painter_options: PainterOptions,
) -> CellSpec:
    # NOTE: Nagios uses 0 to represent "never again" while the CMC uses a time far into the future
    # (year 2262 or 0x7fffffffffffffff nanoseconds after 1970, but we leave some headroom below).
    # Although this is inconsistent, the latter is arguably more correct. In any case, the usage of
    # magic numbers is a quite a hack...
    if not 0 < timestamp < 0x200000000:
        return "", "-"
    return paint_age(
        timestamp,
        True,
        0,
        request=request,
        painter_options=painter_options,
        what="future",
    )


def _paint_day(timestamp: int) -> CellSpec:
    return "", time.strftime("%A, %Y-%m-%d", time.localtime(timestamp))


# .
#   .--Site----------------------------------------------------------------.
#   |                           ____  _ _                                  |
#   |                          / ___|(_) |_ ___                            |
#   |                          \___ \| | __/ _ \                           |
#   |                           ___) | | ||  __/                           |
#   |                          |____/|_|\__\___|                           |
#   |                                                                      |
#   +----------------------------------------------------------------------+
#   |  Column painters showing information about a site.                   |
#   '----------------------------------------------------------------------'


class PainterSiteIcon(Painter):
    @property
    @override
    def ident(self) -> str:
        return "site_icon"

    @override
    def title(self, cell: Cell) -> str:
        return _("Site icon")

    @override
    def short_title(self, cell: Cell) -> str:
        return ""

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["site"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "site"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if row.get("site") and self.config.use_siteicons:
            return None, HTMLWriter.render_img(
                "icons/site-%s-24.png" % row["site"], class_="siteicon"
            )
        return None, ""


class PainterSitenamePlain(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sitename_plain"

    @override
    def title(self, cell: Cell) -> str:
        return _("Site ID")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Site")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["site"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "site"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["site"])


class PainterSitealias(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sitealias"

    @override
    def title(self, cell: Cell) -> str:
        return _("Site alias")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["site"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, self.config.sites[row["site"]]["alias"])


# .
#   .--Services------------------------------------------------------------.
#   |                ____                  _                               |
#   |               / ___|  ___ _ ____   _(_) ___ ___  ___                 |
#   |               \___ \ / _ \ '__\ \ / / |/ __/ _ \/ __|                |
#   |                ___) |  __/ |   \ V /| | (_|  __/\__ \                |
#   |               |____/ \___|_|    \_/ |_|\___\___||___/                |
#   |                                                                      |
#   +----------------------------------------------------------------------+
#   | Painters for services                                                |
#   '----------------------------------------------------------------------'


def service_state_short(row: Row) -> tuple[str, str]:
    if row["service_has_been_checked"] == 1:
        return str(row["service_state"]), short_service_state_name(row["service_state"], "")
    return "p", short_service_state_name(-1, "")


def _paint_service_state_short(row: Row, *, config: Config) -> CellSpec:
    state, name = service_state_short(row)
    if is_stale(row, config.staleness_threshold):
        state = state + " stale"
    return "state svcstate state%s" % state, HTMLWriter.render_span(
        name, class_=["state_rounded_fill"]
    )


def host_state_short(row: Row) -> tuple[str, str]:
    if row["host_has_been_checked"] == 1:
        state = str(row["host_state"])
        # A state of 3 is sent by livestatus in cases where no normal state
        # information is avaiable, e.g. for "DOWNTIMESTOPPED (UP)"
        name = short_host_state_name(row["host_state"], "")
    else:
        state = "p"
        name = _("PEND")
    return state, name


def _paint_host_state_short(row: Row, short: bool = False, *, config: Config) -> CellSpec:
    state, name = host_state_short(row)
    if is_stale(row, config.staleness_threshold):
        state = state + " stale"

    if short:
        name = name[0]

    return "state hstate hstate%s" % state, HTMLWriter.render_span(
        name, class_=["state_rounded_fill"]
    )


class PainterServiceState(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_state"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service state")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("State")

    @override
    def title_classes(self) -> list[str]:
        return ["center"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_has_been_checked", "service_state"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "svcstate"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_service_state_short(row, config=self.config)


class PainterSvcPluginOutput(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_plugin_output"

    @override
    def title(self, cell: Cell) -> str:
        return _("Summary")

    @override
    def list_title(self, cell: Cell) -> str:
        return _("Summary (previously named: Status details or plug-in output)")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_plugin_output", "service_custom_variables", "service_check_command"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "svcoutput"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_stalified(
            row,
            format_plugin_output(
                row["service_plugin_output"],
                request=self.request,
                must_escape=determine_must_escape(self.config.sites, row),
                row=row,
            ),
            self.config.staleness_threshold,
        )


class PainterSvcLongPluginOutput(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_long_plugin_output"

    @override
    def title(self, cell: Cell) -> str:
        return _("Details")

    @override
    def list_title(self, cell: Cell) -> str:
        return _("Details (previously named: long output)")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_long_plugin_output", "service_custom_variables"]

    @property
    @override
    def parameters(self) -> Dictionary:
        return Dictionary(
            elements=[
                (
                    "max_len",
                    Integer(
                        title=_("Maximum number of characters to show"),
                        help=_(
                            "Truncate content at this amount of characters. "
                            "A zero value means not to truncate."
                        ),
                        default_value=0,
                        minvalue=0,
                    ),
                ),
            ]
        )

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if (params := cell.painter_parameters()) is None:
            params = {}

        max_len = params.get("max_len", 0)
        long_output = row["service_long_plugin_output"]
        long_output_len = len(long_output)

        if 0 < max_len < long_output_len:
            long_output = long_output[:max_len] + "..."

        content = format_plugin_output(
            long_output,
            request=self.request,
            row=row,
            newlineishs_to_brs=True,
            must_escape=determine_must_escape(self.config.sites, row),
        )

        # has to be placed after format_plugin_output() to keep links save from
        # escaping
        if (
            max_long_output_size := sites.states()
            .get(row["site"], {})
            .get("max_long_output_size", 0)
        ) and long_output_len > max_long_output_size:
            setting_link_tag = self.url_renderer.link_from_filename(
                "wato.py",
                html_text="(%s)" % _("Increase limit"),
                query_args=[
                    ("mode", "edit_configvar"),
                    ("varname", "max_long_output_size"),
                ],
            )
            content = (
                _("Lost data due to truncation of long output to ")
                + f"{int(max_long_output_size / 1000)}kB "
                + setting_link_tag
                + html.render_b("WARN", class_="stmark state1")
                + html.render_br()
                + content
            )

        return paint_stalified(row, content, self.config.staleness_threshold)


class PainterSvcPerfData(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_perf_data"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service metrics (source code)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Metrics")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_perf_data"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_stalified(row, row["service_perf_data"], self.config.staleness_threshold)


class PainterSvcMetrics(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_metrics"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service metrics")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Metrics")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_command", "service_perf_data"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["show_internal_graph_and_metric_ids"]

    @property
    @override
    def printable(self) -> bool:
        return False

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        perf_data, check_command = parse_perf_data(
            row["service_perf_data"], row["service_check_command"], debug=self.config.debug
        )
        temperature_unit = get_temperature_unit(user, self.config.default_temperature_unit)
        translated_metrics = translate_metrics(
            perf_data,
            check_command,
            metrics_from_api,
            temperature_unit=temperature_unit,
        )

        if row["service_perf_data"] and not translated_metrics:
            return "", _("Failed to parse metrics string: %(perf_data)s") % {
                "perf_data": row["service_perf_data"]
            }

        with output_funnel.plugged():
            self._show_metrics_table(
                translated_metrics,
                row["host_name"],
                row["service_description"],
                show_metric_id=self._painter_options.get("show_internal_graph_and_metric_ids"),
                theme=self.theme,
                temperature_unit=temperature_unit,
            )
            return "", HTML.without_escaping(output_funnel.drain())

    def _show_metrics_table(
        self,
        translated_metrics: Mapping[str, TranslatedMetric],
        host_name: str,
        service_description: str,
        show_metric_id: bool,
        *,
        theme: Theme,
        temperature_unit: TemperatureUnit,
    ) -> None:
        html.open_table(class_="metricstable")
        for metric_name, translated_metric in sorted(
            translated_metrics.items(), key=lambda t: t[1].title
        ):
            optional_metric_id = ""
            if show_metric_id:
                optional_metric_id = f" (Metric ID: {metric_name})"
            html.open_tr()
            html.td(render_color_icon(translated_metric.color), class_="color")
            html.td(f"{translated_metric.title}{optional_metric_id}:")
            html.td(
                user_specific_unit(translated_metric.unit_spec, temperature_unit).formatter.render(
                    translated_metric.value
                ),
                class_="value",
            )
            if cmk_version.edition(cmk.utils.paths.omd_root) is not cmk_version.Edition.COMMUNITY:
                html.td(
                    html.render_popup_trigger(
                        html.render_static_icon(
                            StaticIcon(IconNames.menu),
                            title=_("Add this metric to dedicated graph"),
                            css_classes=["iconbutton"],
                        ),
                        ident="add_metric_to_graph_" + host_name + ";" + str(service_description),
                        method=MethodAjax(
                            endpoint="add_metric_to_graph",
                            url_vars=[
                                ("host", host_name),
                                ("service", service_description),
                                ("metric", metric_name),
                            ],
                        ),
                    )
                )
            html.close_tr()
        html.close_table()


# TODO: Use a parameterized painter for this instead of 10 painter classes
class PainterSvcPerfVal(Painter):
    _num = 0

    @property
    @override
    def ident(self) -> str:
        return "svc_perf_val%02d" % self._num

    @override
    def title(self, cell: Cell) -> str:
        return _("Service metrics - value number %(nr)2d") % {"nr": self._num}

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Val. %(nr)d") % {"nr": self._num}

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_perf_data"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_stalified(
            row, get_perfdata_nth_value(row, self._num - 1), self.config.staleness_threshold
        )


class PainterSvcPerfVal01(PainterSvcPerfVal):
    _num = 1


class PainterSvcPerfVal02(PainterSvcPerfVal):
    _num = 2


class PainterSvcPerfVal03(PainterSvcPerfVal):
    _num = 3


class PainterSvcPerfVal04(PainterSvcPerfVal):
    _num = 4


class PainterSvcPerfVal05(PainterSvcPerfVal):
    _num = 5


class PainterSvcPerfVal06(PainterSvcPerfVal):
    _num = 6


class PainterSvcPerfVal07(PainterSvcPerfVal):
    _num = 7


class PainterSvcPerfVal08(PainterSvcPerfVal):
    _num = 8


class PainterSvcPerfVal09(PainterSvcPerfVal):
    _num = 9


class PainterSvcPerfVal10(PainterSvcPerfVal):
    _num = 10


class PainterSvcCheckCommand(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_command"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service check command")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check command")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_command"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["service_check_command"])


class PainterSvcCheckCommandExpanded(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_command_expanded"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service check command expanded")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check command expanded")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_command_expanded"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["service_check_command_expanded"])


class PainterSvcNotesURL(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_notes_url"

    @override
    def title(self, cell: Cell) -> str:
        return _("Notes (URL) for services")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notes URL")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_address", "service_notes_url"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        raw_url = row.get("service_notes_url")
        if not raw_url:
            return None, HTML.empty()

        url = replace_action_url_macros(raw_url, "service", row)
        content = self.url_renderer.link_direct(url, html_text=url, target="_blank")
        return None, content


class PainterSvcContacts(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_contacts"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service contacts")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Contacts")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_contacts"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, ", ".join(row["service_contacts"]))


class PainterSvcContactGroups(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_contact_groups"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service contact groups")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Contact groups")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_contact_groups"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, ", ".join(row["service_contact_groups"]))


class PainterServiceDescription(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_description"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Service")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_description"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "svcdescr"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["service_description"])


class PainterServiceDisplayName(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_display_name"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service alternative display name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Display name")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_display_name"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "svcdispname"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["service_display_name"])


class PainterSvcStateAge(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_state_age"

    @override
    def title(self, cell: Cell) -> str:
        return _("Age of the current service state")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Age")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_has_been_checked", "service_last_state_change"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "stateage"

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["service_last_state_change"],
            row["service_has_been_checked"] == 1,
            60 * 10,
            request=self.request,
            painter_options=self._painter_options,
        )


def _paint_checked(
    what: str, row: Row, *, config: Config, request: Request, painter_options: PainterOptions
) -> CellSpec:
    age = row[what + "_last_check"]
    if what == "service":
        cached_at = row["service_cached_at"]
        if cached_at:
            age = cached_at

    css, td = paint_age(
        age,
        row[what + "_has_been_checked"] == 1,
        0,
        request=request,
        painter_options=painter_options,
    )
    assert css is not None
    if is_stale(row, config.staleness_threshold):
        css += " staletime"
    return css, td


class PainterSvcCheckAge(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_age"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time since the last check of the service")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Checked")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_has_been_checked", "service_last_check", "service_cached_at"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_checked(
            "service",
            row,
            config=self.config,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterSvcCheckCacheInfo(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_cache_info"

    @override
    def title(self, cell: Cell) -> str:
        return _("Cached agent data")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Cached")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_last_check", "service_cached_at", "service_cache_interval"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if not row["service_cached_at"]:
            return "", ""
        return "", render_cache_info("service", row)


class PainterSvcNextCheck(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_next_check"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time of the next scheduled service check")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Next check")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_next_check"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_future_time(
            row["service_next_check"],
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterSvcLastTimeOk(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_last_time_ok"

    @override
    def title(self, cell: Cell) -> str:
        return _("Last time the service was OK")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Last OK")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_last_time_ok", "service_has_been_checked"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age_or_never(
            row["service_last_time_ok"],
            row["service_has_been_checked"] == 1,
            60 * 10,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterSvcNextNotification(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_next_notification"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time of the next service notification")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Next notification")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_next_notification"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_future_time(
            row["service_next_notification"],
            request=self.request,
            painter_options=self._painter_options,
        )


def _paint_notification_postponement_reason(what: str, row: Row) -> CellSpec:
    # Needs to be in sync with the possible reasons. Can not be translated otherwise.
    reasons = {
        "delayed notification": _("Delay notification"),
        "periodic notification": _("Periodic notification"),
        "currently in downtime": _("In downtime"),
        "host of this service is currently in downtime": _("Host is in downtime"),
        "problem acknowledged and periodic notifications are enabled": _(
            "Problem is acknowledged, but is configured to be periodic"
        ),
        "notifications are disabled, but periodic notifications are enabled": _(
            "Notifications are disabled, but is configured to be periodic"
        ),
        "not in notification period": _("Is not in notification period"),
        "host of this service is not up": _("Host is down"),
        "last host check not recent enough": _("Last host check is not recent enough"),
        "last service check not recent enough": _("Last service check is not recent enough"),
        "all parents are down": _("All parents are down"),
        "at least one parent is up, but no check is recent enough": _(
            "Last service check is not recent enough"
        ),
        None: "",  # column is not available if the Nagios core is used
    }

    reason: str = row[what + "_notification_postponement_reason"]
    return ("", reasons.get(reason, reason))


class PainterSvcNotificationPostponementReason(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_notification_postponement_reason"

    @override
    def title(self, cell: Cell) -> str:
        return _("Notification postponement reason")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notif. postponed")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_notification_postponement_reason"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_notification_postponement_reason("service", row)


class PainterSvcLastNotification(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_last_notification"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time of the last service notification")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("last notification")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_last_notification"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["service_last_notification"],
            row["service_last_notification"],
            0,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterSvcNotificationNumber(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_notification_number"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service notification number")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("N#")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_current_notification_number"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        # Keep in sync with HACK in cmk/base/events.py
        current: str = str(row["service_current_notification_number"])
        return ("", "1" if current == "0" else current)


class PainterSvcCheckLatency(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_latency"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service check latency")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Latency")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_latency"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", approx_age(row["service_latency"]))


class PainterSvcCheckDuration(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_duration"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service check duration")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Duration")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_execution_time"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", approx_age(row["service_execution_time"]))


class PainterSvcAttempt(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_attempt"

    @override
    def title(self, cell: Cell) -> str:
        return _("Current check attempt")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Att.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_current_attempt", "service_max_check_attempts"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, "%d/%d" % (row["service_current_attempt"], row["service_max_check_attempts"]))


class PainterSvcNormalInterval(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_normal_interval"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service normal check interval")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check int.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_interval"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("number", approx_age(row["service_check_interval"] * 60.0))


class PainterSvcRetryInterval(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_retry_interval"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service retry check interval")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Retry")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_retry_interval"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("number", approx_age(row["service_retry_interval"] * 60.0))


class PainterSvcCheckInterval(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_interval"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service normal/retry check interval")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Interval")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_interval", "service_retry_interval"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (
            None,
            "%s / %s"
            % (
                approx_age(row["service_check_interval"] * 60.0),
                approx_age(row["service_retry_interval"] * 60.0),
            ),
        )


class PainterSvcCheckType(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_type"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service check type")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Type")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, _("ACTIVE") if row["service_check_type"] == 0 else _("PASSIVE"))


class PainterSvcInDowntime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_in_downtime"

    @override
    def title(self, cell: Cell) -> str:
        return _("Currently in downtime")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Dt.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_scheduled_downtime_depth"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "service_scheduled_downtime_depth", True)


class PainterSvcInNotifper(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_in_notifper"

    @override
    def title(self, cell: Cell) -> str:
        return _("In notification period")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("in notif. p.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_in_notification_period"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "service_in_notification_period", False)


class PainterSvcNotifper(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_notifper"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service notification period")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("notif.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_notification_period"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["service_notification_period"])


class PainterSvcCheckPeriod(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_check_period"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service check period")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("check.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_period"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["service_check_period"])


class PainterSvcFlapping(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_flapping"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service is flapping")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Flap")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_is_flapping"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "service_is_flapping", True)


class PainterSvcNotificationsEnabled(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_notifications_enabled"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service notifications enabled")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notif.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_notifications_enabled"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "service_notifications_enabled", False)


class PainterSvcIsActive(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_is_active"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service is active")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Active")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_active_checks_enabled"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "service_active_checks_enabled", False)


class PainterSvcGroupMemberlist(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_group_memberlist"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service groups the service is member of")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Groups")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_groups"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        links = []

        for group in row["service_groups"]:
            link = self.url_renderer.link_from_filename(
                "view.py",
                html_text=group,
                query_args=[
                    ("view_name", "servicegroup"),
                    ("servicegroup", group),
                ],
            )
            links.append(link)
        return "", HTML.without_escaping(", ").join(links)

    @override
    def export_for_csv(self, row: Row, cell: Cell, user: LoggedInUser) -> str:
        return ", ".join(row["service_groups"])

    @override
    def export_for_json(self, row: Row, cell: Cell, user: LoggedInUser) -> object:
        return row["service_groups"]


class PainterCheckManpage(Painter):
    @property
    @override
    def ident(self) -> str:
        return "check_manpage"

    @override
    def title(self, cell: Cell) -> str:
        return _("Check manual (for Checkmk based checks)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Manual")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_check_command"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        command = row["service_check_command"]

        if not command.startswith(("check_mk-", "check-mk", "check_mk_active-cmk_inv")):
            return "", ""

        if command == "check-mk":
            checktype = "check-mk"
        elif command == "check-mk-inventory":
            checktype = "check-mk-inventory"
        elif "check_mk_active-cmk_inv" in command:
            checktype = "check_cmk_inv"
        elif command.startswith("check_mk-mgmt_"):
            checktype = command[14:]
        else:
            checktype = command[9:]

        man_page_path_map = man_pages.make_man_page_path_map(
            discover_families(raise_errors=False), PluginGroup.CHECKMAN.value
        )
        # some checks are run as commandlines (e.g. checks configured via the "Integrate nagios plugins" rule).
        name = checktype.split()[0]

        try:
            page = man_pages.parse_man_page(name, man_page_path_map[name])
        except KeyError:
            return "", ""

        description = HTML.without_escaping(
            escaping.escape_attribute(page.description)
            .replace("{", "<b>")
            .replace("}", "</b>")
            .replace("&lt;br&gt;", "<br>")
            .replace("\n\n", "\n<br>\n")
        )
        return "", description


def _paint_comments(prefix: str, row: Row) -> CellSpec:
    comments = row[prefix + "comments_with_info"]
    text = HTML.without_escaping(", ").join(
        [
            HTMLWriter.render_i(a)
            + escaping.escape_to_html_permissive(": %s" % c, escape_links=False)
            for _id, a, c in comments
        ]
    )
    return "", text


class PainterSvcComments(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_comments"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service Comments")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Comments")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_comments_with_info"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_comments("service_", row)


class PainterSvcAcknowledged(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_acknowledged"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service problem acknowledged")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Ack")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_acknowledged"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "service_acknowledged", False)


def match_path_entries_with_item(dirs: Iterable[Path], item: str) -> Iterable[Path]:
    yield from (
        sub_path
        for directory in dirs
        if directory.is_dir()
        for sub_path in directory.iterdir()
        if not sub_path.name.startswith(".") and fnmatch(item, sub_path.name)
    )


def _paint_custom_notes(what: str, row: Row, *, config: Config) -> CellSpec:
    host = row["host_name"]
    svc = row.get("service_description")
    if what == "service":
        dirs = match_path_entries_with_item(
            [cmk.utils.paths.default_config_dir / "notes/services"], host
        )
        item = svc
    else:
        dirs = [cmk.utils.paths.default_config_dir / "notes/hosts"]
        item = host

    assert isinstance(item, str)
    files = sorted(match_path_entries_with_item(dirs, item), reverse=True)
    contents = []

    def replace_tags(text: str) -> str:
        sitename = row["site"]
        url_prefix = config.sites[sitename]["url_prefix"]
        return (
            text.replace("$URL_PREFIX$", url_prefix)
            .replace("$SITE$", sitename)
            .replace("$HOSTNAME$", host)
            .replace("$HOSTNAME_LOWER$", host.lower())
            .replace("$HOSTNAME_UPPER$", host.upper())
            .replace("$HOSTNAME_TITLE$", host[0].upper() + host[1:].lower())
            .replace("$HOSTADDRESS$", row["host_address"])
            .replace("$SERVICEOUTPUT$", row.get("service_plugin_output", ""))
            .replace("$HOSTOUTPUT$", row.get("host_plugin_output", ""))
            .replace("$SERVICEDESC$", row.get("service_description", ""))
        )

    for f in files:
        contents.append(replace_tags(f.read_text(encoding="utf8").strip()))
    # These notes can only be created if you have site user access.
    # And yes that feature is used: SUP-15290
    return "", HTML.without_escaping("<hr>".join(contents))


class PainterSvcCustomNotes(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_custom_notes"

    @override
    def title(self, cell: Cell) -> str:
        return _("Custom services notes")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notes")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_name", "host_address", "service_description", "service_plugin_output"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_custom_notes("service", row, config=self.config)


class PainterSvcStaleness(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_staleness"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service staleness value")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Staleness")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_staleness"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", "%0.2f" % row.get("service_staleness", 0))


def _paint_is_stale(row: Row, staleness_threshold: float) -> CellSpec:
    if is_stale(row, staleness_threshold):
        return "badflag", HTMLWriter.render_span(_("yes"))
    return "goodflag", _("no")


class PainterSvcIsStale(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_is_stale"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service is stale")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Stale")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_staleness"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "svc_staleness"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_is_stale(row, self.config.staleness_threshold)


def _paint_custom_vars(what: str, row: Row, blacklist: list | None = None) -> CellSpec:
    if blacklist is None:
        blacklist = []

    items = sorted(row[what + "_custom_variables"].items())
    rows = []
    for varname, value in items:
        if varname not in blacklist:
            rows.append(
                HTMLWriter.render_tr(HTMLWriter.render_td(varname) + HTMLWriter.render_td(value))
            )
    return "", HTMLWriter.render_table(HTML.empty().join(rows))


def _export_custom_vars(what: str, row: Row, blacklist: list | None = None) -> str:
    if blacklist is None:
        blacklist = []

    items = sorted(row[what + "_custom_variables"].items())
    rows = []
    for varname, value in items:
        if varname not in blacklist:
            if value:
                rows.append(f"{varname}: {value}")
            else:
                rows.append(f"{varname}")
    return ", ".join(rows)


class PainterServiceCustomVariables(Painter):
    @property
    @override
    def ident(self) -> str:
        return "svc_custom_vars"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service custom attributes")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_custom_variables"]

    @override
    def group_by(self, row: Row, cell: Cell) -> tuple[tuple[str, str], ...]:
        return tuple(row["service_custom_variables"].items())

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_custom_vars("service", row)

    @override
    def export_for_csv(self, row: Row, cell: Cell, user: LoggedInUser) -> str:
        return _export_custom_vars("service", row)

    @override
    def export_for_json(self, row: Row, cell: Cell, user: LoggedInUser) -> str:
        return _export_custom_vars("service", row)


class ABCPainterCustomVariable(Painter, abc.ABC):
    @override
    def title(self, cell: Cell) -> str:
        return self._dynamic_title(cell.painter_parameters())

    @override
    def short_title(self, cell: Cell) -> str:
        return self._dynamic_title(cell.painter_parameters())

    @override
    def export_title(self, cell: Cell) -> str:
        if (params := cell.painter_parameters()) is None:
            return self.ident
        return f"{self.ident}_{params['ident']}"

    def _dynamic_title(self, params: PainterParameters | None = None) -> str:
        if params is None:
            # Happens in view editor when adding a painter
            return self._default_title

        try:
            attributes: dict = dict(self._custom_attribute_choices())
            return attributes[params["ident"]]
        except KeyError:
            return self._default_title

    @override
    def list_title(self, cell: Cell) -> str:
        return self._default_title

    @property
    @abc.abstractmethod
    def _default_title(self) -> str:
        raise NotImplementedError

    @property
    @abc.abstractmethod
    def _object_type(self) -> str:
        raise NotImplementedError

    @abc.abstractmethod
    def _custom_attribute_choices(self) -> DropdownChoiceEntries:
        raise NotImplementedError

    @property
    @override
    def parameters(self) -> Dictionary:
        return Dictionary(
            elements=[
                (
                    "ident",
                    DropdownChoice(
                        choices=self._custom_attribute_choices,
                        title=_("ID"),
                    ),
                ),
            ],
            title=_("Options"),
            optional_keys=[],
        )

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if (params := cell.painter_parameters()) is None:
            params = {}
        return paint_custom_var(self._object_type, params.get("ident", "").upper(), row)


class PainterServiceCustomVariable(ABCPainterCustomVariable):
    @property
    @override
    def ident(self) -> str:
        return "service_custom_variable"

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_custom_variable_names", "service_custom_variable_values"]

    @property
    @override
    def _default_title(self) -> str:
        return _("Service custom attribute")

    @property
    @override
    def _object_type(self) -> str:
        return "service"

    @override
    def _custom_attribute_choices(self) -> DropdownChoiceEntries:
        choices = []
        for ident, attr_spec in self.config.custom_service_attributes.items():
            choices.append((ident, attr_spec["title"]))
        return sorted(choices, key=lambda x: x[1])


class PainterHostCustomVariable(ABCPainterCustomVariable):
    @property
    @override
    def ident(self) -> str:
        return "host_custom_variable"

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variable_names", "host_custom_variable_values"]

    @override
    def group_by(self, row: Row, cell: Cell) -> str | tuple[str, ...]:
        if (parameters := cell.painter_parameters()) is None:
            return ""

        custom_variable_name = parameters["ident"]
        try:
            index = row["host_custom_variable_names"].index(custom_variable_name.upper())
        except ValueError:
            # group all hosts without this custom variable into a single group.
            # this group does not have a headline.
            return ""
        return row["host_custom_variable_values"][index]

    @property
    @override
    def _default_title(self) -> str:
        return _("Host custom attribute")

    @property
    @override
    def _object_type(self) -> str:
        return "host"

    @override
    def _custom_attribute_choices(self) -> DropdownChoiceEntries:
        choices = []
        for attr_spec in self.config.wato_host_attrs:
            choices.append((attr_spec["name"], attr_spec["title"]))
        return sorted(choices, key=lambda x: x[1])


# .
#   .--Hosts---------------------------------------------------------------.
#   |                       _   _           _                              |
#   |                      | | | | ___  ___| |_ ___                        |
#   |                      | |_| |/ _ \/ __| __/ __|                       |
#   |                      |  _  | (_) \__ \ |_\__ \                       |
#   |                      |_| |_|\___/|___/\__|___/                       |
#   |                                                                      |
#   +----------------------------------------------------------------------+
#   | Painters for hosts                                                   |
#   '----------------------------------------------------------------------'


class PainterHostState(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_state"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host state")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("State")

    @override
    def title_classes(self) -> list[str]:
        return ["center"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_has_been_checked", "host_state"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "hoststate"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_host_state_short(row, config=self.config)


class PainterHostStateOnechar(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_state_onechar"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host state (first character)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("S.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_has_been_checked", "host_state"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "hoststate"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_host_state_short(row, short=True, config=self.config)


class PainterHostPluginOutput(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_plugin_output"

    @override
    def title(self, cell: Cell) -> str:
        return _("Summary")

    @override
    def list_title(self, cell: Cell) -> str:
        return _("Summary (previously named: Status details or plug-in output)")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_plugin_output", "host_custom_variables"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (
            None,
            format_plugin_output(
                row["host_plugin_output"],
                request=self.request,
                must_escape=determine_must_escape(self.config.sites, row),
                row=row,
            ),
        )


class PainterHostPerfData(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_perf_data"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host metrics")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Metrics")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_perf_data"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["host_perf_data"])


class PainterHostCheckCommand(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_command"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host check command")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check command")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_check_command"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["host_check_command"])


class PainterHostCheckCommandExpanded(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_command_expanded"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host check command expanded")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check command expanded")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_check_command_expanded"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["host_check_command_expanded"])


class PainterHostNotesURL(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_notes_url"

    @override
    def title(self, cell: Cell) -> str:
        return _("Notes (URL) for hosts")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notes URL")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_address", "host_notes_url"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        raw_url = row.get("host_notes_url")
        if not raw_url:
            return None, HTML.empty()

        url = replace_action_url_macros(raw_url, "host", row)
        content = self.url_renderer.link_direct(url, html_text=url, target="_blank")
        return None, content


class PainterHostStateAge(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_state_age"

    @override
    def title(self, cell: Cell) -> str:
        return _("Age of the current host state")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Age")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_has_been_checked", "host_last_state_change"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["host_last_state_change"],
            row["host_has_been_checked"] == 1,
            60 * 10,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterHostCheckAge(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_age"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time since the last check of the host")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Checked")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_has_been_checked", "host_last_check"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_checked(
            "host",
            row,
            config=self.config,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterHostNextCheck(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_next_check"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time of the next scheduled host check")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Next check")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_next_check"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_future_time(
            row["host_next_check"],
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterHostNextNotification(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_next_notification"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time of the next host notification")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Next notification")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_next_notification"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_future_time(
            row["host_next_notification"],
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterHostNotificationPostponementReason(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_notification_postponement_reason"

    @override
    def title(self, cell: Cell) -> str:
        return _("Notification postponement reason")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notif. postponed")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_notification_postponement_reason"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_notification_postponement_reason("host", row)


class PainterHostLastNotification(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_last_notification"

    @override
    def title(self, cell: Cell) -> str:
        return _("Time of the last host notification")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("last notification")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_last_notification"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["host_last_notification"],
            row["host_last_notification"],
            0,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterHostCheckLatency(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_latency"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host check latency")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Latency")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_latency"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", approx_age(row["host_latency"]))


class PainterHostCheckDuration(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_duration"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host check duration")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Duration")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_execution_time"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", approx_age(row["host_execution_time"]))


class PainterHostAttempt(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_attempt"

    @override
    def title(self, cell: Cell) -> str:
        return _("Current host check attempt")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Att.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_current_attempt", "host_max_check_attempts"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, "%d/%d" % (row["host_current_attempt"], row["host_max_check_attempts"]))


class PainterHostNormalInterval(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_normal_interval"

    @override
    def title(self, cell: Cell) -> str:
        return _("Normal check interval")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check int.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_check_interval"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, approx_age(row["host_check_interval"] * 60.0))


class PainterHostRetryInterval(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_retry_interval"

    @override
    def title(self, cell: Cell) -> str:
        return _("Retry check interval")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Retry")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_retry_interval"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, approx_age(row["host_retry_interval"] * 60.0))


class PainterHostCheckInterval(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_interval"

    @override
    def title(self, cell: Cell) -> str:
        return _("Normal/retry check interval")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Interval")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_check_interval", "host_retry_interval"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (
            None,
            "%s / %s"
            % (
                approx_age(row["host_check_interval"] * 60.0),
                approx_age(row["host_retry_interval"] * 60.0),
            ),
        )


class PainterHostCheckType(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_check_type"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host check type")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Type")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_check_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["host_check_type"] == 0 and "ACTIVE" or "PASSIVE")


class PainterHostInNotifper(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_in_notifper"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host in notif. period")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("in notif. p.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_in_notification_period"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "host_in_notification_period", False)


class PainterHostNotifper(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_notifper"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host notification period")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("notif.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_notification_period"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["host_notification_period"])


class PainterHostNotificationNumber(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_notification_number"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host notification number")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("N#")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_current_notification_number"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", str(row["host_current_notification_number"]))


class PainterHostFlapping(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_flapping"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host is flapping")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Flap")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_is_flapping"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "host_is_flapping", True)


class PainterHostIsActive(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_is_active"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host is active")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Active")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_active_checks_enabled"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "host_active_checks_enabled", False)


class PainterHostNotificationsEnabled(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_notifications_enabled"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host notifications enabled")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notif.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_notifications_enabled"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "host_notifications_enabled", False)


class PainterHostBlack(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_black"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host name, red background if down or unreachable (deprecated)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Host")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["site", "host_name", "host_state"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "site_host"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        state = row["host_state"]
        if state != 0:
            return "nobr", HTMLWriter.render_div(row["host_name"], class_="hostdown")
        return "nobr", row["host_name"]


class PainterHostWithState(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_with_state"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host name, marked red if down (deprecated)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Host")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["site", "host_name", "host_state", "host_has_been_checked"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "site_host"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        state = row["host_state"] if row["host_has_been_checked"] else "p"
        if state != 0:
            return "state hstate hstate%s" % state, HTMLWriter.render_span(row["host_name"])
        return "nobr", row["host_name"]


class PainterHost(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Host")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_name", "host_state", "host_has_been_checked", "host_scheduled_downtime_depth"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "site_host"

    @property
    @override
    def parameters(self) -> Dictionary:
        elements: DictionaryElements = [
            (
                "color_choices",
                ListChoice(
                    choices=[
                        ("colorize_up", _("Colorize background if host is up")),
                        ("colorize_down", _("Colorize background if host is down")),
                        ("colorize_unreachable", _("Colorize background if host unreachable")),
                        ("colorize_pending", _("Colorize background if host is pending")),
                        ("colorize_downtime", _("Colorize background if host is downtime")),
                    ],
                    title=_("Coloring"),
                    help=_(
                        "Here, you can configure the background color for specific states. "
                        "The coloring for host in downtime overrules all other coloring."
                    ),
                ),
            )
        ]

        return Dictionary(elements=elements, title=_("Options"), optional_keys=[])

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if (params := cell.painter_parameters()) is None:
            params = {}

        color_choices = params.get("color_choices", [])

        state = row["host_state"] if row["host_has_been_checked"] else "p"

        css = ["nobr"]
        if "colorize_downtime" in color_choices and row["host_scheduled_downtime_depth"] > 0:
            css.extend(["hstate", "hstated"])

        # Also apply other css classes, even if its already in downtime
        for key, option_state in [
            ("colorize_up", 0),
            ("colorize_down", 1),
            ("colorize_unreachable", 2),
            ("colorize_pending", "p"),
        ]:
            if key in color_choices and state == option_state:
                if "hstate" not in css:
                    css.append("hstate")
                css.append("hstate%s" % option_state)
                break

        return " ".join(css), HTMLWriter.render_span(
            row["host_name"], class_=["state_rounded_fill", "host"]
        )


class PainterAlias(Painter):
    @property
    @override
    def ident(self) -> str:
        return "alias"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host alias")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Alias")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_alias"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", row["host_alias"])


class PainterHostAddress(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_address"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host address (primary)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("IP address")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_address"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", row["host_address"])


class PainterHostIpv4Address(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_ipv4_address"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host address (IPv4)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("IPv4 address")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variable_names", "host_custom_variable_values"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_custom_var("host", "ADDRESS_4", row)


class PainterHostIpv6Address(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_ipv6_address"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host address (IPv6)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("IPv6 address")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variable_names", "host_custom_variable_values"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_custom_var("host", "ADDRESS_6", row)


class PainterHostAddresses(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_addresses"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host addresses (IPv4/IPv6)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("IP addresses")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_address", "host_custom_variable_names", "host_custom_variable_values"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        custom_vars = dict(
            zip(row["host_custom_variable_names"], row["host_custom_variable_values"])
        )

        if custom_vars.get("ADDRESS_FAMILY", "4") == "4":
            primary = custom_vars.get("ADDRESS_4", "")
            secondary = custom_vars.get("ADDRESS_6", "")
        else:
            primary = custom_vars.get("ADDRESS_6", "")
            secondary = custom_vars.get("ADDRESS_4", "")

        if secondary:
            secondary = " (%s)" % secondary
        return "", primary + secondary


class PainterHostAddressesAdditional(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_addresses_additional"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host addresses (additional)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Add. addresses")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variable_names", "host_custom_variable_values"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        custom_vars = dict(
            zip(row["host_custom_variable_names"], row["host_custom_variable_values"])
        )

        ipv4_addresses = custom_vars.get("ADDRESSES_4", "").strip()
        ipv6_addresses = custom_vars.get("ADDRESSES_6", "").strip()

        addresses = []
        if ipv4_addresses:
            addresses += ipv4_addresses.split(" ")
        if ipv6_addresses:
            addresses += ipv6_addresses.split(" ")

        return "", ", ".join(addresses)


class PainterHostAddressFamily(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_address_family"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host address family (primary)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Address family")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variable_names", "host_custom_variable_values"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_custom_var("host", "ADDRESS_FAMILY", row)


class PainterHostAddressFamilies(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_address_families"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host address families")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Address families")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variable_names", "host_custom_variable_values"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        custom_vars = dict(
            zip(row["host_custom_variable_names"], row["host_custom_variable_values"])
        )

        primary = custom_vars.get("ADDRESS_FAMILY", "4")

        families = [primary]
        if primary == "6" and custom_vars.get("ADDRESS_4"):
            families.append("4")
        elif primary == "4" and custom_vars.get("ADDRESS_6"):
            families.append("6")

        return "", ", ".join(families)


def paint_svc_count(id_: int | str, count: int) -> CellSpec:
    if count > 0:
        return "count svcstate state%s" % id_, str(count)
    return "count svcstate", "0"


def paint_host_count(id_: int | None, count: int) -> CellSpec:
    if count > 0:
        if id_ is not None:
            return "count hstate hstate%s" % id_, str(count)
        # pending
        return "count hstate hstatep", str(count)
    return "count hstate", "0"


class PainterNumServices(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_services"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services")

    @override
    def short_title(self, cell: Cell) -> str:
        return ""

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, str(row["host_num_services"]))


class PainterNumServicesOk(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_services_ok"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state OK")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("OK")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services_ok"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(0, row["host_num_services_ok"])


class PainterNumProblems(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_problems"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of problems")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Prob.")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services", "host_num_services_ok", "host_num_services_pending"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(
            "s",
            row["host_num_services"]
            - row["host_num_services_ok"]
            - row["host_num_services_pending"],
        )


class PainterNumServicesWarn(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_services_warn"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state WARN")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Wa")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services_warn"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(1, row["host_num_services_warn"])


class PainterNumServicesCrit(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_services_crit"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state CRIT")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Cr")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services_crit"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(2, row["host_num_services_crit"])


class PainterNumServicesUnknown(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_services_unknown"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state UNKNOWN")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Un")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services_unknown"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(3, row["host_num_services_unknown"])


class PainterNumServicesPending(Painter):
    @property
    @override
    def ident(self) -> str:
        return "num_services_pending"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state PENDING")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Pd")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_num_services_pending"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count("p", row["host_num_services_pending"])


def _paint_service_list(row: Row, columnname: str, *, renderer: RenderLink) -> CellSpec:
    def sort_key(entry: tuple[str, int, int] | tuple[str, str, int, int]) -> tuple[str, ...]:
        if columnname.startswith("servicegroup") and isinstance(entry[1], str):
            return entry[0].lower(), entry[1].lower()
        return (entry[0].lower(),)

    h = HTML.empty()
    for entry in sorted(row[columnname], key=sort_key):
        if columnname.startswith("servicegroup"):
            host, svc, state, checked = entry
            text = host + " ~ " + svc
        else:
            svc, state, checked = entry
            host = row["host_name"]
            text = svc

        link = renderer.link_from_filename(
            "view.py",
            html_text=text,
            query_args=[
                ("view_name", "service"),
                ("site", row["site"]),
                ("host", host),
                ("service", svc),
            ],
        )

        css = "state%d" % state if checked else "statep"

        h += HTMLWriter.render_div(HTMLWriter.render_span(link), class_=css)

    return "", HTMLWriter.render_div(h, class_="objectlist")


class PainterHostServices(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_services"

    @override
    def title(self, cell: Cell) -> str:
        return _("Services colored according to state")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Services")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_name", "host_services_with_state"]

    @property
    @override
    def parameters(self) -> Dictionary:
        choices: ListChoiceChoices = [
            (0, _("OK")),
            (1, _("WARN")),
            (2, _("CRIT")),
            (3, _("UNKN")),
            ("p", _("PEND")),
        ]
        elements: DictionaryElements = [
            (
                "render_states",
                ListChoice(
                    choices=choices,
                    toggle_all=True,
                    default_value=[0, 1, 2, 3, "p"],
                    title=_("Only show services in this states"),
                    help=_(
                        "Here, you can configure which services are displayed depending on "
                        "their state. This is a filter at display level not query level."
                    ),
                ),
            )
        ]

        return Dictionary(elements=elements, title=_("Options"))

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if (params := cell.painter_parameters()) is None:
            params = {}

        render_states = params.get("render_states", [0, 1, 2, 3, "p"])
        render_pend = [1]
        if "p" in render_states:
            render_pend.append(0)

        filtered_services = []
        for svc, state, checked in row["host_services_with_state"]:
            if state in render_states and checked in render_pend:
                filtered_services.append([svc, state, checked])

        row["host_services_with_state_filtered"] = filtered_services

        return _paint_service_list(
            row, "host_services_with_state_filtered", renderer=self.url_renderer
        )


class PainterHostParents(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_parents"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host's parents")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Parents")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_parents"]

    @property
    @override
    def use_painter_link(self) -> bool:
        return False  # This painter adds individual links for the single hosts

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_host_list(row["site"], row["host_parents"], request=self.request)


class PainterHostChilds(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_childs"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host's children")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("children")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_childs"]

    @property
    @override
    def use_painter_link(self) -> bool:
        return False  # This painter adds individual links for the single hosts

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_host_list(row["site"], row["host_childs"], request=self.request)


class PainterHostGroupMemberlist(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_group_memberlist"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host groups the host is member of")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Groups")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_groups"]

    @override
    def group_by(self, row: Row, cell: Cell) -> tuple[str, ...]:
        return tuple(row["host_groups"])

    @property
    @override
    def use_painter_link(self) -> bool:
        return False  # This painter adds individual links for the single hosts

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        links = []
        for group in row["host_groups"]:
            link = self.url_renderer.link_from_filename(
                "view.py",
                html_text=group,
                query_args=[
                    ("view_name", "hostgroup"),
                    ("hostgroup", group),
                ],
            )
            links.append(link)
        return "", HTML.without_escaping(", ").join(links)

    @override
    def export_for_csv(self, row: Row, cell: Cell, user: LoggedInUser) -> str:
        return ", ".join(row["host_groups"])

    @override
    def export_for_json(self, row: Row, cell: Cell, user: LoggedInUser) -> object:
        return row["host_groups"]


class PainterHostContacts(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_contacts"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host contacts")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Contacts")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_contacts"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, ", ".join(row["host_contacts"]))


class PainterHostContactGroups(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_contact_groups"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host contact groups")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Contact groups")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_contact_groups"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, ", ".join(row["host_contact_groups"]))


class PainterHostCustomNotes(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_custom_notes"

    @override
    def title(self, cell: Cell) -> str:
        return _("Custom host notes")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Notes")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_name", "host_address", "host_plugin_output"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_custom_notes("hosts", row, config=self.config)


class PainterHostComments(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_comments"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host comments")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Comments")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_comments_with_info"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_comments("host_", row)


class PainterHostInDowntime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_in_downtime"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host in downtime")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Downtime")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_scheduled_downtime_depth"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "host_scheduled_downtime_depth", True)


class PainterHostAcknowledged(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_acknowledged"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host problem acknowledged")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Ack")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_acknowledged"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_nagiosflag(row, "host_acknowledged", False)


class PainterHostStaleness(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_staleness"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host staleness value")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Staleness")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_staleness"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", "%0.2f" % row.get("host_staleness", 0))


class PainterHostIsStale(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_is_stale"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host is stale")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Stale")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_staleness"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "svc_staleness"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_is_stale(row, self.config.staleness_threshold)


class PainterHostCustomVariables(Painter):
    BLACKLIST: list[str] = [
        "FILENAME",
        "TAGS",
        "ADDRESS_4",
        "ADDRESS_6",
        "ADDRESS_FAMILY",
        "NODEIPS",
        "NODEIPS_4",
        "NODEIPS_6",
    ]

    @property
    @override
    def ident(self) -> str:
        return "host_custom_vars"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host custom attributes")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_custom_variables"]

    @override
    def group_by(self, row: Row, cell: Cell) -> tuple[tuple[str, str], ...]:
        return tuple(row["host_custom_variables"].items())

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_custom_vars("host", row, self.BLACKLIST)

    @override
    def export_for_csv(self, row: Row, cell: Cell, user: LoggedInUser) -> str:
        return _export_custom_vars("host", row, self.BLACKLIST)

    @override
    def export_for_json(self, row: Row, cell: Cell, user: LoggedInUser) -> str:
        return _export_custom_vars("host", row, self.BLACKLIST)


def _paint_discovery_output(
    field: str,
    row: Row,
    *,
    renderer: RenderLink,
    theme: Theme,
) -> CellSpec:
    value: str = row[field]
    if field == "discovery_state":
        ruleset_url = "wato.py?mode=edit_ruleset&varname=ignored_services"
        discovery_url = "wato.py?mode=inventory&host=%s&mode=inventory" % row["host_name"]

        return (
            None,
            {
                "ignored": html.render_icon_button(
                    ruleset_url,
                    _("Disabled (configured away by admin)"),
                    StaticIcon(IconNames.rulesets),
                    theme=theme,
                )
                + HTML.with_escaping(_("Disabled (configured away by admin)")),
                "vanished": html.render_icon_button(
                    discovery_url,
                    _("Vanished (checked, but no longer exists)"),
                    StaticIcon(IconNames.services),
                    theme=theme,
                )
                + HTML.with_escaping(_("Vanished (checked, but no longer exists)")),
                "unmonitored": html.render_icon_button(
                    discovery_url,
                    _("Available (missing)"),
                    StaticIcon(IconNames.services),
                    theme=theme,
                )
                + HTML.with_escaping(_("Available (missing)")),
            }.get(value, value),
        )
    if not (field == "discovery_service" and row["discovery_state"] == "vanished"):
        return None, value

    href = renderer.link_from_filename(
        "view.py",
        html_text=value,
        query_args=[
            ("view_name", "service"),
            ("site", row["site"]),
            ("host", row["host_name"]),
            ("service", value),
        ],
    )
    return None, HTMLWriter.render_div(href)


class PainterServiceDiscoveryState(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_discovery_state"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service discovery: State")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("State")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["discovery_state"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_discovery_output(
            "discovery_state", row, renderer=self.url_renderer, theme=self.theme
        )


class PainterServiceDiscoveryCheck(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_discovery_check"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service discovery: Check type")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Check type")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["discovery_state", "discovery_check", "discovery_service"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_discovery_output(
            "discovery_check", row, renderer=self.url_renderer, theme=self.theme
        )


class PainterServiceDiscoveryService(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_discovery_service"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service discovery: Service name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Service name")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["discovery_state", "discovery_check", "discovery_service"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_discovery_output(
            "discovery_service", row, renderer=self.url_renderer, theme=self.theme
        )


#    _   _           _
#   | | | | ___  ___| |_ __ _ _ __ ___  _   _ _ __  ___
#   | |_| |/ _ \/ __| __/ _` | '__/ _ \| | | | '_ \/ __|
#   |  _  | (_) \__ \ || (_| | | | (_) | |_| | |_) \__ \
#   |_| |_|\___/|___/\__\__, |_|  \___/ \__,_| .__/|___/
#                       |___/                |_|
#
class PainterHostgroupHosts(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hostgroup_hosts"

    @override
    def title(self, cell: Cell) -> str:
        return _("Hosts colored according to state (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Hosts")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_members_with_state"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        divs = []
        for host, state, checked in row["hostgroup_members_with_state"]:
            link = self.url_renderer.link_from_filename(
                "view.py",
                html_text=host,
                query_args=[
                    ("view_name", "host"),
                    ("site", row["site"]),
                    ("host", host),
                ],
            )
            css = "hstate%d" % state if checked else "hstatep"
            divs.append(HTMLWriter.render_div(link, class_=css))
        return "", HTMLWriter.render_div(HTML.empty().join(divs), class_="objectlist")


class PainterHgNumServices(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_services"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return ""

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_services"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, str(row["hostgroup_num_services"]))


class PainterHgNumServicesOk(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_services_ok"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state OK (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("O")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_services_ok"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(0, row["hostgroup_num_services_ok"])


class PainterHgNumServicesWarn(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_services_warn"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state WARN (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("W")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_services_warn"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(1, row["hostgroup_num_services_warn"])


class PainterHgNumServicesCrit(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_services_crit"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state CRIT (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("C")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_services_crit"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(2, row["hostgroup_num_services_crit"])


class PainterHgNumServicesUnknown(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_services_unknown"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state UNKNOWN (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("U")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_services_unknown"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(3, row["hostgroup_num_services_unknown"])


class PainterHgNumServicesPending(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_services_pending"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state PENDING (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("P")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_services_pending"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count("p", row["hostgroup_num_services_pending"])


class PainterHgNumHostsUp(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_hosts_up"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of hosts in state UP (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Up")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_hosts_up"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_host_count(0, row["hostgroup_num_hosts_up"])


class PainterHgNumHostsDown(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_hosts_down"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of hosts in state DOWN (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Dw")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_hosts_down"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_host_count(1, row["hostgroup_num_hosts_down"])


class PainterHgNumHostsUnreach(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_hosts_unreach"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of hosts in state UNREACH (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Un")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_hosts_unreach"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_host_count(2, row["hostgroup_num_hosts_unreach"])


class PainterHgNumHostsPending(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_num_hosts_pending"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of hosts in state PENDING (host group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Pd")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_num_hosts_pending"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_host_count(None, row["hostgroup_num_hosts_pending"])


class PainterHgName(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_name"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host group name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Name")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_name"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["hostgroup_name"])


class PainterHgAlias(Painter):
    @property
    @override
    def ident(self) -> str:
        return "hg_alias"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host group alias")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Alias")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["hostgroup_alias"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["hostgroup_alias"])


#    ____                  _
#   / ___|  ___ _ ____   _(_) ___ ___  __ _ _ __ ___  _   _ _ __  ___
#   \___ \ / _ \ '__\ \ / / |/ __/ _ \/ _` | '__/ _ \| | | | '_ \/ __|
#    ___) |  __/ |   \ V /| | (_|  __/ (_| | | | (_) | |_| | |_) \__ \
#   |____/ \___|_|    \_/ |_|\___\___|\__, |_|  \___/ \__,_| .__/|___/
#                                     |___/                |_|


class PainterSgServices(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_services"

    @override
    def title(self, cell: Cell) -> str:
        return _("Services colored according to state (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Services")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_members_with_state"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_service_list(
            row, "servicegroup_members_with_state", renderer=self.url_renderer
        )


class PainterSgNumServices(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_num_services"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return ""

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_num_services"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, str(row["servicegroup_num_services"]))


class PainterSgNumServicesOk(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_num_services_ok"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state OK (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("O")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_num_services_ok"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(0, row["servicegroup_num_services_ok"])


class PainterSgNumServicesWarn(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_num_services_warn"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state WARN (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("W")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_num_services_warn"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(1, row["servicegroup_num_services_warn"])


class PainterSgNumServicesCrit(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_num_services_crit"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state CRIT (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("C")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_num_services_crit"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(2, row["servicegroup_num_services_crit"])


class PainterSgNumServicesUnknown(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_num_services_unknown"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state UNKNOWN (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("U")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_num_services_unknown"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(3, row["servicegroup_num_services_unknown"])


class PainterSgNumServicesPending(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_num_services_pending"

    @override
    def title(self, cell: Cell) -> str:
        return _("Number of services in state PENDING (service group)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("P")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_num_services_pending"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count("p", row["servicegroup_num_services_pending"])


class PainterSgName(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_name"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service group name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Name")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_name"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["servicegroup_name"])


class PainterSgAlias(Painter):
    @property
    @override
    def ident(self) -> str:
        return "sg_alias"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service group alias")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Alias")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["servicegroup_alias"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["servicegroup_alias"])


#     ____                                     _
#    / ___|___  _ __ ___  _ __ ___   ___ _ __ | |_ ___
#   | |   / _ \| '_ ` _ \| '_ ` _ \ / _ \ '_ \| __/ __|
#   | |__| (_) | | | | | | | | | | |  __/ | | | |_\__ \
#    \____\___/|_| |_| |_|_| |_| |_|\___|_| |_|\__|___/
#


class PainterCommentId(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_id"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment ID")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("ID")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_id"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, str(row["comment_id"]))


class PainterCommentAuthor(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_author"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment author")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Author")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_author"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["comment_author"])


class PainterCommentComment(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_comment"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment text")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_comment"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (
            None,
            format_plugin_output(
                row["comment_comment"],
                request=self.request,
                must_escape=determine_must_escape(self.config.sites, row),
                row=row,
            ),
        )


class PainterCommentWhat(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_what"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment type (host/service)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Type")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["comment_type"] == 1 and _("Host") or _("Service"))


class PainterCommentTime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_time"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment entry time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Time")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_entry_time"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["comment_entry_time"],
            True,
            3600,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterCommentExpires(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_expires"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment expiry time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Expires")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_expire_time"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["comment_expire_time"],
            row["comment_expire_time"] != 0,
            3600,
            request=self.request,
            painter_options=self._painter_options,
            what="future",
        )


class PainterCommentEntryType(Painter):
    @property
    @override
    def ident(self) -> str:
        return "comment_entry_type"

    @override
    def title(self, cell: Cell) -> str:
        return _("Comment entry type (user/downtime/flapping/ack)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("E.Type")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["comment_entry_type", "host_name", "service_description"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        t = row["comment_entry_type"]
        linkview = None
        if t == 1:
            icon = StaticIcon(IconNames.comment)
            help_txt = _("Comment")
        elif t == 2:
            icon = StaticIcon(IconNames.downtime)
            help_txt = _("Downtime")
            linkview = "downtimes_of_service" if row["service_description"] else "downtimes_of_host"

        elif t == 3:
            icon = StaticIcon(IconNames.flapping)
            help_txt = _("Flapping")
        elif t == 4:
            icon = StaticIcon(IconNames.ack)
            help_txt = _("Acknowledgment")
        else:
            return "", ""
        code: str | HTML = html.render_static_icon(icon, title=help_txt)
        if linkview:
            code = render_link_to_view(
                code,
                row,
                VisualLinkSpec("views", linkview),
                self._user_permissions,
                request=self.request,
            )
        return "icons", code


#    ____                      _   _
#   |  _ \  _____      ___ __ | |_(_)_ __ ___   ___  ___
#   | | | |/ _ \ \ /\ / / '_ \| __| | '_ ` _ \ / _ \/ __|
#   | |_| | (_) \ V  V /| | | | |_| | | | | | |  __/\__ \
#   |____/ \___/ \_/\_/ |_| |_|\__|_|_| |_| |_|\___||___/
#


class PainterDowntimeId(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_id"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime ID")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("ID")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_id"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, "%d" % row["downtime_id"])


class PainterDowntimeAuthor(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_author"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime author")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Author")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_author"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["downtime_author"])


class PainterDowntimeComment(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_comment"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime comment")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Comment")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_comment"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (
            None,
            format_plugin_output(
                row["downtime_comment"],
                request=self.request,
                must_escape=determine_must_escape(self.config.sites, row),
                row=row,
            ),
        )


class PainterDowntimeFixed(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_fixed"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime start mode")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Mode")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_fixed"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["downtime_fixed"] == 0 and _("flexible") or _("fixed"))


class PainterDowntimeOrigin(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_origin"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime origin")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Origin")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_origin"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["downtime_origin"] == 1 and _("configuration") or _("command"))


class PainterDowntimeWhat(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_what"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime for host/service")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("for")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_is_service"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["downtime_is_service"] and _("Service") or _("Host"))


class PainterDowntimeType(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_type"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime active or pending")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("act/pend")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["is_pending"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return (None, row["is_pending"] == 0 and _("active") or _("pending"))


class PainterDowntimeEntryTime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_entry_time"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime entry time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Entry")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_entry_time"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["downtime_entry_time"],
            True,
            3600,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterDowntimeStartTime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_start_time"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime start time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Start")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_start_time"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["downtime_start_time"],
            True,
            3600,
            request=self.request,
            painter_options=self._painter_options,
            what="both",
        )


class PainterDowntimeEndTime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_end_time"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime end time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("End")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_end_time"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["downtime_end_time"],
            True,
            3600,
            request=self.request,
            painter_options=self._painter_options,
            what="both",
        )


class PainterDowntimeDuration(Painter):
    @property
    @override
    def ident(self) -> str:
        return "downtime_duration"

    @override
    def title(self, cell: Cell) -> str:
        return _("Downtime duration (if flexible)")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Flex. duration")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["downtime_duration", "downtime_fixed"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if row["downtime_fixed"] == 0:
            return "number", "%02d:%02d:00" % divmod(int(row["downtime_duration"] / 60.0), 60)
        return "", ""


#    _
#   | |    ___   __ _
#   | |   / _ \ / _` |
#   | |__| (_) | (_| |
#   |_____\___/ \__, |
#               |___/


class PainterLogDetailsHistory(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_details_history"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: Details")

    @property
    @override
    def columns(self) -> list[ColumnName]:
        return [
            "log_long_plugin_output",
            "service_check_command",
            "service_custom_variables",
            "host_custom_variables",
        ]

    @property
    @override
    def parameters(self) -> Dictionary:
        return Dictionary(
            elements=[
                (
                    "max_len",
                    Integer(
                        title=_("Maximum number of characters to show"),
                        help=_(
                            "Truncate content at this amount of characters. "
                            "A zero value means not to truncate."
                        ),
                        default_value=0,
                        minvalue=0,
                    ),
                ),
            ],
        )

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if (params := cell.painter_parameters()) is None:
            params = {}

        max_len = params.get("max_len", 0)
        long_output = row["log_long_plugin_output"]
        long_output_len = len(long_output)

        if 0 < max_len < len(long_output):
            long_output = long_output[:max_len] + "..."

        # See werk #15523.
        is_ps_check = row["service_check_command"] == "check_mk-ps"
        # We can only display tables if they are complete.
        non_displayable_html = "<table>" in long_output and not long_output.endswith("</table>")
        # Only hand over relevant row to ensure correct escaping options in
        # case of ps_check. Otherwise "ESCAPE_PLUGIN_OUTPUT" would be used in
        # format_plugin_output()
        row_to_format = (
            {"log_long_plugin_output": long_output} if is_ps_check and non_displayable_html else row
        )
        content = format_plugin_output(
            long_output,
            request=self.request,
            row=row_to_format,
            must_escape=determine_must_escape(self.config.sites, row),
            newlineishs_to_brs=True,
        )

        if is_ps_check:
            content = HTML.without_escaping(str(content).replace("&bsol%3B", "\\"))

        # has to be placed after format_plugin_output() to keep links save from
        # escaping
        host_custom_variables: dict = row.get("host_custom_variables", {})
        custom_vars = row.get("service_custom_variables", host_custom_variables)
        escape_plugin_output = custom_vars.get("ESCAPE_PLUGIN_OUTPUT", "1") == "0"
        if long_output_len > max_len and escape_plugin_output and non_displayable_html:
            setting_link_tag = self.url_renderer.link_from_filename(
                "wato.py",
                html_text="(%s)" % _("Increase limit for future entries"),
                query_args=[
                    ("mode", "edit_configvar"),
                    ("varname", "max_long_output_size"),
                ],
            )
            content = (
                _("HTML output cannot be rendered because of truncated data. ")
                + setting_link_tag
                + html.render_b("WARN", class_="stmark state1")
                + html.render_br()
                + content
            )

        return paint_stalified(row, content, self.config.staleness_threshold)


class PainterLogMessage(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_message"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: complete message")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Message")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_message"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", row["log_message"])


class PainterLogPluginOutput(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_plugin_output"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: Summary")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Summary")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_plugin_output", "log_type", "log_state_type", "log_comment"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        if output := self._decode_item(row, column="log_plugin_output"):
            return "", format_plugin_output(
                output,
                request=self.request,
                must_escape=determine_must_escape(self.config.sites, row),
                row=row,
            )

        if comment := self._decode_item(row, column="log_comment"):
            return "", comment

        log_type = row["log_type"]
        lst = row["log_state_type"]
        if "FLAPPING" in log_type:
            what = _("host") if "HOST" in log_type else _("service")
            if lst == "STOPPED":
                return "", _("The %(what)s stopped flapping") % {"what": what}
            return "", _("The %(what)s started flapping") % {"what": what}
        if lst:
            return "", (lst + " - " + log_type)
        return "", ""

    @staticmethod
    def _decode_item(row: Row, *, column: Literal["log_plugin_output", "log_comment"]) -> str:
        """Decode escaped characters coming from Nagios history monitoring."""
        # TODO: decode all escaped characters coming from monitoring history.
        return row.get(column, "").replace("%3B", ";")


class PainterLogWhat(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_what"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: host or service")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Host/service")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        lt = row["log_type"]
        if "HOST" in lt:
            return "", _("Host")
        if "SERVICE" in lt or "SVC" in lt:
            return "", _("Service")
        return "", _("Program")


class PainterLogAttempt(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_attempt"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: number of check attempt")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Att.")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_attempt"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", str(row["log_attempt"]))


class PainterLogStateType(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_state_type"

    @override
    def title(self, cell: Cell) -> str:
        return _('Log: state type (DEPRECATED: Use "state information")')

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Type")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_state_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", row["log_state_type"])


class PainterLogStateInfo(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_state_info"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: State information")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("State info")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_state_info", "log_state_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        info = row["log_state_info"]

        # be compatible to <1.7 remote sites and show log_state_type content as fallback
        if not info:
            info = row["log_state_type"]

        return ("", info)


class PainterLogType(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_type"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: event")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Event")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("nowrap", row["log_type"])


class PainterLogContactName(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_contact_name"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: contact name")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Contact")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_contact_name"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        target_view_name = self.url_renderer.get_filename(
            filename="contactnotifications",
            mobile_filename="mobile_contactnotifications",
        )
        links = [
            self.url_renderer.link_from_filename(
                "view.py",
                html_text=contact,
                query_args=[
                    ("view_name", target_view_name),
                    ("log_contact_name", contact),
                ],
                mobile_filename="mobile_view.py",
            )
            for contact in row["log_contact_name"].split(",")
        ]
        return "nowrap", HTML.without_escaping(", ").join(links)


class PainterLogCommand(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_command"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: command/plug-in")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Command")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_command_name"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("nowrap", row["log_command_name"])


class PainterLogIcon(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_icon"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: event icon")

    @override
    def short_title(self, cell: Cell) -> str:
        return ""

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_type", "log_state", "log_state_type", "log_command_name"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        img: StaticIcon | None = None
        log_type = row["log_type"]
        log_state = row["log_state"]

        if log_type == "SERVICE ALERT":
            img = {
                0: StaticIcon(IconNames.alert_ok),
                1: StaticIcon(IconNames.alert_warn),
                2: StaticIcon(IconNames.alert_crit),
                3: StaticIcon(IconNames.alert_unknown),
            }.get(row["log_state"])
            title = _("Service alert")

        elif log_type == "HOST ALERT":
            img = {
                0: StaticIcon(IconNames.alert_up),
                1: StaticIcon(IconNames.alert_down),
                2: StaticIcon(IconNames.alert_unreach),
            }.get(row["log_state"])
            title = _("Host alert")

        elif log_type.endswith("ALERT HANDLER STARTED"):
            img = StaticIcon(IconNames.alert_alert_handler_started)
            title = _("Alert handler started")

        elif log_type.endswith("ALERT HANDLER STOPPED"):
            if log_state == 0:
                img = StaticIcon(IconNames.alert_alert_handler_stopped)
                title = _("Alert handler stopped")
            else:
                img = StaticIcon(IconNames.alert_alert_handler_failed)
                title = _("Alert handler failed")

        elif "DOWNTIME" in log_type:
            if row["log_state_type"] in ["END", "STOPPED"]:
                img = StaticIcon(IconNames.alert_downtimestop)
                title = _("Downtime stopped")
            else:
                img = StaticIcon(IconNames.alert_downtime)
                title = _("Downtime")

        elif log_type.endswith("NOTIFICATION"):
            if row["log_command_name"] == "check-mk-notify":
                img = StaticIcon(IconNames.alert_cmk_notify)
                title = _("Core produced a notification")
            else:
                img = StaticIcon(IconNames.alert_notify)
                title = _("User notification")

        elif log_type.endswith("NOTIFICATION RESULT"):
            img = StaticIcon(IconNames.alert_notify_result)
            title = _("Final notification result")

        elif log_type.endswith("NOTIFICATION PROGRESS"):
            img = StaticIcon(IconNames.alert_notify_progress)
            title = _("The notification is being processed")

        elif log_type == "EXTERNAL COMMAND":
            img = StaticIcon(IconNames.alert_command)
            title = _("External command")

        elif "restarting..." in log_type:
            img = StaticIcon(IconNames.alert_restart)
            title = _("Core restarted")

        elif "Reloading configuration" in log_type:
            img = StaticIcon(IconNames.alert_reload)
            title = _("Core configuration reloaded")

        elif "starting..." in log_type:
            img = StaticIcon(IconNames.alert_start)
            title = _("Core started")

        elif "shutdown..." in log_type or "shutting down" in log_type:
            img = StaticIcon(IconNames.alert_stop)
            title = _("Core stopped")

        elif " FLAPPING " in log_type:
            img = StaticIcon(IconNames.alert_flapping)
            title = _("Flapping")

        elif "ACKNOWLEDGE ALERT" in log_type:
            if row["log_state_type"] == "STARTED":
                img = StaticIcon(IconNames.alert_ack)
                title = _("Acknowledged")
            else:
                img = StaticIcon(IconNames.alert_ackstop)
                title = _("Stopped acknowledgment")

        if img:
            return "icon", html.render_static_icon(img, title=title)
        return "icon", ""


class PainterLogOptions(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_options"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: informational part of message")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Info")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_options"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", row["log_options"])


def _log_comment_min_fields(log_type: str) -> int:
    """Minimum number of ";"-separated fields in a notification log line
    before a trailing comment field is present.

    Host notification log lines have one field fewer than service
    notification log lines (they lack the ";<service>" segment), so the
    threshold below which no comment field can be present differs between
    the two. See cmk.events.log_to_history._format_notification_message,
    which is the counterpart producing these log lines.
    """
    return 6 if "SERVICE" in log_type else 5


class PainterLogComment(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_comment"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: comment")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Comment")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_options", "log_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        msg = row["log_options"]
        if ";" in msg:
            parts = msg.split(";")
            if len(parts) > _log_comment_min_fields(row.get("log_type", "")):
                return ("", parts[-1])
        return ("", "")


class PainterLogTime(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_time"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: entry time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Time")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_time"]

    @property
    @override
    def painter_options(self) -> list[str]:
        return ["ts_format", "ts_date"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_age(
            row["log_time"],
            True,
            3600 * 24,
            request=self.request,
            painter_options=self._painter_options,
        )


class PainterLogLineno(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_lineno"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: line number in log file")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Line")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_lineno"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("number", str(row["log_lineno"]))


class PainterLogDate(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_date"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: day of entry")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Date")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_time"]

    @override
    def group_by(self, row: Row, cell: Cell) -> str:
        return str(_paint_day(row["log_time"])[1])

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return _paint_day(row["log_time"])


class PainterLogState(Painter):
    @property
    @override
    def ident(self) -> str:
        return "log_state"

    @override
    def title(self, cell: Cell) -> str:
        return _("Log: state of host/service at log time")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("State")

    @override
    def title_classes(self) -> list[str]:
        return ["center"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_state", "log_state_type", "log_service_description", "log_type"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        state = row["log_state"]

        # Notification result/progress lines don't hold real states. They hold notification plugin
        # exit results (0: ok, 1: temp issue, 2: perm issue). We display them as service states.
        if (
            row["log_service_description"]
            or row["log_type"].endswith("NOTIFICATION RESULT")
            or row["log_type"].endswith("NOTIFICATION PROGRESS")
        ):
            return _paint_service_state_short(
                {"service_has_been_checked": 1, "service_state": state},
                config=self.config,
            )
        return _paint_host_state_short(
            {"host_has_been_checked": 1, "host_state": state},
            config=self.config,
        )


# Alert statistics


class PainterAlertStatsOk(Painter):
    @property
    @override
    def ident(self) -> str:
        return "alert_stats_ok"

    @override
    def title(self, cell: Cell) -> str:
        return _("Alert statistics: Number of recoveries")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("OK")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_alerts_ok"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return ("", str(row["log_alerts_ok"]))


class PainterAlertStatsWarn(Painter):
    @property
    @override
    def ident(self) -> str:
        return "alert_stats_warn"

    @override
    def title(self, cell: Cell) -> str:
        return _("Alert statistics: Number of warnings")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("WARN")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_alerts_warn"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(1, row["log_alerts_warn"])


class PainterAlertStatsCrit(Painter):
    @property
    @override
    def ident(self) -> str:
        return "alert_stats_crit"

    @override
    def title(self, cell: Cell) -> str:
        return _("Alert statistics: Number of critical alerts")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("CRIT")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_alerts_crit"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(2, row["log_alerts_crit"])


class PainterAlertStatsUnknown(Painter):
    @property
    @override
    def ident(self) -> str:
        return "alert_stats_unknown"

    @override
    def title(self, cell: Cell) -> str:
        return _("Alert statistics: Number of unknown alerts")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("UNKN")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_alerts_unknown"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count(3, row["log_alerts_unknown"])


class PainterAlertStatsProblem(Painter):
    @property
    @override
    def ident(self) -> str:
        return "alert_stats_problem"

    @override
    def title(self, cell: Cell) -> str:
        return _("Alert statistics: Number of problem alerts")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Problems")

    @override
    def title_classes(self) -> list[str]:
        return ["right"]

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["log_alerts_problem"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return paint_svc_count("s", row["log_alerts_problem"])


#
# TAGS
#


class PainterHostTags(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_tags"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host tags")

    @override
    def short_title(self, cell: Cell) -> str:
        return self.title(cell)

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_tags"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "host"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return "", render_tag_groups(
            get_tag_groups(row, "host"), "host", with_links=True, request=self.request
        )


class ABCPainterTagsWithTitles(Painter, abc.ABC):
    @property
    @abc.abstractmethod
    def object_type(self) -> str:
        raise NotImplementedError

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        entries = self._get_entries(row)
        return "", HTMLWriter.render_br().join(
            [
                escaping.escape_to_html_permissive("%s: %s" % e, escape_links=False)
                for e in sorted(entries)
            ]
        )

    def _get_entries(self, row: Row) -> list[tuple[str, str]]:
        entries = []
        aux_titles = _aux_tag_titles(self.config.tags)
        for tag_group_id, tag_id in get_tag_groups(row, self.object_type).items():
            tag_group = self.config.tags.get_tag_group(tag_group_id)
            if tag_group:
                choices = tag_choices_for_group(tag_group)
                entries.append((tag_group.title, choices.get(tag_id, tag_id)))
                continue

            aux_tag_title = aux_titles.get(tag_group_id)
            if aux_tag_title:
                entries.append((aux_tag_title, aux_tag_title))
                continue

            entries.append((tag_group_id, tag_id))
        return entries


@request_memoize()
def _aux_tag_titles(tag_config: TagConfig) -> dict[str, str]:
    return dict(tag_config.aux_tag_list.get_choices())


class PainterHostTagsWithTitles(ABCPainterTagsWithTitles):
    @property
    @override
    def object_type(self) -> str:
        return "host"

    @property
    @override
    def ident(self) -> str:
        return "host_tags_with_titles"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host tags (with titles)")

    @override
    def short_title(self, cell: Cell) -> str:
        return self.title(cell)

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_tags"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "host"


class PainterServiceTags(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_tags"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service tags")

    @override
    def short_title(self, cell: Cell) -> str:
        return self.title(cell)

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_tags"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "service_tags"

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return "", render_tag_groups(
            get_tag_groups(row, "service"), "service", with_links=True, request=self.request
        )


class PainterServiceTagsWithTitles(ABCPainterTagsWithTitles):
    @property
    @override
    def object_type(self) -> str:
        return "service"

    @property
    @override
    def ident(self) -> str:
        return "service_tags_with_titles"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service tags (with titles)")

    @override
    def short_title(self, cell: Cell) -> str:
        return self.title(cell)

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_tags"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "service_tags"


class PainterHostLabels(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_labels"

    @override
    def title(self, cell: Cell) -> str:
        return _("Host labels")

    @override
    def short_title(self, cell: Cell) -> str:
        return self.title(cell)

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_labels", "host_label_sources"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "host_labels"

    @override
    def _compute_data(self, row: Row, cell: Cell, user: LoggedInUser) -> Labels:
        return get_labels(row, "host")

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return "", render_labels(
            self._compute_data(row, cell, user),
            "host",
            with_links=True,
            label_sources=get_label_sources(row, "host"),
            request=self.request,
        )

    @override
    def export_for_python(self, row: Row, cell: Cell, user: LoggedInUser) -> Labels:
        return self._compute_data(row, cell, user)

    @override
    def export_for_csv(self, row: Row, cell: Cell, user: LoggedInUser) -> str | HTML:
        return format_labels_for_csv_export(self._compute_data(row, cell, user))

    @override
    def export_for_json(self, row: Row, cell: Cell, user: LoggedInUser) -> Labels:
        return self._compute_data(row, cell, user)


class PainterServiceLabels(Painter):
    @property
    @override
    def ident(self) -> str:
        return "service_labels"

    @override
    def title(self, cell: Cell) -> str:
        return _("Service labels")

    @override
    def short_title(self, cell: Cell) -> str:
        return self.title(cell)

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_labels", "service_label_sources"]

    @property
    @override
    def sorter(self) -> SorterName:
        return "service_labels"

    @override
    def _compute_data(self, row: Row, cell: Cell, user: LoggedInUser) -> Labels:
        return get_labels(row, "service")

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        return "", render_labels(
            self._compute_data(row, cell, user),
            "service",
            with_links=True,
            label_sources=get_label_sources(row, "service"),
            request=self.request,
        )

    @override
    def export_for_python(self, row: Row, cell: Cell, user: LoggedInUser) -> Labels:
        return self._compute_data(row, cell, user)

    @override
    def export_for_csv(self, row: Row, cell: Cell, user: LoggedInUser) -> str | HTML:
        return format_labels_for_csv_export(self._compute_data(row, cell, user))

    @override
    def export_for_json(self, row: Row, cell: Cell, user: LoggedInUser) -> Labels:
        return self._compute_data(row, cell, user)


class PainterHostDockerNode(Painter):
    @property
    @override
    def ident(self) -> str:
        return "host_docker_node"

    @override
    def title(self, cell: Cell) -> str:
        return _("Docker node")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Node")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_labels", "host_label_sources"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        """We use the information stored in output of docker_container_status
        here. It's the most trusted source of the current node the container is
        running on."""
        if row.get("host_labels", {}).get("cmk/docker_object") != "container":
            return "", ""

        docker_nodes = _get_docker_container_status_outputs()
        output = docker_nodes.get(row["host_name"])
        # Output with node: "Container running on node mynode2"
        # Output without node: "Container running"
        if output is None or "node" not in output:
            return "", ""

        node = output.split()[-1]
        content = self.url_renderer.link_from_filename(
            "view.py",
            query_args=[
                ("view_name", "host"),
                ("host", node),
            ],
            html_text=node,
        )
        return "", content


@request_memoize()
def _get_docker_container_status_outputs() -> dict[str, str]:
    """Returns a map of all known hosts with their docker nodes

    It is important to cache this query per request and also try to use the
    liveproxyd query cached.
    """
    query: str = (
        "GET services\n"
        "Columns: host_name service_plugin_output\n"
        "Filter: check_command = check_mk-docker_container_status\n"
    )
    return {row[0]: row[1] for row in sites.live().query(query)}


class AbstractColumnSpecificMetric(Painter):
    @property
    @override
    def ident(self) -> str:
        raise NotImplementedError

    @override
    def title(self, cell: Cell) -> str:
        return self._title_with_parameters(cell.painter_parameters(), metrics_from_api)

    @override
    def short_title(self, cell: Cell) -> str:
        return self._title_with_parameters(cell.painter_parameters(), metrics_from_api)

    @override
    def list_title(self, cell: Cell) -> str:
        return _("Metric")

    def _title_with_parameters(
        self,
        parameters: PainterParameters | None,
        registered_metrics: Mapping[str, RegisteredMetric],
    ) -> str:
        try:
            if not parameters:
                # Used in Edit-View
                return _("Show single metric")
            return get_metric_spec(parameters["metric"], registered_metrics).title
        except KeyError:
            return _("Metric not found")

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        raise NotImplementedError

    @property
    @override
    def parameters(self) -> Dictionary:
        return Dictionary(
            elements=[
                (
                    "metric",
                    DropdownChoice(
                        title=_("Show metric"),
                        choices=self._metric_choices(),
                        help=_("If available, the following metric will be shown"),
                    ),
                ),
                ("column_title", TextInput(title=_("Custom title"))),
            ],
            optional_keys=["column_title"],
        )

    @classmethod
    @request_memoize()
    def _metric_choices(cls) -> list[tuple[str, str]]:
        return sorted(
            (
                (metric_id, metric_title)
                for metric_id, metric_title in registered_metric_ids_and_titles(metrics_from_api)
            ),
            key=lambda x: x[1],
        )

    def _render(
        self, row: Row, cell: Cell, perf_data_entries: str, check_command: str
    ) -> tuple[str, str]:
        parameters = cell.painter_parameters()
        assert parameters is not None
        show_metric = parameters["metric"]

        perf_data, check_command = parse_perf_data(
            perf_data_entries, check_command, debug=self.config.debug
        )
        temperature_unit = get_temperature_unit(user, self.config.default_temperature_unit)
        translated_metrics = translate_metrics(
            perf_data,
            check_command,
            metrics_from_api,
            temperature_unit=temperature_unit,
        )

        if show_metric not in translated_metrics:
            return "", ""

        translated_metric = translated_metrics[show_metric]

        return (
            "",
            user_specific_unit(translated_metric.unit_spec, temperature_unit).formatter.render(
                translated_metric.value
            ),
        )


class PainterHostSpecificMetric(AbstractColumnSpecificMetric):
    @property
    @override
    def ident(self) -> str:
        return "host_specific_metric"

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_perf_data", "host_check_command"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        perf_data_entries = row["host_perf_data"]
        check_command = row["host_check_command"]
        return self._render(row, cell, perf_data_entries, check_command)


class PainterServiceSpecificMetric(AbstractColumnSpecificMetric):
    @property
    @override
    def ident(self) -> str:
        return "service_specific_metric"

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["service_perf_data", "service_check_command"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        perf_data_entries = row["service_perf_data"]
        check_command = row["service_check_command"]
        return self._render(row, cell, perf_data_entries, check_command)


class _PainterHostKubernetes(Painter):
    """
    Link to kubernetes dashboard. The filters are set in a way that only hosts
    belonging to the kubernetes_object are shown.

    A host representing a kubernetes cluster will link to the kubernetes
    cluster dashboard. This dashboard should only display objects (=cmk hosts)
    belonging to cluster. So the link to the dashboard is augmented by a
    kubernetes_cluster filter.

    As nodes are not unique among multiple clusters, chains of multiple filters
    have to build for certain objects: in order to show only objects of a
    certain node, both node and cluster filter needs to be present.

    The cmk host names and the kubernetes names may differ: normally the cmk
    host names of kubernetes objects are prefixed with the cluster name. This
    painter will show the original kubernetes name, not the checkmk host name.
    """

    _kubernetes_object_type: str
    """
    The content of the corresponding label will be displayed by this painter.
    """
    _constraints: list[str]
    """
    Defines which filters should be added for building up the link.
    """

    @property
    @override
    def ident(self) -> str:
        return f"host_kubernetes_{self._kubernetes_object_type}"

    @property
    @override
    def columns(self) -> Sequence[ColumnName]:
        return ["host_labels", "host_name", "site"]

    @override
    def render(self, row: Row, cell: Cell, user: LoggedInUser) -> CellSpec:
        labels = row.get("host_labels", {})
        if labels.get("cmk/kubernetes/object") != self._kubernetes_object_type:
            return "", ""

        links: HTTPVariables = []
        for link_key in self._constraints:
            if (link_value := labels.get(f"cmk/kubernetes/{link_key}")) is None:
                # a requested filter can not be set, so better don't show anything
                return "", ""

            links.append((f"kubernetes_{link_key}", link_value))

        links.extend(
            [
                # name of the dashboard we are linking to
                ("name", f"kubernetes_{self._kubernetes_object_type}"),
                ("host", row["host_name"]),
                ("site", row["site"]),
            ]
        )

        if (object_name := labels.get(f"cmk/kubernetes/{self._kubernetes_object_type}")) is None:
            return "", ""

        content = self.url_renderer.link_from_filename(
            "dashboard.py", html_text=object_name, query_args=links
        )
        return "", content


class PainterHostKubernetesCluster(_PainterHostKubernetes):
    _kubernetes_object_type = "cluster"
    _constraints = ["cluster"]

    @override
    def title(self, cell: Cell) -> str:
        return _("Kubernetes cluster")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Cluster")


class PainterHostKubernetesNamespace(_PainterHostKubernetes):
    _kubernetes_object_type = "namespace"
    _constraints = ["namespace", "cluster-host", "cluster"]

    @override
    def title(self, cell: Cell) -> str:
        return _("Kubernetes Namespace")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Namespace")


class PainterHostKubernetesDeployment(_PainterHostKubernetes):
    _kubernetes_object_type = "deployment"
    _constraints = ["deployment", "namespace", "cluster-host", "cluster"]

    @override
    def title(self, cell: Cell) -> str:
        return _("Kubernetes deployment")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Deployment")


class PainterHostKubernetesDaemonset(_PainterHostKubernetes):
    _kubernetes_object_type = "daemonset"
    _constraints = ["daemonset", "namespace", "cluster-host", "cluster"]

    @override
    def title(self, cell: Cell) -> str:
        return _("Kubernetes DaemonSet")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("DaemonSet")


class PainterHostKubernetesStatefulset(_PainterHostKubernetes):
    _kubernetes_object_type = "statefulset"
    _constraints = ["statefulset", "namespace", "cluster-host", "cluster"]

    @override
    def title(self, cell: Cell) -> str:
        return _("Kubernetes StatefulSet")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("StatefulSet")


class PainterHostKubernetesNode(_PainterHostKubernetes):
    _kubernetes_object_type = "node"
    _constraints = ["node", "cluster"]

    @override
    def title(self, cell: Cell) -> str:
        return _("Kubernetes node")

    @override
    def short_title(self, cell: Cell) -> str:
        return _("Node")