#!/usr/bin/env python3
# -*- coding: utf-8; py-indent-offset: 4 -*-
#
# Author:  Linuxfabrik GmbH, Zurich, Switzerland
# Contact: info (at) linuxfabrik (dot) ch
#          https://www.linuxfabrik.ch/
# License: The Unlicense, see LICENSE file.

# https://github.com/Linuxfabrik/monitoring-plugins/blob/main/CONTRIBUTING.md

"""See the check's README for more details."""

import argparse
import json
import os
import sys

import lib.args
import lib.base
import lib.lftest
import lib.redfish
import lib.txt
import lib.url
from lib.globals import STATE_CRIT, STATE_OK, STATE_UNKNOWN, STATE_WARN

__author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
__version__ = '2026060706'

DESCRIPTION = """Reports the firmware inventory of a Redfish-compatible server via the Redfish API.
Lists every firmware component with its installed version and identification, and alerts whenever a
component reports a degraded or failed health state."""

API_BASE = '/redfish/v1'
DEFAULT_CACHE_EXPIRE = 15  # minutes; keep below the controller's session timeout
DEFAULT_INSECURE = True
DEFAULT_NO_PROXY = False
DEFAULT_RETRIES = 3  # extra attempts on a failed Redfish request
DEFAULT_TIMEOUT = 8
DEFAULT_URL = 'https://localhost:5000'


def parse_args():
    """Parse command line arguments using argparse."""
    parser = argparse.ArgumentParser(description=DESCRIPTION)

    parser.add_argument(
        '-V',
        '--version',
        action='version',
        version=f'%(prog)s: v{__version__} by {__author__}',
    )

    parser.add_argument(
        '--always-ok',
        help=lib.args.help('--always-ok'),
        dest='ALWAYS_OK',
        action='store_true',
        default=False,
    )

    parser.add_argument(
        '--brief',
        help='Hide items that are OK and show only those in WARN/CRIT state. '
        'Alerting is unaffected: all items still drive the overall check state. '
        'Default: %(default)s',
        dest='BRIEF',
        action='store_true',
        default=False,
    )

    parser.add_argument(
        '--cache-expire',
        help=lib.args.help('--cache-expire') + ' Default: %(default)s',
        dest='CACHE_EXPIRE',
        type=int,
        default=DEFAULT_CACHE_EXPIRE,
    )

    parser.add_argument(
        '--ignore',
        help='Ignore items whose name matches this Python regular expression. '
        'Case-sensitive by default; use `(?i)` for case-insensitive matching. '
        'Can be specified multiple times.',
        dest='IGNORE',
        action='append',
        default=None,
    )

    parser.add_argument(
        '--insecure',
        help=lib.args.help('--insecure'),
        dest='INSECURE',
        action='store_true',
        default=DEFAULT_INSECURE,
    )

    parser.add_argument(
        '--inventory',
        help='Output the parsed components as JSON on stdout and exit OK, instead of '
        'running a health check. Use this to collect a hardware inventory: the JSON is a '
        'single object keyed by component type, so the output of several Redfish checks can '
        'be merged into one inventory document with `jq --slurp`. Ignores --brief, --match '
        'and --ignore. Default: %(default)s',
        dest='INVENTORY',
        action='store_true',
        default=False,
    )

    parser.add_argument(
        '--match',
        help='Only check items whose name matches this Python regular expression. '
        'Case-sensitive by default; use `(?i)` for case-insensitive matching. '
        'Can be specified multiple times.',
        dest='MATCH',
        action='append',
        default=None,
    )

    parser.add_argument(
        '--no-proxy',
        help=lib.args.help('--no-proxy'),
        dest='NO_PROXY',
        action='store_true',
        default=DEFAULT_NO_PROXY,
    )

    parser.add_argument(
        '--password',
        help='Redfish API password.',
        dest='PASSWORD',
    )

    parser.add_argument(
        '--retries',
        help='Number of extra attempts if a request to the Redfish API fails, before the '
        'check gives up. Helps against an occasionally slow or flaky management controller. '
        'Default: %(default)s',
        dest='RETRIES',
        type=int,
        default=DEFAULT_RETRIES,
    )

    parser.add_argument(
        '--test',
        help=lib.args.help('--test'),
        dest='TEST',
        type=lib.args.csv,
    )

    parser.add_argument(
        '--timeout',
        help=lib.args.help('--timeout') + ' Default: %(default)s (seconds)',
        dest='TIMEOUT',
        type=int,
        default=DEFAULT_TIMEOUT,
    )

    parser.add_argument(
        '--url',
        help='Redfish API URL. Default: %(default)s',
        dest='URL',
        default=DEFAULT_URL,
    )

    parser.add_argument(
        '--username',
        help='Redfish API username.',
        dest='USERNAME',
    )

    args, _ = parser.parse_known_args()
    return args


def load_test_fixture(test_args, path):
    # Replace the first element of args.TEST with the walk-specific
    # fixture path, read it via lib.lftest.test() and return the parsed
    # JSON. On a missing file or malformed JSON, exit STATE_UNKNOWN with
    # a helpful message instead of letting json.loads raise a traceback.
    if not os.path.isfile(path):
        lib.base.cu(f'Test fixture not found: "{path}".')
    test_args[0] = path
    stdout, _, _ = lib.lftest.test(test_args)
    try:
        return json.loads(stdout)
    except (json.JSONDecodeError, ValueError) as e:
        lib.base.cu(f'Test fixture "{path}" does not contain valid JSON: {e}')


def main():
    """The main function. This is where the magic happens."""

    # parse the command line
    try:
        args = parse_args()
    except SystemExit:
        sys.exit(STATE_UNKNOWN)

    # set default values for append parameters that were not specified
    if args.IGNORE is None:
        args.IGNORE = []
    if args.MATCH is None:
        args.MATCH = []

    # compile the item filter regexes once
    ignore_patterns = [
        lib.base.coe(p) for p in lib.txt.compile_regex(args.IGNORE, '--ignore')
    ]
    match_patterns = [
        lib.base.coe(p) for p in lib.txt.compile_regex(args.MATCH, '--match')
    ]

    # fetch data
    if args.TEST is None:
        if not args.URL.startswith('http'):
            lib.base.cu('--url parameter has to start with "http://" or https://".')
        header = {'Accept': 'application/json'}
        # reuse a cached Redfish session token across requests and runs, so we
        # do not create (and have the controller log) a new session each time
        header.update(lib.redfish.get_auth_header(args))
        # Entry point: the FirmwareInventory collection
        result = lib.base.coe(
            lib.url.fetch_json(
                f'{args.URL}{API_BASE}/UpdateService/FirmwareInventory',
                header=header,
                insecure=args.INSECURE,
                no_proxy=args.NO_PROXY,
                timeout=args.TIMEOUT,
                retries=args.RETRIES,
            )
        )
    else:
        # do not call the API, put in test data. Each API call in the
        # Redfish walk has an explicit fixture suffix, so the fixture
        # file names describe what they contain (firmwareinventory,
        # firmware-N).
        test_base = args.TEST[0]
        result = load_test_fixture(args.TEST, f'{test_base}-firmwareinventory')
    # "Members": [
    #     {
    #         "@odata.id": "/redfish/v1/UpdateService/FirmwareInventory/BIOS"
    #     }
    # ],
    if len(result.get('Members', [])) == 0:
        lib.base.cu('Nothing to check, no Redfish members found.')

    # init some vars
    msg = ''
    state = STATE_OK
    perfdata = ''
    component_count = 0
    component_not_ok = 0
    # only allocated and populated in --inventory mode, so a normal health
    # check holds nothing extra in memory
    inventory = [] if args.INVENTORY else None

    # analyze data: follow each "Member" link and aggregate firmware-component
    # health into `state`. Every component is listed regardless of its state,
    # because this check doubles as a firmware version inventory.
    table_data = []
    for fw_idx, firmware in enumerate(result.get('Members', [])):
        if args.TEST is None:
            # "/redfish/v1/UpdateService/FirmwareInventory/BIOS"
            firmware_data = lib.base.coe(
                lib.url.fetch_json(
                    f'{args.URL}{firmware["@odata.id"]}',
                    header=header,
                    insecure=args.INSECURE,
                    no_proxy=args.NO_PROXY,
                    timeout=args.TIMEOUT,
                    retries=args.RETRIES,
                )
            )
        else:
            firmware_data = load_test_fixture(
                args.TEST, f'{test_base}-firmware-{fw_idx}'
            )
        firmware_data = lib.redfish.get_updateservice_firmwareinventory(firmware_data)
        # collect for --inventory before any display filter (--match/--ignore/--brief)
        if args.INVENTORY:
            inventory.append(dict(firmware_data))
        # --match/--ignore: filter by item name
        item_name = firmware_data['Name'] or firmware_data.get('Id', '')
        if ignore_patterns and any(p.search(item_name) for p in ignore_patterns):
            continue
        if match_patterns and not any(p.search(item_name) for p in match_patterns):
            continue
        component_count += 1
        # is the firmware component healthy at all?
        firmware_data_state = lib.redfish.get_state(firmware_data)
        state = lib.base.get_worst(state, firmware_data_state)
        firmware_data['State'] = lib.base.state2str(firmware_data_state, empty_ok=False)
        if firmware_data_state != STATE_OK:
            component_not_ok += 1
        table_data.append(firmware_data)

    if args.BRIEF:
        table_data = [r for r in table_data if r.get('State') != '[OK]']
    if table_data:
        keys = [
            'Name',
            'Version',
            'Manufacturer',
            'ReleaseDate',
            'Updateable',
            'State',
        ]
        headers = [
            'Component',
            'Version',
            'Manufacturer',
            'ReleaseDate',
            'Updateable',
            'State',
        ]
        msg += lib.base.get_table(table_data, keys, header=headers)

    # --inventory: emit the collected components as JSON and exit before
    # building the human-readable message and perfdata
    if args.INVENTORY:
        print(
            json.dumps(
                {'firmware': inventory}, ensure_ascii=False, indent=4, sort_keys=True
            )
        )
        sys.exit(STATE_OK)

    # build the message
    components = lib.txt.pluralize('component', component_count)
    if state == STATE_CRIT:
        msg = (
            f'Checked {component_count} firmware {components}.'
            f' There are critical errors.\n\n'
        ) + msg
    elif state == STATE_WARN:
        msg = (
            f'Checked {component_count} firmware {components}. There are warnings.\n\n'
        ) + msg
    else:
        msg = (
            f'Everything is ok, checked {component_count} firmware {components}.\n\n'
        ) + msg

    # perfdata: how many firmware components were checked and how many are not OK
    perfdata = lib.base.get_perfdata(
        'firmware_components',
        component_count,
        _min=0,
    )
    perfdata += lib.base.get_perfdata(
        'firmware_components_not_ok',
        component_not_ok,
        _min=0,
    )

    # over and out
    lib.base.oao(msg, state, perfdata, always_ok=args.ALWAYS_OK)


if __name__ == '__main__':
    try:
        main()
    except Exception:
        lib.base.cu()
