#!/usr/bin/perl

use strict;
use warnings;
use Data::Dumper;
use Carp;
use Parse::CSV;
use SNMP;

use SNMP::Query::AsynchMulti;

#---------------------------------------------------------

my $csv_file = shift || die "Please specify a CSV file with SNMP host info!";

my $max_inflight = shift || 50;
my $num_cycles   = shift || 1;
my $master_timeout = 0;    # Set to number of seconds before
                           # all queries are terminated.
                           # 0 means no master timeout.

my $batch_size = 50;       # Run a callback whenever this many
                           # results have been returned

my @varbinds = qw(
  ifDescr ifInOctets ifOutOctets ifAlias ifType
  ifName  ifInErrors ifOutErrors ifSpeed
  ifAdminStatus      ifOperStatus
);

my @reqired_fields = qw(HOSTIP COMMUNITY SNMPVER SNMPPORT);
my @hosts = read_hosts_csv( $csv_file, @reqired_fields );
@hosts = clean_hosts_data( \@hosts );

# This object encapsulates the desired queries to run.
my $query = SNMP::Query::AsynchMulti->new();

# This probably isn't necessary, but it's the Right Thing To Do.
my $varlist = SNMP::VarList->new( map { [$_] } @varbinds );

my $preop_callback = sub {
    warn "+ IF/CT/GT: "
      . $query->current_in_flight() . "/"
      . $query->total_this_run() . "/"
      . $query->grand_total() . "\n";
};

my $postop_callback = sub {
    warn "- IF/CT/GT: "
      . $query->current_in_flight() . "/"
      . $query->total_this_run() . "/"
      . $query->grand_total() . "\n";
};

foreach my $host (@hosts) {

    $query->add(
        {

            # Params concerning the SNMP Session
            DestHost   => $host->{HOSTIP},
            Community  => $host->{COMMUNITY},
            Version    => $host->{SNMPVER},
            RemotePort => $host->{SNMPPORT},

            #Timeout      => $host->{SNMP_TIMEOUT},
            #Retries      => $host->{SNMP_RETRIES},

            # Params concerning the type of query operation
            QueryType    => 'getbulk',    # See POD for explanation...
            MaxRepeaters => 20,           # Additional options depend on
            NonRepeaters => 0,            # the QueryType...

            # The varbinds to be operated on
            VarBinds => $varlist,

            # Callbacks before and after this query op.
            PreCallback  => $preop_callback,     # Do this before the op
            PostCallback => $postop_callback,    # Do this after the op
        }
    );

    warn "Added query to: $host->{HOSTIP}\n";
}

warn "Shuffling queries (not yet implemented)\n";
$query->shuffle();    # Randomize order of queries...(not yet implemented)

# Run all the added queries with up to $max_inflight
# asynchronous operations in-flight at any time.
# Lather, rinse, repeat for $num_cycles.
warn "Beginning polling cycle\n";

#use DDS;
#warn Dump $query; exit;

foreach my $iter ( 1 .. $num_cycles ) {
    sleep 30 unless $iter == 1;
    my $results = $query->execute(
        {
            InFlight      => $max_inflight,
            MasterTimeout => $master_timeout,

            # TODO Implement the batching functionality
            BatchSize => 50,    # Number of results that makes up a 'batch'
            BatchCallback => sub { 1 }
            ,    # Sub to call when a batch is done (or all results are in)
        }
    );
    print Dumper $results;
}

exit;

#---------------------------------------------------------

# Read in the CSV file.
sub read_hosts_csv {
    my $file            = shift;
    my @required_fields = @_;

    # Parse entries from a CSV file into hashes hash
    my $csv_parser = Parse::CSV->new(
        file   => $file,
        fields => 'auto',    # Use the first line as column headers,
                             # which become the hash keys.
    );

    my @node_cfg;            # Return a reference to this
    my $line_num = 0;
    while ( my $line = $csv_parser->fetch() ) {
        $line_num++;
        my $error_flag = 0;
        foreach my $field (@required_fields) {
            if ( !exists $line->{$field} ) {
                $error_flag = 1;
                carp
"Missing field [$field] on line [$line_num] in CSV file [$file]";
            }
        }
        croak
          "Terminating due to errors on line [$line_num] in CSV file [$file]"
          if $error_flag;

        push @node_cfg, $line;
    }

    if ( $csv_parser->errstr() ) {
        croak "Fatal error parsing [$file]: " . $csv_parser->errstr();
    }

    return @node_cfg;
}

sub clean_hosts_data {
    my $hosts_data = shift;
    my @clean_hosts;
    foreach my $host (@$hosts_data) {

        # Maybe put in a loop to scrub leading and trailing
        # whitespace from each field? Yeah, I know. map in
        # void context is the devil's work, yadda, yadda.
        map { s/^\s*|\s*$//g } values %$host;

        if (
            $host->{SNMPVER} == 2    #=~ /^1|2c?|3$/
            && $host->{SNMPPORT} =~ /^\d+$/
            && $host->{HOSTIP} =~
            /^(?:\d{1,3}\.){3}\d{1,3}$/    # Flawed, but Good Enough.
            && $host->{COMMUNITY}
          )
        {
            push @clean_hosts, $host;
        }
        else {
            warn "Invalid host data - skipping:\n" . "  "
              . Dumper($host) . "\n";
        }
    }
    return @clean_hosts;
}

1;
__END__