#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-features.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/hardware/cpu.h>
#include "cpu.h"

netsnmp_feature_child_of(hardware_cpu, libnetsnmpmibs);

netsnmp_feature_child_of(hardware_cpu_copy_stats, hardware_cpu);
netsnmp_feature_child_of(hardware_cpu_load, hardware_cpu);
netsnmp_feature_child_of(hardware_cpu_get_cache, hardware_cpu);
netsnmp_feature_child_of(hardware_cpu_get_byName, hardware_cpu);

static void _cpu_update_stats( unsigned int, void* );

static int _cpuAutoUpdate =  5;
static int _cpuHistoryLen;
int  cpu_num = 0;

static netsnmp_cpu_info *_cpu_head  = NULL;
static netsnmp_cpu_info *_cpu_tail  = NULL;
static netsnmp_cache    *_cpu_cache = NULL;

void init_cpu( void ) {
    oid nsCPU[] = { 1, 3, 6, 1, 4, 1, 8072, 1, 33 };
    /*
     * If we're sampling the CPU statistics automatically,
     *   then arrange for this to be triggered regularly,
     *   keeping sufficient samples to cover the last minute.
     * If the system-specific code has already initialised
     *   the list of CPU entries, then retrieve the first set
     *   of stats immediately.
     * Otherwise, wait until the regular sampling kicks in.
     *
     * If we're not sampling these statistics regularly,
     *   create a suitable cache handler instead.
     */
    if ( _cpuAutoUpdate ) {
         
        _cpuHistoryLen = 60/_cpuAutoUpdate;
        snmp_alarm_register( _cpuAutoUpdate, SA_REPEAT, _cpu_update_stats,
                             NULL );
        if ( _cpu_head )
            _cpu_update_stats( 0, NULL );
    } else
        _cpu_cache = netsnmp_cache_create( 5, netsnmp_cpu_arch_load, NULL,
                                              nsCPU, OID_LENGTH(nsCPU));
}

void shutdown_cpu( void ) {
    while ( _cpu_head ) {
        netsnmp_cpu_info *tmp = _cpu_head;
        _cpu_head = _cpu_head->next;
        SNMP_FREE(tmp->history);
        SNMP_FREE(tmp);
    }
    _cpu_tail = NULL;
}


netsnmp_cpu_info *netsnmp_cpu_get_first( void ) {
    return _cpu_head;
}
netsnmp_cpu_info *netsnmp_cpu_get_next( netsnmp_cpu_info *this_ptr ) {
    return ( this_ptr ? this_ptr->next : NULL );
}

    /*
     * Work with a list of CPU entries, indexed numerically
     */
netsnmp_cpu_info *netsnmp_cpu_get_byIdx(  int idx, int create ) {
    netsnmp_cpu_info *cpu, *cpu2;

        /*
         * Find the specified CPU entry
         */
    DEBUGMSGTL(("cpu", "cpu_get_byIdx %d ", idx));
    for ( cpu=_cpu_head; cpu; cpu=cpu->next ) {
        if ( cpu->idx == idx ) {
            DEBUGMSG(("cpu", "(found)\n"));
            return cpu;
        }
    }
    if (!create) {
        DEBUGMSG(("cpu", "(not found)\n"));
        return NULL;
    }

        /*
         * Create a new CPU entry, and insert it into the list....
         */
    cpu = SNMP_MALLOC_TYPEDEF( netsnmp_cpu_info );
    if (!cpu) {
        DEBUGMSG(("cpu", "(failed)\n"));
        return NULL;
    }
    DEBUGMSG(("cpu", "(created)\n"));
    cpu->idx = idx;
        /* ... either as the first (or only) entry....  */
    if ( !_cpu_head || _cpu_head->idx > idx ) {
        cpu->next = _cpu_head;
        _cpu_head = cpu;
        if (!_cpu_tail)
            _cpu_tail = cpu;
        return cpu;
    }
        /* ... or in the appropriate position  */
    for ( cpu2=_cpu_head; cpu2; cpu2=cpu2->next ) {
        if ( !cpu2->next || cpu2->next->idx > idx ) {
            cpu->next  = cpu2->next;
            cpu2->next = cpu;
            if (!cpu->next)
                _cpu_tail = cpu;
            return cpu;
        }
    }
    SNMP_FREE(cpu); /* just in case */
    return NULL;  /* Shouldn't happen! */
}

    /*
     * Work with a list of CPU entries, indexed by name
     */
#ifndef NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_GET_BYNAME
netsnmp_cpu_info *netsnmp_cpu_get_byName( char *name, int create ) {
    netsnmp_cpu_info *cpu;

        /*
         * Find the specified CPU entry
         */
    for ( cpu=_cpu_head; cpu; cpu=cpu->next ) {
        if ( !strcmp(cpu->name, name))
            return cpu;
    }
    if (!create)
        return NULL;

        /*
         * Create a new CPU entry, and append it to the list
         */
    cpu = SNMP_MALLOC_TYPEDEF( netsnmp_cpu_info );
    if (!cpu)
        return NULL;
    if (strlen(name) >= sizeof(cpu->name)) {
        free(cpu);
        snmp_log(LOG_ERR, "Name of CPU is too large: %s\n", name);
        return NULL;
    }

    strlcpy(cpu->name, name, sizeof(cpu));
    if ( _cpu_tail ) {
        cpu->idx = _cpu_tail->idx+1;
        _cpu_tail->next = cpu;
        _cpu_tail       = cpu;
    } else {
        cpu->idx = 0;
        _cpu_head = cpu;
        _cpu_tail = cpu;
    }
    return cpu;
}
#endif /* NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_GET_BYNAME */

#ifndef NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_GET_CACHE
netsnmp_cache *netsnmp_cpu_get_cache( void ) {
    return _cpu_cache;
}
#endif /* NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_GET_CACHE */

#ifndef NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_LOAD
int netsnmp_cpu_load( void ) {
        /*
         * If we're automatically updating the stats regularly,
         * then don't invoke the cache handling.
         */
    return ( _cpuAutoUpdate ? 1
                            : netsnmp_cache_check_and_reload( _cpu_cache ));
}
#endif /* NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_LOAD */

    /*
     * Call the system-specific load routine regularly,
     * keeping track of the relevant earlier results.
     */
static void
_cpu_update_stats( unsigned int reg, void* magic ) {
    netsnmp_cpu_info *cpu;
    int i;

    for ( cpu=_cpu_head; cpu; cpu=cpu->next ) {
        if ( !cpu->history ) {
            /*
             * First time through, we need to create buffers
             * for the historical stats
             */
            cpu->history  = (struct netsnmp_cpu_history *)calloc( _cpuHistoryLen, sizeof(struct netsnmp_cpu_history));
        } else {
            /*
             * Otherwise, rotate these values - in descending order
             *   with the earliest (relevant) statistics in entry 0.
             * This means that the code to calculate the rolling averages
             *   is independent of the number of historical samples saved.
             */
            for (i=0; i<_cpuHistoryLen-2; i++) {
                cpu->history[i] = cpu->history[i+1];
            }
            cpu->history[i].user_hist  = cpu->user_ticks;
            cpu->history[i].sys_hist   = cpu->sys_ticks;
            cpu->history[i].idle_hist  = cpu->idle_ticks;
            cpu->history[i].nice_hist  = cpu->nice_ticks;
            cpu->history[i].total_hist = cpu->total_ticks;

            cpu->history[i].ctx_hist   = cpu->nCtxSwitches;
            cpu->history[i].intr_hist  = cpu->nInterrupts;
            cpu->history[i].swpi_hist  = cpu->swapIn;
            cpu->history[i].swpo_hist  = cpu->swapOut;
            cpu->history[i].pagei_hist = cpu->pageIn;
            cpu->history[i].pageo_hist = cpu->pageOut;
        }
    }

    /*
     * Now call the system-specific load routine, to
     * retrieve the latest set of data.
     */
    netsnmp_cpu_arch_load( NULL, NULL );
    for ( cpu=_cpu_head; cpu; cpu=cpu->next ) {
        cpu->total_ticks = cpu->user_ticks +
                           cpu->nice_ticks +
                           cpu->sys_ticks +
                           cpu->idle_ticks +
                           cpu->wait_ticks +
                           cpu->kern_ticks +
                           cpu->intrpt_ticks +
                           cpu->sirq_ticks +
                           cpu->steal_ticks +
                           cpu->guest_ticks +
                           cpu->guestnice_ticks;
    }
}

#ifndef NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_COPY_STATS
void _cpu_copy_stats( netsnmp_cpu_info *cpu )
{
    netsnmp_cpu_info *cpu2;

        /*
         * Copy "overall" statistics to the 'cpu0' entry
         *  on single CPU systems where this isn't done automatically
         */
    cpu2 = netsnmp_cpu_get_byIdx( 0, 1 );
    if (!cpu || !cpu2) return;
    cpu2->user_ticks = cpu->user_ticks;
    cpu2->nice_ticks = cpu->nice_ticks;
    cpu2->sys_ticks  = cpu->sys_ticks;
    cpu2->sys2_ticks = cpu->sys2_ticks;
    cpu2->idle_ticks = cpu->idle_ticks;
    cpu2->wait_ticks = cpu->wait_ticks;
    cpu2->kern_ticks = cpu->kern_ticks;
    cpu2->intrpt_ticks = cpu->intrpt_ticks;
    cpu2->sirq_ticks = cpu->sirq_ticks;
    cpu2->steal_ticks = cpu->steal_ticks;
    cpu2->guest_ticks = cpu->guest_ticks;
    cpu2->guestnice_ticks = cpu->guestnice_ticks;

    cpu2->nInterrupts  = cpu->nInterrupts;
    cpu2->nCtxSwitches = cpu->nCtxSwitches;
    cpu2->swapIn     = cpu->swapIn;
    cpu2->swapOut    = cpu->swapOut;
    cpu2->pageIn     = cpu->pageIn;
    cpu2->pageOut    = cpu->pageOut;
}
#endif /* NETSNMP_FEATURE_REMOVE_HARDWARE_CPU_COPY_STATS */