#!/usr/bin/perl -w 


my ($licensekey);
$licensekey='gulfie';


#
#
# 	a rewrite of a little tool I once knew of.
#
#

$comments = $comments =  "

	Take a command or field, and give us LIFE!
	
	er' , find the numbers in it and subtract them from there previous values, maybe divide by time.	

"; 


#
# because time should always be good. 128 bits would be better. 
#
use Time::HiRes qw(time sleep);
use Data::Dumper; 

my $cmd = 'ifconfig -a'; 
my $pollfile = undef;
my $do_dt  = 0; 
my $looptime = 5; 
my $sleeptime = $looptime;
my $avg_loop_dt = $looptime;
my $flatfileify = 0; 





my $version = "
Mon Aug 14 01:58:55 PDT 2006
"; 

$name = $0; 

my $debug = 0;
my $usagemsg; 
$usagemsg = <<EOUM
$name : usage

	$name is a something.
	

$name   arguments 
	--help|-h|-? 		this
	--faq|--FAQ		The frequently asked questions.
	--tutorial|-t		The tutorial. it's neat
	--license|-l\
		--legal		license and legal information
	--vesion|-V		version information
	--debug|-d 		toggle debugging mode on or off (default $debug)	


	--bugreport		report a bug (may send email on your behalf)

	--cmd 'CMD'		A command to run to generate a buffer to work on. 
	--    CMD 		After the -- everything is concidered part of the command.
	--file			In steed of running a command, read a file.  it has much less overhead than '--cmd cat /proc/meminfo' or the like.
	--dt 			divide by time, as well as subtract	
	--looptime SECONDS	The targeted number of seconds between each call to cmd.
	--hz	HZ		Polls / second, or 1/looptime.
	--flatfile		Dump out the resulting values as a ',' seperated flat file. 
	

EOUM
;





sub usage {
	my($str) = @_;
	
	if (defined $str){
		print STDERR "$0 : usage error : ($str)\n";
	}

	
	print $usagemsg;

	exit(1); 
} 


#
# 	reading up the argumets.
#
sub args{
	my(@args) = @_; 
	my ($arg);
	my ($confarg) = ''; 
	
	# 
	# masticate the arugments, 
	# 

	while (defined ($arg  = shift @args)){
		if ($arg =~ /\A(--help|-h|-\?)\Z/){
			usage(); 
		}elsif($arg =~ /\A(--faq|--FAQ)\Z/){
			FAQ(); 
		}elsif($arg =~ /\A(--tutorial|-t)\Z/){
			tutorial(); 
		}elsif($arg =~ /\A(--license|-l|--legal)\Z/){
			license(); 
		}elsif($arg =~ /\A(--Version|-V)\Z/){
			$version =~ /(\A\s*\n|\s*\n\s*\Z)/g;
			print "Version : $version\n"; 
		}elsif($arg =~ /\A(--debug|-d)\Z/){
			$debug = not $debug;

		}elsif($arg =~ /\A(--cmd)\Z/){
			$cmd = shift @args;
		}elsif($arg =~ /\A(--file)\Z/){
			$pollfile = shift @args;
		}elsif($arg =~ /\A--\Z/){
			$cmd = join " " , @args; 
			@args = ();
		}elsif($arg =~ /\A--dt\Z/){
			$do_dt = 1; 
		}elsif($arg =~ /\A--looptime\Z/){
			$looptime = shift @args; 	# fix, range checking
		}elsif($arg =~ /\A--hz\Z/){
			my ($hz) = shift @args;
			if ($hz and numeric($hz)){
				$looptime = 1/$hz;
			}else{
				usage( "--hz should be followed by a number");
			}
		}elsif($arg =~ /\A--flatfile\Z/){
			$flatfileify = 1;
		}else{
			usage("Misunderstood argument ($arg)\n");
		}
	}
	
	$sleeptime = $looptime;
	$avg_loop_dt = $looptime;
}



#
#	is the argumetn numeric?
#
sub numeric{
	my ($txt) =@_;

	$ret = $txt =~ /\A\s*(-|\+)?(\d+|\.\d+)/; 

	$ret;
}

sub FAQ{ die "ui"; }


# the tutorial. 
sub tutorial {

print <<EOTUT; 

	starter tutorial:  ($version)

INTRO: 

	run

	'deltizer'   

	it'll kinda work out. 

TOC:
	Z' big picture.

	

BODY:
	
	Z' big picture.



EOTUT
	exit(0); 
}


sub catch_hup{
	#rbatch_quit(); 	# gets us there a kinda slow way. 
}


# quick timeing question. 
my $tincure_old ;
$tincure_old = time(); 
sub tincure{
	my ($str) = @_;  
	my ($begin,$end,$deltat); 
	$begin = $tincure_old;
	$end = time(); 
	$deltat = $end - $begin;
	print "The timem for ($str) is $deltat\n";
	$tincure_old = $end;
}


my ($MACBYTE,$MAC,$IP);


sub main_loop{
	my ($begin,$end,$dt,$td); 

	$begin = $end = time(); 
	$begin --; 

	my ($firsttime) = 1;

	my %lastval = (); 

# prework up some regular expressions.
	$MACBYTE = '[0-9a-fA-F]{1,2}';
	$MAC = "$MACBYTE((:|-)$MACBYTE){5}";
	$IP = '\d+(\.\d+){3}'; #kind wrong.. 

	sub isignore{
		my ($value) = @_;
	#	print "isignore ($value)\n";
		$value =~ /($IP)|($MAC)/;
	}

	my $last_good_buffer_t; 
	my $last_time = $end;

	while(1){
		my $buf;

		if(defined $pollfile and $pollfile){
			{
				local $/;
				if (open INFILE, "<$pollfile" ){
					$buf = <INFILE>; 
					close INFILE; 
				}else{
					print STDERR "Unable to opnen file ($pollfile)  ($!)  this may be an error, maybe not.\n";
				}	
			}
		}elsif(defined $cmd and $cmd){
			$buf = `$cmd`;
		}


		$end = time(); 

		if (defined $last_good_buffer_t and $last_good_buffer_t != $begin){
			$dt = $end - $last_good_buffer_t;  # only do DT on good buffers. 		
		}else{
			$dt = $end - $begin; 	# though we may end up not using it.
		}

		$begin = $end;

		if ($dt and $do_dt ){
			$td = 1 / $dt;
		}


		my $newbuf = $buf;
		my $cnt = 2; 
		

		if (defined $buf and not $buf =~ /\A\s*\Z/ms){
			$last_good_buffer_t = $end;

			#$newbuf =~ s/(^|(?<=(:|\s|\()))((-|\+)?(\d+(\.\d+)?))(?>(\s|\)|\.(\s)|\n|\Z))/
			$newbuf =~ s/(^|(?<=(:|\s|\()))(($IP)|($MAC)|((-|\+)?((\d+(\.\d+)?))))/{
					my $value = $3; 
					

					if (isignore($value)){
						# ignore it most definitely
					  #	print "what?! ($value)\n";
						$value;  # don't muck with it. 
					}else{

						# print "value a ($value)\n";

						$cnt++; 

						$debug and print "value ($value)\n"; 							

						if (defined $lastval{$cnt}){
							my $tmp; 
							$tmp = $value - $lastval{$cnt}; 
							$lastval{$cnt} = $value;
							$value = $tmp; 
							if ($do_dt){
								if ($dt){
									$value = $td * $value;
								}else{
									$value = 'nan'; 
								}
							}
						}else{
							$lastval{$cnt} = $value;	
						}

						$debug and print "resulting value ($value)\n";
						$newvalue{$cnt} = $value;

						$value;
					}
				}/msge; 

			if ($firsttime){
				$firsttime =0;
				if ($flatfileify){	# print out the header 
					my $header = "date  " . `date`; 
					$header .= "cmd  ". join " " , @ARGV; 
					
					$header .= "\n\nExample bufer ($buf)\n";
					$header .= "\n\nledgend   : note the values are not molested in the ledgend\n\n";

					$header .= "1   :   time at the end\n";
					$header .= "2   :   dt\n";
					$header .= join "" , map { 
						"$_   :   $lastval{$_}\n";
						} sort {$a<=>$b} keys %lastval; 

					$header =~ s/^/#  /msg; 
					print "$header\n\n";
				}
			}else{
				if ($flatfileify){
					print "$end , $dt , " , (join " , " , map { $newvalue{$_} }  sort {$a <=> $b}    keys %newvalue ) , "\n"; 
					
				}else{
					print $newbuf;
				}
			}

		} # we had a buffer so we did stuf with it. 

		# end has our new timestamp. 
		$loop_dt = $end - $last_time;
		$avg_loop_dt = $looptime;
		$avg_loop_dt = ($avg_loop_dt * 15 + $loop_dt)/16;

		$error =  $looptime - $avg_loop_dt; 
		
		$sleeptime = ($sleeptime * 15 + ( $looptime - $error )  ) / 16; 	
		

		$last_time = $end;	

		if ($debug){
			print "looptime ($looptime)  loop_dt = ($loop_dt)  error ($error)  sleeptime ($sleeptime)  avg_loop_dt ($avg_loop_dt)\n";
		}

		if ($sleeptime >= 0 ){
			sleep $sleeptime;
		}

	}
}


sub main{
	# but quit nicely. 
#	$SIG{HUP} = \&catch_hup; 
#	$SIG{INT} = \&catch_hup; 
#	$SIG{QUIT} = \&catch_hup; 
#	$SIG{TERM} = \&catch_hup; 

#	print "\n" x 80 ; 

	args(@ARGV); 
#	$now = time(); 
#	print "BEGINNNING RUN! ($now)\n\n\n"; 
	my ($bannerline); 
#	$bannerline = "*" x 120 . "\n"; 
#	print $bannerline x 30; 
	main_loop();
	
}


if (not defined $copyrightnotice){
	$copyrightnotice = "Copyright Gulfie\@grotto-group.com all rights resurved, unpublished work, trade secret \n\n";

}


# golem hates me. 
sub license { 
	print "
$copyrightnotice


";
	exit(1); 
}

main();