#!/usr/bin/perl

# we need to disable hash shuffling in order to make as less prints to stdout as possible
BEGIN {
	unless (defined $ENV{PERL_PERTURB_KEYS}) {
		$ENV{PERL_PERTURB_KEYS} = 0;
		exec ( $^X, $0, @ARGV );
		exit 0; # we actually never get here
	}
}

use 5.018;
use strict;
use warnings;
use utf8;
use open qw (:std :utf8);
use Fcntl qw (:seek);
use AnyEvent;
use AnyEvent::I3;
use JSON::XS;
use Net::DBus;
use Encode;
use IO::Socket qw (AF_INET SOCK_STREAM SHUT_WR);

sub add_events ();
sub spawn (@);
sub find_caps_led ();
sub to_hours ($);
sub readconf ();
sub active_win_borders ();

my $CONF = readconf ();
my $i3 = i3 ();
my $done = AnyEvent->condvar;
$i3->connect->recv or die 'Unable to connect to i3';

# event pool
my @EP;

# reload config and re-apply it on SIGHUP
$SIG{HUP} = sub {
	$CONF = readconf ();
	active_win_borders ();
	$#EP = -1;
	add_events ();
};

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

# File handler pool
my $LAHANDLE;
my $MEMINFOHANDLE;
my $CPUTEMPHANDLE;
my $CAPSHANDLE;

# everything for text labels on i3bar
my $wallclock = '';
my $la = '';
my $meminfo = '';
my $cputemp = '';
my $caps_state = '';
my $charge = '';
my $tcp_check = 0;
my $file_check = 0;
my $file_check_mtime = 0;
my $output_string;
my $old_output_string = '';
my $STDIN_FIRST_LINE_DROPPED = 0;

my $CAPS_LED_PATH = find_caps_led ();

# for fetching battery stats via dee-boos :)
my $properties;

# opened windows info storage ref
my $win;

# capture click events and do not override sigstop and sigcont numbers
syswrite STDOUT, << 'EOJSON';
{"version": 1, "click_events": true}
[ [], 
EOJSON

# i3 events should persist over config relads
my $i3_subscription->{window} = sub {
	my $w = shift;

	if (defined $w->{change}) {
		if ($w->{change} eq 'new' ) {
			if (defined $w->{container}->{window_properties}->{instance}) {
				if (defined $win->{instance}->{$w->{container}->{window_properties}->{instance}}) {
					$win->{instance}->{$w->{container}->{window_properties}->{instance}}++;
				} else {
					$win->{instance}->{$w->{container}->{window_properties}->{instance}} = 1;
				}
			}
		} elsif ($w->{change} eq 'close') {
			if (defined $w->{container}->{window_properties}->{instance}) {
				if (defined $win->{instance}->{$w->{container}->{window_properties}->{instance}}) {
					if ($win->{instance}->{$w->{container}->{window_properties}->{instance}} > 1) {
						$win->{instance}->{$w->{container}->{window_properties}->{instance}} --;
					} else {
						delete $win->{instance}->{$w->{container}->{window_properties}->{instance}};
					}
				}
			}
		}

		active_win_borders ();
	}
};

$i3_subscription->{_error} = sub {
	my ($msg) = @_;
	die "Connection to i3 closed: $msg";
};

$i3->subscribe($i3_subscription)->recv->{success} || die 'Unable to subscribe to i3 events';

# now we can add other events
add_events ();

# and start eventloop
$done->recv ();
exit 0;


sub add_events () {
	# prep dee-boos connection
	if ($CONF->{battery}) {
		unless (defined $properties) {
			# we should not install more than one connection to dbus,
			# but we can not break connection gracefully (via Net::DBus) once we make one
			my $bus = Net::DBus->system;
			my $upower = $bus->get_service ('org.freedesktop.UPower');
			$properties = $upower->get_object ('/org/freedesktop/UPower/devices/battery_BAT0', 'org.freedesktop.DBus.Properties');
		}
	}

	# Register callbacks/event handlers

	# Actually print messages there
	push @EP, AnyEvent->timer (
		after    => 1,    # sleep 1 second
		interval => 0.3,  # then invoke every 1 second
		cb       => sub { # the callback to invoke
			my $OUTPUT;

			if ($CONF->{app_buttons}) {
				@{$OUTPUT} = @{$CONF->{apps}};
			}

			if ($CONF->{capslock}) {
				unless ($caps_state) {
					push @{$OUTPUT}, { color => '#3e78fd', background => '#edeceb', border => '#edeceb', full_text => 'caps', markup => 'pango'};
				} else {
					push @{$OUTPUT}, { background => '#3e78fd', color => '#edeceb', border => '#edeceb', full_text => 'caps', markup => 'pango'};
				}
			}

			if ($CONF->{cpu_temp}) {
				push @{$OUTPUT}, { color => '#3e78fd', full_text => $cputemp };
			}

			if ($CONF->{mem}) {
				push @{$OUTPUT}, { color => '#3e78fd', full_text => $meminfo };
			}

			if ($CONF->{la}) {
				push @{$OUTPUT}, { color => '#3e78fd', full_text => "LA: $la" };
			}

			my $vpn_str = 'VPN:';

			if ($CONF->{vpn}->{enabled}) {
				if ($file_check) {
					$vpn_str .= '⍋';
				} else {
					$vpn_str .= '⍒';
				}
			}

			if ($CONF->{vpn}->{tcp_check}->{enabled}) {
				if ($CONF->{vpn}->{enabled}) {
					$vpn_str .= ':';
				}

				if ($tcp_check) {
					$vpn_str .= '✔';
				} else {
					$vpn_str .= '✘';
				}
			}

			if ($CONF->{vpn}->{tcp_check}->{enabled} || $CONF->{vpn}->{enabled}) {
				push @{$OUTPUT}, { color => '#3e78fd', full_text => $vpn_str };
			}

			if ($CONF->{battery}) {
				push @{$OUTPUT}, { color => '#3e78fd', full_text => $charge };
			}

			if ($CONF->{clock}) {
				push @{$OUTPUT}, { color => '#000000', full_text => "<big>$wallclock</big>", markup => 'pango'};
			}

			$output_string = eval { encode_json ($OUTPUT) };

			if (defined $output_string) {
				if ($output_string ne $old_output_string) {
					syswrite STDOUT, decode ('UTF-8', $output_string) . ",\n";
					$old_output_string = $output_string;
				}
			} else {
				warn $@;
			}

			@{$OUTPUT} = -1;
		}
	);


	# read STDIN
	push @EP, AnyEvent->io (
		fh   => \*STDIN,
		poll => 'r',
		cb   => sub {
			my $msg = <>;

			unless ($STDIN_FIRST_LINE_DROPPED) {
				$msg = <>;
				$STDIN_FIRST_LINE_DROPPED = 1;
			}

			if ($msg) {
				# drop leading ',' if present
				if (substr ($msg, 0, 1) eq ',') {
					$msg = substr $msg, 1;
				}

				my $j = eval { decode_json ($msg) };

				if (defined $j) {
					foreach (@{$CONF->{apps}}) {
						unless (defined $_->{name}) {
							next;
						}

						unless (defined $j->{name}) {
							next;
						}

						if ($j->{name} eq $_->{name}) {
							spawn ($_->{cmd});
							last;
						}
					}
				}
			}
		}
	);

	# poll caps lock status, on one of my laptop there is no led for this :(
	if ($CONF->{capslock}) {
		push @EP, AnyEvent->timer (
			after    => 0,    # first invoke ASAP
			interval => 0.3,  # then invoke every 0.3 seconds
			cb       => sub { # the callback to invoke
				if (defined $CAPS_LED_PATH) {
					if (defined $CAPSHANDLE) {
						if (tell ($CAPSHANDLE) == -1) {
							unless (open $CAPSHANDLE, '<', $CAPS_LED_PATH) {
								$CAPS_LED_PATH = undef;
								$caps_state = 2;
							}
						}
					} else {
						unless (open $CAPSHANDLE, '<', $CAPS_LED_PATH) {
							$CAPS_LED_PATH = undef;
							$caps_state = 2
						}
					}
				} else {
					$caps_state = 2;
				}

				if ($caps_state ne '2') {
					$caps_state = eval { readline ($CAPSHANDLE) };
					seek $CAPSHANDLE, SEEK_SET, 0;
					chomp $caps_state;
				}
			}
		);
	}

	# poll clock by timer
	if ($CONF->{clock}) {
		push @EP, AnyEvent->timer (
			after    => 0,    # first invoke ASAP
			interval => 1,    # then invoke every 1 second
			cb       => sub { # the callback to invoke
				# Fetch time for clock
				my ($sec, $min, $hour, $mday, $mon, $year, $wday) = (localtime)[0,1,2,3,4,5,6];
				$year = $year + 1900;
				$wallclock = sprintf '     %s, %s %s %s  %02s:%02s  ', $week_day[$wday], $mday, $month[$mon], $year, $hour, $min;
			}
		);
	}

	# poll battery status via dbus
	# but it is possible to fetch this status via upower directly
	if ($CONF->{battery}) {
		push @EP, AnyEvent->timer (
			after    => 0,    # first invoke ASAP
			interval => 10,   # then invoke every 10 seconds
			cb       => sub { # the callback to invoke
				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 = '•';
				}

				if ($time ne '?') {
					$time = to_hours ($time);
				}

				$charge = sprintf '⚡ %s%% %s %s', $capacity, $state, $time;
			}
		);
	}

	# put all fast accessable stats in one callback
	push @EP, AnyEvent->timer (
		after    => 0,    # first invoke ASAP
		interval => 3,    # then invoke every 3 second
		cb       => sub { # the callback to invoke

			# Fetch Load Average
			if ($CONF->{la}) {
				if (defined $LAHANDLE) {
					if (tell ($LAHANDLE) == -1) {
						open $LAHANDLE, '<', '/proc/loadavg';
					}
				} else {
					open $LAHANDLE, '<', '/proc/loadavg';
				}

				$la = readline $LAHANDLE;
				seek $LAHANDLE, SEEK_SET, 0;
				$la = (split / /ms, $la, 2)[0];
			}

			# populate memory statistics
			if ($CONF->{mem}) {
				if (defined $MEMINFOHANDLE) {
					if (tell ($MEMINFOHANDLE) == -1) {
						open $MEMINFOHANDLE, '<', '/proc/meminfo';
					}
				} 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 $memtotal = (split /\s+/xms, $mem[0])[1];
				my $memavail  = (split /\s+/xms, $mem[2])[1];
				my $swaptotal = (split /\s+/xms, $mem[14])[1];
				my $swapfree  = (split /\s+/xms, $mem[15])[1];
				my $shmem = (split /\s+/xms, $mem[20])[1];
				my $memused = int (($memtotal - $memavail) / ($memtotal / 100));

				$meminfo = sprintf (
					'M:%d%% SHM:%dM SW:%dM',
					$memused,
					int ($shmem / 1024),
					int (($swaptotal - $swapfree) / 1024)
				);
			}

			# populate cpu temperature info
			if ($CONF->{cpu_temp}) {
				my $hwmon = 1;

				if (defined $CPUTEMPHANDLE) {
					if (tell $CPUTEMPHANDLE == -1) {
						if (open $CPUTEMPHANDLE, '<', '/sys/class/hwmon/hwmon0/temp1_input') {
							$hwmon = 1;
						} else {
							$hwmon = 0;
						}
					}
				} else {
					unless (open $CPUTEMPHANDLE, '<', '/sys/class/hwmon/hwmon0/temp1_input') {
						$hwmon = 0;
					};
				}

				if ($hwmon) {
					$cputemp = readline $CPUTEMPHANDLE;
					seek $CPUTEMPHANDLE, SEEK_SET, 0;
					chomp $cputemp;
					$cputemp = int $cputemp;

					if ($cputemp > 1000) {
						$cputemp = int ($cputemp / 1000);
					}

					$cputemp = sprintf '%s°', $cputemp;
				}
			}
		},
	);

	# Try to tcp connect to server
	if ($CONF->{vpn}->{tcp_check}->{enabled}) {
		push @EP, AnyEvent->timer (
			after    => 0,    # first invoke ASAP
			interval => 5,    # then invoke every 5 seconds
			cb       => sub { # the callback to invoke
				if (
					my $sock = IO::Socket->new (
						Domain   => AF_INET,
						proto    => 'tcp',
						PeerHost => $CONF->{vpn}->{tcp_check}->{host},
						PeerPort => $CONF->{vpn}->{tcp_check}->{port},
						Type     => SOCK_STREAM,
						Timeout  => $CONF->{vpn}->{tcp_check}->{timeout}
					)
				) {
					$sock->shutdown (SHUT_WR);
					$sock->close ();
					$tcp_check = 1;
				} else {
					$tcp_check = 0;
				}
			}
		);
	}

	# check file mtime
	if ($CONF->{vpn}->{enabled}) {
		push @EP, AnyEvent->timer (
			after    => 0,    # first invoke ASAP
			interval => 3,    # then invoke every 3 seconds
			cb       => sub { # the callback to invoke
				my $mtime = (stat $CONF->{vpn}->{statusfile}) [8];

				if (defined $mtime) {
					if (($mtime - $file_check_mtime) < $CONF->{vpn}->{mtime_threshold}) {
						$file_check = 1;
					} else {
						$file_check = 0;
					}

					$file_check_mtime = $mtime;
				} else {
					$mtime = 0;
					$file_check = 0;
				}
			}
		);
	}
}

sub spawn (@) {
	my @args = @_;
	my  $pid = fork ();

	if ($pid) {
		# Parent, work done, return
		return;
	} elsif ($pid == 0) {
		# it seems that at least vscode creashes if we close stdio handles
		open STDOUT, '>', '/dev/null';
		open STDERR, '>', '/dev/null';
		open STDIN,  '<', '/dev/null';
		$pid = fork ();

		if ($pid) { # Parent
			# in this place parent quits
			exit 0;
		} elsif ($pid == 0) { # Child
			my $prg = shift @args;
			# weird situation, silently quit here :)
			exit 0 unless (defined $prg);

			if (@args > 0) {
				exec $prg, @args;
			} else {
				exec $prg;
			}
		} else { # Unable to fork()
			syswrite STDERR, "[{\"full_text\":\"ERROR: Could not fork new process: $!\",\"color\":\"#ff0000\"}],\n";
		}
	}

	return;
}

sub find_caps_led () {
	my $str;
	opendir my $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;
}

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

	my $hrs = int ($sec / (60 * 60));
	my $min = int (($sec - ($hrs * 60 * 60)) / 60);

	return sprintf '%02d:%02d', $hrs, $min;
}

sub readconf () {
	my $file = "$ENV{HOME}/.i3/config.json";
	my $FH;

	unless (open $FH, '<', $file) {
		die "Unable to open $file: $!\n";
	}

	my $len = (stat $file)[7];
	my $data;
	use bytes;
	my $readlen = read $FH, $data, $len;
	no bytes;
	close $FH;

	unless (defined $readlen) {
		die "Unable to read $file: $!\n";
	}

	if ($readlen != $len) {
		die "Unable to read $file: read $readlen, but stat() reports that file is $len bytes\n";
	}

	my $config = eval { JSON::XS->new->utf8->relaxed->decode ($data) };

	unless ($config) {
		die "Unable to decode $file: $@\n";
	}

	return $config;
}

sub active_win_borders () {
	foreach my $app (@{$CONF->{apps}}) {
		unless (defined $app->{border_inactive}) {
			$app->{border_inactive} = $app->{border};
		}

		unless (defined $app->{border_active}) {
			$app->{border_active} = $app->{border};
		}

		if (defined ($app->{instance}) && defined ($win->{instance}->{$app->{instance}})) {
			$app->{border} = $app->{border_active};
		} else {
			$app->{border} = $app->{border_inactive};
		}
	}
}