#!/usr/bin/perl
# vim: set ai noet ts=4 sw=4 sts=4 ft=perl :

# TODO: check for file descriptor leak for used fd munching technique

use strict;
use warnings "all";

use Fcntl qw(:seek);
use Net::DBus;
use 5.10.0;
use utf8;

binmode STDOUT;
binmode STDERR;

sub gettimestr();
sub getlastr();
sub getbatterychargestr3();
sub to_hours($);
sub meminfo();
sub ifaces();
sub cpuspeed();
sub cputemp();
sub caps();
sub caps_find();

my $slow_timer = 360; # 0.333 * 360 ~= 2 min
my $onesec_timer = 3; # 0.333 * 3   ~= 1 sec

my @months = ('Янв', 'Фев', 'Мар', 'Апр', 'Май', 'Июн', 'Июл', 'Авг', 'Сен', 'Окт', 'Ноя', 'Дек');
my @wdays = ('Вс', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб');

my $pstr = '';

my $charge;
my $la;
my $time;
my $mem;
my $net;
my $cpuspeed;
my $cputemp;

# prep dee-boos connection
my $bus = Net::DBus->system;
my $upower = $bus->get_service("org.freedesktop.UPower");
my $properties = $upower->get_object("/org/freedesktop/UPower/devices/battery_BAT0", "org.freedesktop.DBus.Properties");

# find out caps lock indicator
my $CAPSPATH = &caps_find();

my $LAHANDLE;
my $MEMINFOHANDLE;
my $CPUTEMPHANDLE;
my %CPUSCALEHANDLE;
my %CPUSCALEMAXHANDLE;
my $ROUTEHANDLE;
my %IFSTATEHANDLE;
my $CAPSHANDLE;

my @IFACE = qw (wlan0);
my %IFSTATE;
my %IFPSTATE;
my %IFADDR;

# take a nap
sleep 1;

while (1) {
	if ($onesec_timer >= 3) {
#		$cpuspeed = cpuspeed();
		$cputemp = cputemp();
		$time = gettimestr();
		$mem = meminfo();
		$net = ifaces();
		$onesec_timer = 0;
	}

	if ($slow_timer >= 360) {
		$charge = getbatterychargestr3();
		$la = getlastr();
		$CAPSPATH = caps_find() unless (defined($CAPSPATH));
		$slow_timer = 0;
	}

#	my $str = $cpuspeed;
	my $str = caps();
	$str .= $net;
	$str .= $cputemp;
	$str .= $la;
	$str .= $mem;
	$str .= $charge;
	$str .= $time;
	utf8::encode($str);

	if ($pstr ne $str) {
		syswrite STDOUT, $str . "\n";
		$pstr = $str;
	}

# tick timers
	$slow_timer++;
	$onesec_timer++;

# sleep for 0.333 second;
	select(undef, undef, undef, 0.333);
}

sub gettimestr() {
	my ($sec, $min, $hour, $mday, $mon, $year, $wday) = (localtime)[0,1,2,3,4,5,6];
	$year = $year + 1900;

	return sprintf(" |     %s, %s %s %s  %02s:%02s  ", $wdays[$wday], $mday, $months[$mon], $year, $hour, $min);
}

sub getlastr() {
	if (defined($LAHANDLE)) {
		open $LAHANDLE, "/proc/loadavg" if (tell($LAHANDLE) == -1);
	} else {
		open $LAHANDLE, "/proc/loadavg";
	}

	my $str = readline($LAHANDLE);
	seek $LAHANDLE, SEEK_SET, 0;
	$str = (split(/ /, $str, 2))[0];

	return " | LA: $str";
}

sub getbatterychargestr3() {
	my $capacity = $properties->Get('org.freedesktop.UPower.Device', 'Percentage');
	my $state = $properties->Get('org.freedesktop.UPower.Device', 'State');
	my $time = "?";

	if ($state == 2) {
# discharging
		$time = $properties->Get('org.freedesktop.UPower.Device', 'TimeToEmpty');
		# time in seconds, let's translate it to hours:minutes
		$state = '▼';
	} elsif ($state == 1) {
# charging
		$time = $properties->Get('org.freedesktop.UPower.Device', 'TimeToFull');
		$state = '▲';
	} else {
# already charged
		$time = 0;
		$state = '•';
	}

	$time = to_hours ($time) unless ($time eq '?');

	return sprintf(" | ⚡ %s%% %s %s", $capacity, $state, $time);
}

sub to_hours ($) {
	my $sec = shift;

	my $hrs = $sec / (60 * 60);
	$hrs = 0 if ( $hrs < 1 );
	my $min = ($sec - ($hrs * 60 * 60)) / 60;
	$min = 0 if ( $min < 1 );

	return sprintf("%02d:%02d", $hrs, $min);
}

sub meminfo() {
	if (defined($MEMINFOHANDLE)) {
		open ($MEMINFOHANDLE, "/proc/meminfo") if (tell($MEMINFOHANDLE) == -1);
	} else {
		open ($MEMINFOHANDLE, "/proc/meminfo");
	}

	my @mem;

	while ( ! eof($MEMINFOHANDLE) ) {
		push @mem, readline($MEMINFOHANDLE);
	}

	seek $MEMINFOHANDLE, SEEK_SET, 0;
	@mem = map { substr($_, 0, -4) } @mem;
	my $memavail = (split(/\s+/, $mem[2]))[1];
	my $swaptotal = (split(/\s+/, $mem[14]))[1];
	my $swapfree = (split(/\s+/, $mem[15]))[1];

	return sprintf (
		" | mem/sw: %s/%s M",
		int($memavail / 1024),
		int(($swaptotal - $swapfree) / 1024)
	);
}

sub ifaces() {
	my $str = '';

	foreach my $if (@IFACE) {
		my $addr = "no addr";
		my $link;

		if (defined($IFSTATEHANDLE{$if})) {
			if (tell($IFSTATEHANDLE{$if}) == -1) {
				unless (open ($IFSTATEHANDLE{$if}, "/sys/class/net/$if/operstate")) {
					$str .= " | ? $if: not exist";
					next;
				}
			}
		} else {
			open ($IFSTATEHANDLE{$if}, "/sys/class/net/$if/operstate") or do {
				$str .= " | ? $if: not exist";
				next;
			};
		}

		$IFSTATE{$if} = readline($IFSTATEHANDLE{$if});
		seek $IFSTATEHANDLE{$if}, SEEK_SET, 0;
		$IFPSTATE{$if} = $IFSTATE{$if} unless(defined($IFPSTATE{$if}));

		if ($IFSTATE{$if} eq "up\n") {
			$link = '▲';
		} else {
			$link = '▼';
		}

		if ($IFPSTATE{$if} ne $IFSTATE{$if}) {
			$IFADDR{$if} = undef;
			$IFPSTATE{$if} = $IFSTATE{$if}
		}

		unless (defined($IFADDR{$if})) {
			if (defined($ROUTEHANDLE)) {
				open ($ROUTEHANDLE, "/proc/self/net/route") if (tell($ROUTEHANDLE) == -1);
			} else {
				open ($ROUTEHANDLE, "/proc/self/net/route");
			}

			my @route;

			while ( ! eof($ROUTEHANDLE)) {
				push @route, readline($ROUTEHANDLE);
			}

			seek $ROUTEHANDLE, SEEK_SET, 0;

			foreach my $r (@route) {
				if ((split(/\t/, $r, 2))[0] eq $if) {
					$addr = (split(/\n/, `/sbin/ip address show dev $if`))[2];
					$addr =~ m/    inet (.+)\//;
					$IFADDR{$if} = $1;

					last;
				}
			}
		}

		unless (defined($IFADDR{$if})) {
			$str .= sprintf(" | %s %s: %s", $link, $if, $addr);
		} else {
			$str .= sprintf(" | %s %s: %s", $link, $if, $IFADDR{$if});
		}
	}

	return $str;
}

sub cpuspeed() {
	my $str = 'cpu:';

	opendir(C, "/sys/devices/system/cpu/cpufreq") or do {
		return '';
	};

	while (readdir(C)) {
		next if($_ eq '.');
		next if($_ eq '..');

		if (defined($CPUSCALEHANDLE{$_})) {
			if (tell($CPUSCALEHANDLE{$_}) == -1) {
				unless (open ($CPUSCALEHANDLE{$_}, "/sys/devices/system/cpu/cpufreq/$_/scaling_cur_freq")) {
					return '';
				}
			}
		} else {
			open ($CPUSCALEHANDLE{$_}, "/sys/devices/system/cpu/cpufreq/$_/scaling_cur_freq") or do {
				return '';
			};
		}

		my $speed = readline($CPUSCALEHANDLE{$_});
		seek $CPUSCALEHANDLE{$_}, SEEK_SET, 0;
		chomp $speed;
		$speed = int($speed / 1000);

		if (defined($CPUSCALEMAXHANDLE{$_})) {
			if (tell($CPUSCALEMAXHANDLE{$_}) == -1) {
				unless (open ($CPUSCALEMAXHANDLE{$_}, "/sys/devices/system/cpu/cpufreq/$_/scaling_max_freq")) {
					return '';
				}
			}
		} else {
			open ($CPUSCALEMAXHANDLE{$_}, "/sys/devices/system/cpu/cpufreq/$_/scaling_max_freq") or do {
				return '';
			};
		}

		my $speedmax = readline($CPUSCALEMAXHANDLE{$_});
		seek $CPUSCALEHANDLE{$_}, SEEK_SET, 0;
		chomp $speedmax;
		$speedmax = int($speedmax / 1000);
		$str .= sprintf(" %s/%s", $speed, $speedmax);
	}

	closedir C;

	return $str . " MHz";
}

sub cputemp() {
	if (defined($CPUTEMPHANDLE)) {
		if (tell($CPUTEMPHANDLE) == -1) {
			unless (open ($CPUTEMPHANDLE, "/sys/class/hwmon/hwmon0/temp1_input")) {
				return '';
			}
		}
	} else {
		open ($CPUTEMPHANDLE, "/sys/class/hwmon/hwmon0/temp1_input") or do {
			return '';
		};
	}

	my $t = readline($CPUTEMPHANDLE);
	seek $CPUTEMPHANDLE, SEEK_SET, 0;
	chomp $t;
	$t = int($t);
	$t = int($t / 1000) if ($t > 1000);

	return sprintf(" | %s°", $t);
}

sub caps() {
	if (defined($CAPSPATH)) {
		if (defined($CAPSHANDLE)) {
			if (tell($CAPSHANDLE) == -1) {
				unless (open($CAPSHANDLE, $CAPSPATH)) {
					$CAPSPATH = undef;
					return "? caps";
				}
			}
		} else {
			open($CAPSHANDLE, $CAPSPATH) or do {
				$CAPSPATH = undef;
				return "? caps";
			};
		}

		my $state = readline($CAPSHANDLE);
		seek $CAPSHANDLE, SEEK_SET, 0;
		chomp $state;

		if ($state eq '1') {
			return '☒ caps';
		} else {
			return '☐ caps';
		}
	}
}

sub caps_find() {
	my $str;
	opendir (C, "/sys/class/input");
	my $cnt = 0;

	while (readdir(C)) {
		if (-f sprintf("/sys/class/input/%s/input0::capslock/brightness", $_)) {
			$str = sprintf("/sys/class/input/%s/input0::capslock/brightness", $_);
			last;
		}

		if (-f sprintf("/sys/class/input/%s/input%s::capslock/brightness", $_, $cnt)) {
			$str = sprintf("/sys/class/input/%s/input%s::capslock/brightness", $_, $cnt);
			last;
		}

		$cnt++;
	}

	closedir C;

	return $str;
}