<?php
/**
 * Observium
 *
 *   This file is part of Observium.
 *
 * @package    observium
 * @subpackage entities
 * @copyright  (C) Adam Armstrong
 *
 */

function discover_processor_definition($device, $mib, $entry) {

    // Just append mib name to definition entry, for simple pass to external functions
    if (empty($entry['mib'])) {
        $entry['mib'] = $mib;
    }

    // Check that types listed in skip_if_valid_exist have already been found
    if (discovery_check_if_type_exist($entry, 'processor')) {
        echo '!]';
        return FALSE;
    }

    // Check array requirements list
    if (discovery_check_requires_pre($device, $entry, 'processor')) {
        echo '!]';
        return FALSE;
    }

    // Units, see: LANCOM-GS2310PPLUS-MIB
    $unit = $entry['unit'] ?? NULL;

    // CLEANME, Compat, remove when converted
    if ($entry['type'] === 'table' && !isset($entry['table'])) {
        $entry['table'] = $entry['object'];
    }
    // elseif (!isset($entry['rename_rrd']) && OBSERVIUM_REV < 13500) {
    //     // Add rename by default
    //     $entry['rename_rrd'] = $entry['object'] . '-%index%';
    // }

    // Fetch table or Oids
    $table_oids = [
        'oid', 'oid_descr', 'oid_scale', 'oid_precision', 'oid_count',
        //'oid_limit_low', 'oid_limit_low_warn', 'oid_limit_high_warn', 'oid_limit_high', 'oid_limit_warn',
        //'oid_limit_nominal', 'oid_limit_delta_warn', 'oid_limit_delta', 'oid_limit_scale',
        'oid_extra', //'oid_unit', 'oid_entPhysicalIndex'
    ];
    $processors_array = discover_fetch_oids($device, $mib, $entry, $table_oids);

    if (empty($entry['oid_num'])) {
        // Use snmptranslate if oid_num not set
        $entry['oid_num'] = snmp_translate($entry['oid'], $mib);
    }

    $found = FALSE;
    $i = 1; // Used in descr as $i++
    $processors_count = count($processors_array);
    foreach ($processors_array as $index => $processor) {
        $dot_index = '.' . $index;
        $oid_num   = $entry['oid_num'] . $dot_index;

        // Check valid exist with entity tags
        if (discovery_check_if_type_exist($entry, 'processor', $processor)) {
            continue;
        }

        // Rewrite specific keys
        $index_tags = entity_index_tags($index, $i);
        $options = [ 'i' => $i, 'count' => $processors_count, 'oid' => $entry['oid'] ];
        if ($processors_count === 1 && isset($entry['indexes'])) {
            // Compat with old static definitions
            $options['indexes'] = count($entry['indexes']);
        }

        $descr = entity_descr_definition('processor', $entry, array_merge($index_tags, $processor), $processors_count);

        if (isset($entry['oid_count'])) {
            // See F5-PLATFORM-STATS-MIB
            if (str_contains($entry['oid_count'], '.')) {
                $oid = array_tag_replace($index_tags, $entry['oid_count']);
                // Get processors count if exist for MIB
                $processor_count = snmp_get_oid($device, $oid, $mib);
            } else {
                $processor_count = $processor[$entry['oid_count']];
            }
            if (is_numeric($processor_count) && $processor_count > 1) {
                $descr .= ' x' . $processor_count;
            }
            $options['count'] = $processor_count;
        }

        // Options
        if (!empty($unit)) {
            $options['unit'] = $unit;
        }

        if (isset($entry['idle'])) {
            $options['idle'] = $entry['idle'] ? 1 : 0;
        }
        // FIXME. entPhysicalIndex and hrDeviceIndex

        // Rename old (converted) RRDs to definition format
        if (isset($entry['rename_rrd'])) {
            $options['rename_rrd'] = $entry['rename_rrd'];
        }

        // Precision (scale)
        // FIXME, currently we support only int precision, need convert all to float scale!
        $scale     = entity_scale_definition($device, $entry, $processor, 'processor');
        $precision = $scale !== 1 ? round(float_div(1, $scale)) : 1;

        $usage = snmp_fix_numeric($processor[$entry['oid']], $unit);
        if (discovery_check_value_valid($device, $usage, $entry, 'processor')) {
            discover_processor_ng($device, $mib, $entry['object'], $oid_num, $index, $descr, $precision, $usage, $options);
            $found = TRUE;
        }
        $i++;
    }

    return $found;
}

// Compatibility wrapper!
function discover_processor(&$valid, $device, $processor_oid, $processor_index, $processor_type, $processor_descr, $processor_precision = 1, $value = NULL, $entPhysicalIndex = NULL, $hrDeviceIndex = NULL, $processor_returns_idle = 0) {

    $options = [ 'idle' => $processor_returns_idle ? 1 : 0 ];
    if (!safe_empty($processor_type)) {
        $options['processor_type'] = $processor_type;
    }
    if (!safe_empty($entPhysicalIndex)) {
        $options['entPhysicalIndex'] = $entPhysicalIndex;
    }
    if (!safe_empty($hrDeviceIndex)) {
        $options['hrDeviceIndex'] = $hrDeviceIndex;
    }

    return discover_processor_ng($device, '', '', $processor_oid, $processor_index, $processor_descr, $processor_precision, $value, $options);
}

function discover_processor_ng($device, $processor_mib, $processor_object, $processor_oid, $processor_index,
                               $processor_descr, $processor_precision = 1, $value = NULL, $options = []) {

    // Old: processor_type
    // New: mib-object
    if ($discovery_ng = empty($options['processor_type'])) {
        if (!empty($processor_object)) {
            $processor_type = $processor_object;
        }
        if (!empty($processor_mib)) {
            $processor_type = $processor_mib . '-' . $processor_type;
        }
    } else {
        $processor_type = $options['processor_type'];
    }

    // Split unit need extend type for multiple entities (see NEWTEC-DEVICE-MIB definition)
    if (!empty($options['unit']) && str_starts_with($options['unit'], 'split_cpu')) {
        $processor_type .= '-' . $options['unit'];
    }

    // Idle (100-proc)?
    $processor_returns_idle = isset($options['idle']) && $options['idle'];

    print_debug($device['device_id'] . " -> $processor_oid, $processor_index, $processor_type, $processor_descr, $processor_precision, $value");

    // Check processor ignore filters
    if (entity_descr_check($processor_descr, 'processor')) {
        return FALSE;
    }

    // Skip discovery processor if value not numeric or null(default)
    if ($value !== NULL) {
        $value = snmp_fix_numeric($value);
    }

    if (!(is_numeric($value) || $value === NULL)) {
        print_debug("Skipped by not numeric value: $value, $processor_descr ");
        return FALSE;
    }

    // Main params
    $params = [ 'processor_index', 'processor_mib', 'processor_object', 'processor_oid', 'processor_type', 'processor_descr', 'processor_precision' ];
    $params_opt = [ 'entPhysicalIndex' => 'entPhysicalIndex', 'hrDeviceIndex' => 'hrDeviceIndex', 'idle' => 'processor_returns_idle' ];

    $processor_db = dbFetchRow("SELECT * FROM `processors` WHERE `device_id` = ? AND `processor_index` = ? AND `processor_type` = ?", [ $device['device_id'], $processor_index, $processor_type ]);

    // Compat with old discovery (update instead delete/add)
    if ($discovery_ng && !$processor_db) {
        if (isset($options['indexes'])) {
            // Old static converted to indexes
            $processor_db = dbFetchRow("SELECT * FROM `processors` WHERE `device_id` = ? AND `processor_index` = ? AND `processor_oid` = ? AND `processor_mib` IS NULL",
                                       [ $device['device_id'], $processor_index, $processor_oid ]);
        } else {
            $old_index1 = $processor_object . '.' . $processor_index;
            $old_index2 = $options['oid'] . '.' . $processor_index;
            $processor_db = dbFetchRow("SELECT * FROM `processors` WHERE `device_id` = ? AND `processor_index` IN (?, ?, ?) AND `processor_type` = ? AND `processor_mib` IS NULL",
                                       [ $device['device_id'], $processor_index, $old_index1, $old_index2, $processor_object ]);
        }
        if (!isset($options['rename_rrd']) && isset($processor_db['processor_index'])) {
            // Derp old table indexes..
            if ($processor_db['processor_index'] === $old_index1) {
                $options['rename_rrd'] = $processor_object . '-' . $old_index1;
            } elseif ($processor_db['processor_index'] === $old_index2) {
                $options['rename_rrd'] = $processor_object . '-' . $old_index2;
            }
        }
    }

    if (!isset($processor_db['processor_id'])) {
        $insert = [ 'device_id' => $device['device_id'] ];
        if (!$processor_precision) {
            $processor_precision = 1;
        }
        foreach ($params as $param) {
            $insert[$param] = $$param ?? [ 'NULL' ];
        }
        foreach ($params_opt as $opt => $param) {
            if (isset($options[$opt])) {
                $insert[$param] = $options[$opt];
            }
        }

        if ($processor_precision != 1) {
            $value = round(float_div($value, $processor_precision), 2);
        }
        // The OID returns idle value, so we subtract it from 100.
        if ($processor_returns_idle) {
            $value = 100 - $value;
        }

        $insert['processor_usage'] = $value;
        $id = dbInsert($insert, 'processors');

        $GLOBALS['module_stats']['processors']['added']++;
        log_event("Processor added: index $processor_index, type $processor_type, descr $processor_descr", $device, 'processor', $id);
    } else {
        $update = [];
        foreach ($params as $param) {
            if ($$param != $processor_db[$param]) {
                $update[$param] = $$param ?? [ 'NULL' ];
            }
        }
        foreach ($params_opt as $opt => $param) {
            if (isset($options[$opt]) && $options[$opt] != $processor_db[$param]) {
                print_debug_vars($options);
                print_debug_vars($processor_db);
                $update[$param] = $options[$opt];
            }
        }

        // Skip WMI processor description update, this is done in poller
        if (isset($update['processor_descr']) && $processor_type === 'hr' &&
            ($update['processor_descr'] === 'Unknown Processor Type' || $update['processor_descr'] === 'Intel') &&
            is_module_enabled($device, 'wmi', 'poller')) {
            unset($update['processor_descr']);
        }

        if (count($update)) {
            dbUpdate($update, 'processors', '`processor_id` = ?', [ $processor_db['processor_id'] ]);
            $GLOBALS['module_stats']['processors']['updated']++;
            log_event("Processor updated: index $processor_index, type $processor_type, descr $processor_descr", $device, 'processor', $processor_db['processor_id']);
        } else {
            $GLOBALS['module_stats']['processors']['unchanged']++;
        }
        $id = $processor_db['processor_id'];
    }

    // Rename old (converted) RRDs to definition format
    if (isset($options['rename_rrd'])) {
        $rrd_tags = [
            'index'  => $processor_index,
            'type'   => $processor_type,
            'mib'    => $processor_mib,
            'object' => $processor_object,
            'oid'    => $processor_object,
            'count'  => $options['count'],
            'i'      => $options['i'],
            // for rrd
            'processor_index'  => $processor_index,
            'processor_type'   => $processor_type,
            'processor_mib'    => $processor_mib,
            'processor_object' => $processor_object,
        ];

        $options['rename_rrd'] = array_tag_replace($rrd_tags, $options['rename_rrd']);

        $old_rrd = 'processor-' . $options['rename_rrd'];
        $new_rrd = get_processor_rrd($device, $rrd_tags);
        rename_rrd($device, $old_rrd, $new_rrd);
    }

    $GLOBALS['valid']['processor'][$processor_type][$processor_index] = 1;

    return $id;
}

function get_processor_rrd($device, $processor, $full = TRUE) {
    $index = $processor['processor_index'];

    if (!empty($processor['processor_mib']) && !empty($processor['processor_object'])) {
        // for discover_processor_ng(), note here is just status index
        if ($processor['processor_type'] === $processor['processor_mib'] . '-' . $processor['processor_object']) {
            // FIXME. Use old style of rrd naming, because rename rrd impossible for remote rrd
            $rrd_file = $processor['processor_object'] . "-" . $index;
        } else {
            $rrd_file = $processor['processor_mib'] . "-" . $processor['processor_object'] . "-" . $index;
        }
    } else {
        // for discover_processor(), note index == "%object%.%index%"
        $rrd_file = $processor['processor_type'] . "-" . $index;
    }

    if ($full) {
        // Prepend processor
        return 'processor-' . $rrd_file . '.rrd';
    }
    return $rrd_file;
}

// EOF