path: root/hue

#!/usr/bin/perl
use warnings;
use strict;
use utf8;
use POSIX;
use JSON;
use utf8;
use Digest::MD5		qw(md5_hex);
use Scalar::Util	qw(reftype);
use List::Util		qw(min max);
use LWP::UserAgent;
use Config::Simple;
use Data::Dumper;

# config
my $cfg = new Config::Simple( syntax => 'ini' );
$cfg->autosave(1);
$cfg->read($ENV{HOME} . "/.huerc");

# find all bridges
my @bridges = map { s/\.bridge//; $_ } grep(/\.bridge/, keys %{$cfg->vars()});
my $bridge;
$bridge = $bridges[0] if defined($bridges[0]);
$bridge = $ENV{HUE}   if defined($ENV{HUE});
$bridge = "default"   unless defined($bridge);

# move default bridge to head of list
@bridges = grep { $_ ne $bridge } @bridges;
unshift @bridges, $bridge;

my (%server,%user);
for my $i (@bridges) {
	$server{$i} = $cfg->param($i . '.bridge');
	$user{$i}   = $cfg->param($i . '.user');
}

# init
my ($sysname, $nodename, $release, $version, $machine) = POSIX::uname();
$nodename =~ m/([^.]+)/;
my $devid = sprintf("%s@%s", getlogin(), $1);
binmode STDOUT, ':utf8';

# global variables
my ($ua, $err);

##############################################################################
# colors and unicode chars

my %tt;
if (-t STDOUT) {
	$tt{'red'}    = "\x1b[31;1m";
	$tt{'green'}  = "\x1b[32;1m";
	$tt{'yellow'} = "\x1b[33;1m";
	$tt{'reset'}  = "\x1b[0m";
} else {
	$tt{'red'}    = "";
	$tt{'green'}  = "";
	$tt{'yellow'} = "";
	$tt{'reset'}  = "";
}

$tt{'yes'} = $tt{'green'}  . "\N{CHECK MARK}"          . $tt{'reset'};
$tt{'no'}  = $tt{'red'}    . "\N{BALLOT X}"            . $tt{'reset'};
$tt{'on'}  = $tt{'yellow'} . "\N{WHITE SUN WITH RAYS}" . $tt{'reset'};
$tt{'off'} = "-";

##############################################################################
# rest helpers

sub rest_request {
	my $req = shift;
	my ($res,$json);

	$res = $ua->request($req);
	unless ($res->is_success) {
		printf STDERR ">> %s %s\n", $req->method, $req->uri;
		printf STDERR "<< %s\n", $res->status_line;
		return undef;
	}
	$json = from_json($res->content);
#	if (reftype($json) eq 'ARRAY' &&
#	    defined($json->[0]->{'error'})) {
#		$err = $json->[0]->{'error'};
#		printf(STDERR "ERROR: #%d: %s\n",
#		       $err->{'type'}, $err->{'description'});
#		return undef;
#	}
	return $json;
}

sub rest_post {
	my $br = shift;
	my $path = shift;
	my $post = shift;
	my ($url,$body,$req);

	$url = "http://$server{$bridge}${path}";
	$req = HTTP::Request->new(POST => $url);
	$body = to_json($post);
	$req->content($body);
	return rest_request($req);
}

sub create_command {
	my $br = shift;
	my $cmd = {};
	$cmd->{"method"}  = shift;
	$cmd->{"address"} = "/api/$user{$br}" . shift;
	$cmd->{"body"}    = shift;
	return $cmd;
}

sub execute_command {
	my $br = shift;
	my $cmd = shift;
	my ($url, $req, $body);

	$url = "http://$server{$br}" . $cmd->{"address"};
	$req = HTTP::Request->new($cmd->{"method"}, $url);
	$body = to_json($cmd->{"body"});
	$req->content($body);
	return rest_request($req);
}

sub run_command {
	my $br = shift;
	my $cmd = create_command($br, @_);
	return execute_command($br, $cmd);
}

sub schedule_command {
	my $body = {};
	$body->{'time'} = shift;
	$body->{'command'} = shift;
	my $rc = run_command($bridge, "POST", "/schedules", $body);
	die unless defined($rc);
	return $rc;
}

sub manual_request {
	my $method = shift;
	my $address = shift;
	my $body = shift;

	my $url = "http://$server{$bridge}/api/$user{$bridge}$address";
	my $req = HTTP::Request->new($method, $url);
	$req->content($body);
	my $res = $ua->request($req);
	unless ($res->is_success) {
		printf STDERR ">> %s %s\n", $req->method, $req->uri;
		printf STDERR "<< %s\n", $res->status_line;
	}
	print $res->content . "\n";
}

##############################################################################
# rgb helpers

my $x11colors = {};

sub rgb_to_hsv {
	my ($r, $g, $b) = @_;
	my ($h, $s, $v);

	my $a = max $r,$g, $b;
	my $i = min $r,$g, $b;

	# hue
	if ($a == $i) {
		$h = 0;
	} elsif ($a == $r) {
		$h = ($g - $b) / ($a - $i);
	} elsif ($a == $g) {
		$h = ($b - $r) / ($a - $i) + 2;
	} else {
		$h = ($r - $g) / ($a - $i) + 4;
	}
	if ($h < 0) {
	    $h += 6;
	}
	$h = int(($h * 65535) / 6);
	
	# saturation
	if ($a > 0) {
		$s = int(($a - $i) * 255 / $a);
	} else {
		$s = 0;
	}

	# brightness
	$v = int($a);
	return ($h, $s, $v);
}

sub rgb_parse {
	my $filename = "/usr/share/X11/rgb.txt";
	open FILE, "< $filename" or die "open $filename";
	while (my $line = <FILE>) {
		$line =~ s/^\s+//;
		my @items = split /\s+/, $line;
		my $r = shift @items;
		my $g = shift @items;
		my $b = shift @items;
		my $name = join("",@items);
		$name =~ tr/A-Z/a-z/;
		my ($h, $s, $v) = rgb_to_hsv($r, $g, $b);
		$x11colors->{$name}->{'h'} = $h;
		$x11colors->{$name}->{'s'} = $s;
		$x11colors->{$name}->{'v'} = $v;
	}
}

sub rgb_lookup {
	my $cmd = shift;
	my $name = shift;

	die "color $name not found" unless defined($x11colors->{$name});
	#print Dumper($x11colors->{$name});
	$cmd->{'hue'} = $x11colors->{$name}->{'h'} + 0;
	$cmd->{'sat'} = $x11colors->{$name}->{'s'} + 0;
	$cmd->{'bri'} = $x11colors->{$name}->{'v'} + 0;
}

##############################################################################
# hue helpers

sub format_reachable {
	my $obj = shift;
	my $reachable;

	if (defined($obj->{'state'}->{'reachable'})) {
		# lights
		$reachable = $obj->{'state'}->{'reachable'}
	}
	if (defined($obj->{'config'}->{'reachable'})) {
		# sensors
		$reachable = $obj->{'config'}->{'reachable'}
	}

	return "-" if !defined($reachable);
	return $tt{'yes'} if $reachable;
	return $tt{'no'};
}

sub print_lights_header {
	print "\n";
	printf("Bri ID  %-16s  r  st   bri  mode    ct   hue sat   xy\n", "Name");
	printf("---------------------------------------------------------------------------\n");
}

sub print_lights_one {
	my $br = shift;
	my $state = shift;
	my $ry  = "\x1b[32;1m\N{CHECK MARK}\x1b[0m";
	my $rn  = "\x1b[31;1m\N{BALLOT X}\x1b[0m";
	my $on  = "\x1b[33;1m\N{WHITE SUN WITH RAYS}\x1b[0m";
	my $off = "-";

	# list lights
	for my $i (sort { $state->{'lights'}->{$a}->{'name'} cmp 
			      $state->{'lights'}->{$b}->{'name'} } keys %{$state->{'lights'}}) {
		my $l = $state->{'lights'}->{$i};
		printf("%3.3s %2d  %-16s  %s  %s ",
		       $br, $i, $l->{'name'}, format_reachable($l),
		       $l->{'state'}->{'on'} ? $tt{'on'}  : $tt{'off'} );
		if (defined($l->{'state'}->{'bri'})) {
			printf("   %3d", $l->{'state'}->{'bri'});
		} else {
			printf("     -");
		}
		if (defined($l->{'state'}->{'colormode'})) {
			printf("   %3s", $l->{'state'}->{'colormode'});
		} else {
			printf("     -");
		}
		if (defined($l->{'state'}->{'ct'})) {
			printf("   %3d", $l->{'state'}->{'ct'});
		} else {
			printf("     -");
		}
		if (defined($l->{'state'}->{'hue'})) {
			printf(" %5d %3d   %.4f,%.4f",
			       $l->{'state'}->{'hue'},
			       $l->{'state'}->{'sat'},
			       $l->{'state'}->{'xy'}[0],
			       $l->{'state'}->{'xy'}[1]);
		} else {
			printf("     -   -   -");
		}
		printf("\n");
	}
}

sub print_lights {
	my $states = shift;

	print_lights_header();
	for my $br (@bridges) {
		print_lights_one($br, $states->{$br});
	}
	print "\n";
}

sub print_users_header {
	print "\n";
	printf("%3.3s %-40s  %-20s  %-10s  %-10s\n",
	       "Bri", "ID", "Name", "Created", "Last used");
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
}

sub print_users_one {
	my $br = shift;
	my $state = shift;

	for my $i (sort keys %{$state->{'config'}->{'whitelist'}}) {
		my $u = $state->{'config'}->{'whitelist'}->{$i};
		printf("%3.3s %-40s  %-20s  %.10s  %.10s\n",
		       $br, $i,
		       $u->{'name'},
		       $u->{'create date'},
		       $u->{'last use date'});
	}
}

sub print_users {
	my $states = shift;

	print_users_header();
	for my $br (@bridges) {
		print_users_one($br, $states->{$br});
	}
	print "\n";
}

sub print_schedules {
	my $state = shift;

	print "\n";
	printf("%-2s  %-8s  %-20s  %s\n",
	       "ID", "UTC", "URI", "Body");
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
	for my $i (sort { $a <=> $b } keys %{$state->{'schedules'}}) {
		my $s = $state->{'schedules'}->{$i};
		my $t = $s->{'time'};
		my $a = $s->{'command'}->{'address'};
		my $b = $s->{'command'}->{'body'};
		$t =~ s/.*T//;
		$a =~ s/\/api\/[^\/]+//;
		if ($a =~ m/\/lights\/(\d+)\/state/) {
			$a = "light: " . $state->{'lights'}->{$1}->{'name'};
		}
		printf("%2s  %-8s  %-20s  %s\n", $i, $t, $a, encode_json($b));
	}
	print "\n";
}

sub print_groups_header {
	print "\n";
	printf("%3.3s %-2s  %-16s  %-16s  %s\n",
	       "Bri", "ID", "Name", "Class", "Lights");
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
}

sub print_groups_one {
	my $br = shift;
	my $state = shift;

	for my $i (sort { $a <=> $b } keys %{$state->{'groups'}}) {
		my $r = $state->{'groups'}->{$i};
		printf("%3.3s %2s  %-16s  %-16s", $br, $i,
		       $r->{'name'},
		       defined($r->{'class'}) ? $r->{'class'} : "-");
		for my $l (@{$r->{'lights'}}) {
			printf("  %s", $state->{'lights'}->{$l}->{'name'});
		}
		printf("\n");
	}
}

sub print_groups {
	my $states = shift;

	print_groups_header();
	for my $br (@bridges) {
		print_groups_one($br, $states->{$br});
	}
	print "\n";
}

sub print_sensors_header {
	print "\n";
	printf("%3.3s %-2s  %-16s  %-2s  %-16s  %-8s  %s\n",
	       "Bri", "ID", "Name", "St", "Type", "State", "Info");
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
}

sub print_sensors_one {
	my $br = shift;
	my $state = shift;

	for my $i (sort { $a <=> $b } keys %{$state->{'sensors'}}) {
		my $s = $state->{'sensors'}->{$i};
		printf("%3.3s %2s  %-16s  %s   %-16s", $br, $i, $s->{'name'},
		       format_reachable($s), $s->{'type'});
		if ($s->{'type'} eq "Daylight") {
			if ($s->{'config'}->{'contigured'}) {
				printf("  %-8s  pos %s,%s",
				       $s->{'state'}->{'daylight'} ? "on" : "off",
				       $s->{'config'}->{'lat'},
				       $s->{'config'}->{'long'});
			} else {
				printf("  unconfigured");
			}
		}
		if ($s->{'type'} eq "ZLLSwitch") {
			my $state = "-";
			$state = sprintf("btn %d", $s->{'state'}->{'buttonevent'})
			    if defined($s->{'state'}->{'buttonevent'});
			printf("  %-8s  ", $state);
			printf("battery %d%%", $s->{'config'}->{'battery'})
			    if defined($s->{'config'}->{'battery'});
		}
		printf("\n");
	}
}

sub print_sensors {
	my $states = shift;

	print_sensors_header();
	for my $br (@bridges) {
		print_sensors_one($br, $states->{$br});
	}
	print "\n";
}

sub print_rules {
	my $state = shift;

	print "\n";
	printf("%-2s  %-20s  %-2s\n",
	       "ID", "Name", "st");
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
	for my $i (sort { $a <=> $b } keys %{$state->{'rules'}}) {
		my $r = $state->{'rules'}->{$i};
		printf("%2s  %-20s  %-2s\n", $i, $r->{'name'},
		       $r->{'status'} eq "enabled" ? $tt{'yes'} : $tt{'no'});
		for my $c (@{$r->{'conditions'}}) {
			printf("%3s condition :  %s %s %s\n", "",
			       $c->{'address'}, $c->{'operator'},
			       defined($c->{'value'}) ? $c->{'value'} : "");
		}
		for my $a (@{$r->{'actions'}}) {
			my $b = join(", ", map { $_ . "=" . $a->{'body'}->{$_} }
				     keys %{$a->{'body'}});
			printf("%3s action    :  %s %s: %s\n", "",
			       $a->{'method'}, $a->{'address'}, $b);
		}
	}
	print "\n";
}

sub print_devices_header {
	print "\n";
	printf("%3.3s %-16s %-2s %-12s %-16s %-16s %s\n",
	       "Bri", "Name", "St", "Manufacturer", "Model", "Firmware", "Type");
}

sub print_devices_one {
	my $br = shift;
	my $state = shift;
	my $group = shift;

	for my $item (sort { $a <=> $b } keys %{$state->{$group}}) {
		my $dev = $state->{$group}->{$item};
		printf("%3.3s %-16s %s  %-12s %-16s %-16s %s\n",
		       $br, $dev->{'name'},
		       format_reachable($dev), 
		       $dev->{'manufacturername'},
		       $dev->{'modelid'},
		       $dev->{'swversion'},
		       $dev->{'type'});
	}
}

sub print_devices {
	my $states = shift;

	print_devices_header();
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
	for my $br (@bridges) {
		print_devices_one($br, $states->{$br}, "lights");
	}
	printf("%s%s\n",
	       "-----------------------------------------------",
	       "-----------------------------------------------");
	for my $br (@bridges) {
		print_devices_one($br, $states->{$br}, "sensors");
	}
	print "\n";
}

sub format_result {
	my $rc = shift;

	if (defined($rc->[0]->{'success'})) {
		my $s = $rc->[0]->{'success'};
		if (ref($s) eq "HASH") {
			my $v = to_json($s);
			return sprintf("OK: %s", $v);
		} else {
			return sprintf("OK: %s", $s);
		}
	}
	if (defined($rc->[0]->{'error'})) {
		my $e = $rc->[0]->{'error'};
		return sprintf("ERROR: #%d: %s", $e->{'type'}, 
			       $e->{'description'});
	}
	return Dumper($rc);
}

sub parse_value {
	my $value = shift;

	return JSON::true  if $value =~ m/(on|yes|true)/i;
	return JSON::false if $value =~ m/(off|no|false)/i;
	return int($value) if $value =~ m/^[0-9]+$/;
	return $value;
}

my $numargs_light = {
	"b"               => "bri",
	"bri"             => "bri",
	"bright"          => "bri",
	"brightness"      => "bri",
	"h"               => "hue",
	"hue"             => "hue",
	"s"               => "sat",
	"sat"             => "sat",
	"saturation"      => "sat",
	"ct"              => "ct",
	"time"            => "transitiontime",
	"transitiontime"  => "transitiontime",
};

sub parse_light_state {
	my $cmd = {};
	while (my $arg = shift) {
		if (defined($numargs_light->{$arg})) {
			my $opt = $numargs_light->{$arg};
			my $val = shift;
			$cmd->{$opt} = int($val);
			next;
		}
		if ($arg eq "on") {
			$cmd->{'on'} = JSON::true;
			next;
		}
		if ($arg eq "off") {
			$cmd->{'on'} = JSON::false;
			next;
		}
		if ($arg eq "alert") {
			$cmd->{'alert'} = "select";
			next;
		}
		if ($arg eq "loop" ||
		    $arg eq "colorloop") {
			$cmd->{'effect'} = "colorloop";
			next;
		}
		if ($arg eq "noeffect") {
			$cmd->{'effect'} = "none";
			next;
		}
		if ($arg eq "def" ||
		    $arg eq "default") {
			$cmd->{'on'} = JSON::true;
			$cmd->{'ct'} = 365;
			$cmd->{'bri'} = 240;
			next;
		}
		if ($arg eq "color") {
			my $val = shift;
			rgb_lookup($cmd, $val);
			next;
		}
		if ($arg =~ m/^(\w+)=(\w+)$/) {
			$cmd->{$1} = parse_value($2);
			next;
		}
		die "unknown arg: $arg";
	}
	return $cmd;
}

sub try_find_object {
	my $state = shift;
	my $type = shift;
	my $name = shift;
	my $index;

	if (defined($state->{$type}->{$name})) {
		# index specified
		$index = $name;
	} else {
		# try find by name
		for my $item (sort { $a <=> $b } keys %{$state->{$type}}) {
			if ($state->{$type}->{$item}->{'name'} eq $name) {
				$index = $item;
			}
		}
	}
	return $index;
}

sub find_object {
	my $state = shift;
	my $type = shift;
	my $name = shift;

	my $index = try_find_object($state, $type, $name);
	die "$type $name not found" unless defined($index);
	return $index;
}

sub find_lights {
	my $state = shift;
	my @lights;
	my $index;

	while (my $l = shift) {
		$index = find_object($state, 'lights', $l);
		push @lights, $index;
	}
	return \@lights;
}

sub set_light {
	my $states = shift;
	my $when = shift;
	my $name = shift;
	my $body = parse_light_state(@_);
	my ($br,$i,$state);

	for my $item (@bridges) {
		$br = $item;
		$state = $states->{$br};
		$i = try_find_object($state, 'lights', $name);
		last if defined($i);
	}
	die "lights $name not found" unless defined($i);
	my $l = $state->{'lights'}->{$i};
	my $cmd = create_command($br, "PUT", "/lights/$i/state", $body);
	if (defined($when)) {
		printf("schedule #%d [%s] at %s [utc]  ",
		       $i, $l->{'name'}, $when);
		my $rc = schedule_command($when, $cmd);
		printf("--  %s\n", format_result($rc));
	} else {
		printf("configure #%d [%s]  ",
		       $i, $l->{'name'});
		my $rc = execute_command($br, $cmd);
		printf("--  %s\n", format_result($rc));
	}
}

sub raw_request {
	my $uri = shift;
	my $rc = run_command($bridge, "GET", $uri, {});
	print to_json($rc, { pretty => 1 } );
#	print Dumper($rc);
}

sub raw_put_request {
	my $uri = shift;
	my $key = shift;
	my $value = shift;
	my $body = {};

	while (defined($key) && defined($value)) {
		$body->{$key} = parse_value($value);
		$key = shift;
		$value = shift;
	}
	print to_json($body, { pretty => 1 } );
	my $rc = run_command($bridge, "PUT", $uri, $body);
	print to_json($rc, { pretty => 1 } );
}

sub raw_del_request {
	my $uri = shift;
	my $rc = run_command($bridge, "DELETE", $uri, {});
	print to_json($rc, { pretty => 1 } );
}

sub calc_time {
	my $when = shift;
	my $hour = shift;
	my $min = shift;
	my @tm = localtime($when);
	$tm[0] = 0;
	$tm[1] = $min;
	$tm[2] = $hour;
	my $newtime = mktime(@tm);
	$newtime += 86400 if ($newtime < $when);
	return $newtime;
}

sub parse_time {
	my $arg = shift;
	my $when = time();

	if ($arg =~ m/^\+(\d+)s/) {
		$when += $1;
	} elsif ($arg =~ m/^\+(\d+)m/) {
		$when += $1 * 60;
	} elsif ($arg =~ m/^\+(\d+)h/) {
		$when += $1 * 60 * 60;
	} elsif ($arg =~ m/^(\d+):(\d+)/) {
		$when = calc_time($when, $1, $2);
	} else {
		die "can't parse time: $arg";
	}
	
	my $ret = strftime("%Y-%m-%dT%H:%M:%S", gmtime($when));
	return $ret;
}

sub rename_object {
	my $state = shift;
	my $type = shift;
	my $item = shift;
	my $name = shift;
	my $body = {};
	my $nr = find_object($state, $type, $item);

	$body->{'name'} = $name;
	my $rc = run_command($bridge, "PUT", "/$type/$nr", $body);
	printf("%s\n", format_result($rc));
	exit;
}

sub scan_objects {
	my $type = shift;

	print STDERR "Start scan for $type ";
	my $rc = run_command($bridge, "POST", "/$type", {});
	die unless defined($rc);
	do {
		sleep 3;
		print STDERR ".";
		$rc = run_command($bridge, "GET", "/$type/new", {});
	} while ($rc->{'lastscan'} eq "active");
	print STDERR " done\n";
	print Dumper($rc);
}

sub rule_update_body {
	my $state = shift;
	my $clear = shift;
	my $rname = shift;
	my $key = shift;
	my $value = shift;
	my $body = {};
	my $nr = find_object($state, 'rules', $rname);
	my $rule = $state->{'rules'}->{$nr};

	$rule->{'actions'}->[0]->{'body'} = {} if $clear;
	while (defined($key) && defined($value)) {
		$rule->{'actions'}->[0]->{'body'}->{$key} =
		    parse_value($value);
		$key = shift;
		$value = shift;
	}
	$body->{'actions'} = $rule->{'actions'};
	my $rc = run_command($bridge, "PUT", "/rules/$nr", $body);
	printf("%s\n", format_result($rc));
}

##############################################################################
# import/export

my @rules_props = ("name", "status", "conditions", "actions");
my @groups_props = ("name", "class", "type", "lights");

sub lookup_name {
	my $state = shift;
	my $type  = shift;
	my $idx   = shift;

	if (defined($state->{$type}->{$idx}->{'name'})) {
		return "/" . $type . "/[" .
		    $state->{$type}->{$idx}->{'name'} . "]/";
	}
	return "/" . $type . "/" . $idx . "/";
}

sub lookup_id {
	my $state = shift;
	my $type  = shift;
	my $name  = shift;

	my $idx = find_object($state, $type, $name);
	return "/" . $type . "/" . $idx . "/";
}

sub id_to_name {
	my $state = shift;
	my $string = shift;

	$string =~ s|/(\w+)/(\d+)/|lookup_name($state,$1,$2)|ge;
	return $string;
}

sub name_to_id {
	my $state = shift;
	my $string = shift;

	$string =~ s|/(\w+)/\[([^\]]+)\]/|lookup_id($state,$1,$2)|ge;
	$string =~ s|\[([^\]"\t ]+)\]|find_object($state,"lights",$1)|ge;
	return $string;
}

sub lights_id_to_name {
	my $state = shift;
	my $lights = shift;

	my @named = map { "[" . $state->{'lights'}->{$_}->{'name'} . "]" } @{$lights};
	return \@named;
}

sub hue_export_one {
	my $br = shift;
	my $state = shift;
	my $type  = shift;
	my $props = shift;

	for my $idx (sort { $a <=> $b } keys %{$state->{$type}}) {
		my $obj = $state->{$type}->{$idx};
		my $export = {};
		for my $prop (@{$props}) {
			next if !defined($obj->{$prop});
			if ($prop eq "lights") {
				$export->{$prop} = lights_id_to_name($state, $obj->{$prop});
			} else {
				$export->{$prop} = $obj->{$prop};
			}
		}
		my $filename = sprintf("%s-%s-%02d-%s", $type, $br, $idx,
				       $obj->{'name'});
		printf "# writing %s\n", $filename;
		open(FILE, ">", $filename) or die "open $filename: $!";
		print FILE id_to_name($state, to_json($export, { pretty => 1 } ));
		close FILE;
	}
}

sub hue_export {
	my $states = shift;
	my $type   = shift;
	my $props  = shift;

	for my $br (@bridges) {
		hue_export_one($br, $states->{$br}, $type, $props);
	}
}

sub hue_export_groups {
	my $states = shift;
	hue_export($states, 'groups', \@groups_props);
}

sub hue_export_rules {
	my $states = shift;
	hue_export($states, 'rules', \@rules_props);
}

sub hue_import {
	my $state = shift;
	my $type  = shift;
	my $file  = shift;
	my ($json, $body, $name, $idx, $rc);

	open(FILE, "<", $file) or die "open $file: $!";
	{ local $/; undef $/; $json = <FILE>; }
	close FILE;
	$json = name_to_id($state, $json);
	$body = from_json($json);
	$name = $body->{'name'};
	printf("# reading %s %s from %s\n", $type, $name, $file);

	# find by name
	for my $item (sort { $a <=> $b } keys %{$state->{$type}}) {
		if ($state->{$type}->{$item}->{'name'} eq $name) {
			$idx = $item;
		}
	}

	if (defined($idx)) {
		# update
		print "# $type $name is $idx\n";
		delete $body->{'name'};
		delete $body->{'type'};
		$rc = run_command($bridge, "PUT", "/$type/$idx", $body);
	} else {
		# create
		print "# $type $name is new\n";
		$rc = run_command($bridge, "POST", "/$type", $body);
	}
	printf("%s\n", format_result($rc));
}

##############################################################################
# misc helpers

sub print_help {
	print <<EOF;

usage:
   hue help                      print this text

   hue                           print lights state
   hue state                     print lights state

   hue light <name> <commands>   configure light(s)
   hue add-lights                add new (scan for) lights
   hue rename-light <nr> <name>  rename light

   hue rooms                     print rooms (and groups)
   hue add-room <name> <class>   add room
   hue add-group <name> <lights> add group
   hue room-lights <name> <lights> set room/group lights
   hue rename-room <nr> <name>   rename room
   hue del-room <nr>             delete room

   hue sensors                   print sensors
   hue add-sensors               add new (scan for) sensors
   hue rename-sensor <nr> <name> rename sensor

   hue rules                     print rules
   hue rule-update-body <rule> <key> <value>
   hue rule-replace-body <rule> <key> <value>
                                 update/replace action[0] body
   hue rename-rule <nr> <name>   rename rule
   hue del-rule <nr>             delete rule

   hue users                     print users
   hue del-user <id>             delete user

   hue at <time> light ...       create schedule
   hue schedules                 print schedules
   hue del-schedule <nr>         delete schedule

   hue raw <uri>                 raw get request
   hue raw-put <uri> <key> <val> raw put request
   hue raw-del <uri>             raw delete request
   hue manual <method> <uri> <body> manual request

   hue export                    export bridge state to files
   hue import <type> <file>      import bridge object from file

 commands:
   on                            turn on
   off                           turn off
   loop                          colorloop effect
   noeffect                      disable effects
   def                           set default color & brightness
   bri   <val>                   set brightness      [ 0 - 255   ]
   hue   <val>                   set hue             [ 0 - 65535 ]
   sat   <val>                   set saturation      [ 0 - 255   ]
   ct    <val>                   set color temp      [ 153 - 500 ]
   time  <time>                  transition time     [ multiple of 100ms ]
   color <name>                  set color by name
   <key>=<value>                 set raw key/value

 time specs:
   +<nr>s                        in <nr> seconds
   +<nr>m                        in <nr> minutes
   +<nr>h                        in <nr> hours
   hh:mm                         at given time (next day if in the past)

EOF
}

##############################################################################
# main

my $mode = shift;
$ua = LWP::UserAgent->new;

# print help
if (defined($mode) && ($mode eq "h" || $mode eq "-h" || $mode eq "help")) {
	print_help();
	exit;
}

# init
rgb_parse();

# config: bridge address
if (!defined($server{$bridge})) {
	print "hue bridge (hostname/ipaddr) ? ";
	chomp($server{$bridge} = <>);
	$cfg->param($bridge . '.bridge', $server{$bridge});
}

# read state (and test whenever we have access)
my ($states, $state);
for my $br (@bridges) {
	$states->{$br} = run_command($br, "GET", "", {}) if defined($user{$br});
	if (!defined($states->{$br})) {
		# config: user
		printf STDERR "### try adding user to bridge \"$br\"\n";
		printf STDERR "### press link button to allow access\n";
		my $rc;
		while (1) {
			$rc = rest_post($br, "/api", { 'devicetype' => $devid });
			last if (defined($rc) && defined($rc->[0]->{'success'}));
			printf("Error: %s\n", 
			       $rc->[0]->{'error'}->{'description'})
			    if defined($rc->[0]->{'error'});
			sleep 5;
		};

		# save user
		$user{$br} = $rc->[0]->{'success'}->{'username'};
		$cfg->param($br . '.user', $user{$br});
		printf STDERR "### OK: user %s\n", $user{$br};

		# read state
		$states->{$br} = run_command($br, "GET", "", {});
	}
	die unless defined($states->{$br});
}
$state = $states->{$bridge};


##########################################
# parse schedule time

my $cmdtime;

if (defined($mode) and $mode eq "at") {
	my $time = shift;
	$mode = shift;
	$cmdtime = parse_time($time);
} else {
	$cmdtime = undef;
}

##########################################
# lights

# print state
if (!defined($mode) or $mode eq "state") {
	print_lights $states;
	exit;
}

# program lights
if ($mode eq "l" || 
    $mode eq "light") {
	set_light($states, $cmdtime, @ARGV);
	exit;
}

# add lights
if ($mode eq "add-lights") {
	scan_objects("lights");
	exit;
}

# rename lights
if ($mode eq "rename-light") {
	rename_object($state, "lights", shift, shift);
	exit;
}

##########################################
# users

if ($mode eq "users") {
	print_users $states;
	exit;
}

if ($mode eq "del-user") {
	my $id = shift;
	my $rc = run_command($bridge, "DELETE", "/config/whitelist/$id", {});
	printf("%s\n", format_result($rc));
	exit;
}

##########################################
# schedules

if ($mode eq "schedules") {
	print_schedules $state;
	exit;
}

if ($mode eq "del-schedule") {
	my $id = shift;
	my $rc = run_command($bridge, "DELETE", "/schedules/$id", {});
	printf("%s\n", format_result($rc));
	exit;
}

##########################################
# groups

if ($mode eq "groups" || $mode eq "rooms") {
	print_groups $states;
	exit;
}

if ($mode eq "add-room") {
	my $body = {};
	my $name = shift;
	my $class = shift;
	$body->{'type'} = "Room";
	$body->{'name'} = $name;
	$body->{'class'} = $class if defined($class);
	my $rc = run_command($bridge, "POST", "/groups", $body);
	printf("%s\n", format_result($rc));
	exit;
}

if ($mode eq "add-group") {
	my $body = {};
	$body->{'type'} = "LightGroup";
	$body->{'name'} = shift;
	$body->{'lights'} = find_lights($state, @ARGV);
	my $rc = run_command($bridge, "POST", "/groups", $body);
	printf("%s\n", format_result($rc));
	exit;
}

if ($mode eq "room-lights" || $mode eq "group-lights") {
	my $name = shift;
	my $index = find_object($state, "groups", $name);
	my $body = {};
	$body->{'lights'} = find_lights($state, @ARGV);
	my $rc = run_command($bridge, "PUT", "/groups/$index", $body);
	printf("%s\n", format_result($rc));
	exit;
}

if ($mode eq "rename-room" || $mode eq "rename-group") {
	rename_object($state, "groups", shift, shift);
	exit;
}

if ($mode eq "del-room" || $mode eq "del-group") {
	my $id = shift;
	my $rc = run_command($bridge, "DELETE", "/groups/$id", {});
	printf("%s\n", format_result($rc));
	exit;
}

##########################################
# sensors

if ($mode eq "sensors") {
	print_sensors $states;
	exit;
}

# add sensors
if ($mode eq "add-sensors") {
	scan_objects("sensors");
	exit;
}

if ($mode eq "rename-sensor") {
	rename_object($state, "sensors", shift, shift);
	exit;
}

##########################################
# rules

if ($mode eq "rules") {
	print_rules $state;
	exit;
}

if ($mode eq "rule-update-body") {
	rule_update_body($state, 0, @ARGV);
	exit;
}

if ($mode eq "rule-replace-body") {
	rule_update_body($state, 1, @ARGV);
	exit;
}

if ($mode eq "rename-rule") {
	rename_object($state, "rules", shift, shift);
	exit;
}

if ($mode eq "del-rule") {
	my $id = shift;
	my $rc = run_command($bridge, "DELETE", "/rules/$id", {});
	printf("%s\n", format_result($rc));
	exit;
}

##########################################
# hacking

# device properties
if ($mode eq "devices" || $mode eq "dev") {
	print_devices($states);
	exit;
}

# raw access
if ($mode eq "raw") {
	raw_request(@ARGV);
	exit;
}

if ($mode eq "raw-put") {
	raw_put_request(@ARGV);
	exit;
}

if ($mode eq "raw-del") {
	raw_del_request(@ARGV);
	exit;
}

if ($mode eq "manual") {
	manual_request(@ARGV);
	exit;
}

# read/write from files
if ($mode eq "export") {
	hue_export_groups($states);
	hue_export_rules($states);
	exit;
}

if ($mode eq "import") {
	hue_import($state, shift, shift);
	exit;
}

die "unknown mode: $mode";