#!/usr/bin/env python3
# pylint: disable=line-too-long, simplifiable-if-statement, missing-module-docstring, too-many-locals, unused-argument

from pprint import pprint

from cmk.utils import debug

# import necessary elements from API version 2
from cmk.agent_based.v2 import (
    AgentSection,
    CheckPlugin,
    Service,
    Result,
    State,
    Metric,
)


def get_state_upper(
    levels: tuple[int | float, int | float], value: int | float
) -> State:
    """returns OK/WARN/CRIT depending on the given parameters"""
    warn, crit = levels
    if value >= crit:
        return State.CRIT
    if value >= warn:
        return State.WARN
    return State.OK


def parse_mailcow_info(string_table) -> dict:
    """the parse function"""
    parsed_data = {}
    # we only expect one line with 7 entries
    line = string_table[0]
    version = line[0]
    num_domains = int(line[1])
    num_mailboxes = int(line[2])
    num_global_messages = int(line[3])
    git_version = line[4]
    update_available = line[5]
    if update_available == "True":
        update_available = True
    else:
        update_available = False
    check_version_enabled = line[6]
    if check_version_enabled == "True":
        check_version_enabled = True
    else:
        check_version_enabled = False
    parsed_data["version"] = version
    parsed_data["num_domains"] = num_domains
    parsed_data["num_mailboxes"] = num_mailboxes
    parsed_data["num_global_messages"] = num_global_messages
    parsed_data["git_version"] = git_version
    parsed_data["update_available"] = update_available
    parsed_data["check_version_enabled"] = check_version_enabled
    return parsed_data


def discover_mailcow_info(section):
    """the discover function"""
    yield Service()


def check_mailcow_info(params, section):
    """the check function"""
    if debug.enabled():
        pprint(section)
    # get thresholds
    _type, levels_num_domains = params["levels_num_domains"]
    _type, levels_num_mailboxes = params["levels_num_mailboxes"]
    _type, levels_num_global_messages = params["levels_num_global_messages"]
    # get all section data
    version: str = section["version"]
    git_version: str = section["git_version"]
    check_version_enabled: bool = section["check_version_enabled"]
    update_available: bool = section["update_available"]
    num_domains: int = section["num_domains"]
    num_mailboxes: int = section["num_mailboxes"]
    num_global_messages: int = section["num_global_messages"]

    # create graphs for number of domains, mailboxes and messages
    yield Metric(name="mc_num_domains", value=num_domains, levels=levels_num_domains)
    yield Metric(
        name="mc_num_mailboxes", value=num_mailboxes, levels=levels_num_mailboxes
    )
    yield Metric(
        name="mc_num_global_messages",
        value=num_global_messages,
        levels=levels_num_global_messages,
    )

    # create overall result
    if check_version_enabled:
        if update_available:
            summary = f"Update available: Running version is {version}, Github version is: {git_version}"
            state = State.WARN
        else:
            summary = f"No update available: Running version is {version}, Github version is: {git_version}"
            state = State.OK
    else:
        summary = f"Version is {version}, Update check is disabled"
        state = State.OK
    details = f"Mailcow version: {version}\nNumber of domains: {num_domains}\nNumber of mailboxes: {num_mailboxes}\nNumber of messages: {num_global_messages}"
    yield Result(state=state, summary=summary, details=details)

    # Create result for number of domains
    warn, crit = levels_num_domains
    state = get_state_upper((warn, crit), num_domains)
    notice = f"Number of domains: {num_domains}"
    if state != State.OK:
        yield Result(state=state, notice=notice)

    # Create result for number of mailboxes
    warn, crit = levels_num_mailboxes
    state = get_state_upper((warn, crit), num_mailboxes)
    notice = f"Number of mailboxes: {num_mailboxes}"
    if state != State.OK:
        yield Result(state=state, notice=notice)

    # Create result for number of global messages
    warn, crit = levels_num_global_messages
    state = get_state_upper((warn, crit), num_global_messages)
    notice = f"Number of messages: {num_global_messages}"
    if state != State.OK:
        yield Result(state=state, notice=notice)


# create the new agent section, must begin with "agent_section_"
# and must be an instance of "AgentSection"
agent_section_mailcow_info = AgentSection(
    # "name" must exactly match the section name within the agent output
    name="mailcow_info",
    # define the parse function, name is arbitrary, a good choice is to choose
    # "parse_" as prefix and append the section name
    parse_function=parse_mailcow_info,
)

# create the new check plugin, must begin with "check_plugin_"
#  and must be an instance of "CheckPlugin"
check_plugin_mailcow_info = CheckPlugin(
    # "name" should be the same as the corresponding section within the agent output
    name="mailcow_info",
    service_name="Mailcow info",
    # define the discovery function, name is arbitrary, a good choice is to choose
    # "discover_" as prefix and append the section name
    discovery_function=discover_mailcow_info,
    # define the check function, name is arbitrary, a good choice is to choose
    # "check_" as prefix and append the section name
    check_function=check_mailcow_info,
    # define the default parameters
    check_default_parameters={
        "levels_num_domains": ("fixed", (100, 200)),
        "levels_num_mailboxes": ("fixed", (500, 1000)),
        "levels_num_global_messages": ("fixed", (100_000, 250_000)),
    },
    # connect to the ruleset where parameters can be defined
    # must match the name of the ruleset exactly
    check_ruleset_name="mailcow_info",
)