package POEDaemon::WheelRun::OneWire;


use strict;
use warnings FATAL => 'all';
no warnings 'redefine';

use POE;
use POEDaemon;


sub states
{
	return $_[0],
	[qw(
		onewire_start
		onewire_stop
		
		onewire_childexit
		
		onewire
		onewire_stdout_line
		onewire_stderr_line
	)];
}


sub onewire_start
{
	my ($kernel, $heap) = @_[KERNEL, HEAP];
	
	
	log_enabled && logline 'event fired';
	
	
	my $port = cfg->{onewire_port};
	
	
	unless ($port)
	{
		log_enabled && logline 'no port';
		
		return;
	}
	
	
	my $prog =
	[
		'util/1-wire.pl',
		$port,
	];
	
	
	log_enabled && logline 'wheelrun_exec';
	
	
	$kernel->yield(wheelrun_exec =>
	{
		prog         => $prog,
		name         => 'onewire',
		stdout_event => 'onewire_stdout_line',
		stderr_event => 'onewire_stderr_line',
	});
}


sub onewire_stop
{
	my $kernel = $_[KERNEL];
	
	
	$kernel->yield(wheelrun_kill => { wheel_name => 'onewire' });
}


sub onewire_childexit
{
	my ($kernel, $heap) = @_[KERNEL, HEAP];
	
	
	unless ($heap->{shutdown})
	{
		$kernel->yield(shutdown => 'onewire child abnormally terminated');
	}
}


sub onewire
{
	my ($heap, $args) = @_[HEAP, ARG0];
	
	
	my $cmd = $args->{cmd};
	
	
	unless (defined $cmd)
	{
		log_enabled && logline 'undef cmd';
		
		return;
	}
	
	unless ($cmd =~ /^\w+$/i)
	{
		log_enabled && logline "invalid cmd '%s'", $cmd;
		
		return;
	}
	
	
	my $line = $cmd;
	
	
	my $wheel = $heap->{wheel_run}->{children_by_name}->{onewire}->{wheel};
	
	return unless $wheel;
	
	
	#log_enabled && logline "put '%s'", $line;
	
	
	$wheel->put($line);
}


sub onewire_stdout_line
{
	my ($kernel, $session, $heap, $line) = @_[KERNEL, SESSION, HEAP, ARG0];
	
	
	my ($type, $id, $value);
	
	
	if ($line =~ /^\s*(temp)\s+([[:xdigit:]]+)\s+(\S+)\s*$/i)
	{
		$type  = lc $1;
		$id    = uc $2;
		$value =    $3;
	}
	else
	{
		log_enabled && logline "invalid line = '%s'", $line;
		
		return;
	}
	
	
	my $time = time_hires;
	
	
	$heap->{onewire}->{$type}->{$id} =
	{
		value => $value,
		time  => $time,
	};
	
	
	my $result = sprintf "%s %s %s %s",
		$time,
		$type,
		$id,
		$value;
	
	
	my $output_per_target;
	
	
	$output_per_target->{tcpserver} = sprintf "ONEWIRE %s", $result;
	
	$output_per_target->{tcpclient} = sprintf "%s onewire %s",
		POECLIENT_CMD_PREFIX,
		$result;
	
	
	#foreach my $target (qw(tcpserver tcpclient))
	#{
	#	next unless exists $heap->{$target} && exists $heap->{$target}->{connections};
	#	
	#	
	#	my $tcpserver = $target eq 'tcpserver';
	#	my $tcpclient = $target eq 'tcpclient';
	#	
	#	
	#	my $output = sprintf "%s %s",
	#		($tcpclient ? sprintf "%s onewire", POECLIENT_CMD_PREFIX : 'ONEWIRE'),
	#		$result;
	#	
	#	
	#	foreach my $wheel_id (keys %{$heap->{$target}->{connections}})
	#	{
	#		next if $tcpserver && !$heap->{$target}->{connections}->{$wheel_id}->{onewire_watch};
	#		
	#		
	#		next unless $heap->{$target}->{connections}->{$wheel_id}->{wheel};
	#		
	#		
	#		$kernel->call($session => sprintf("%s_output", $target) =>
	#		{
	#			wheel_id  => $wheel_id,
	#			output    => $output,
	#			use_flush => 1,
	#		});
	#	}
	#}
	
	
	$kernel->call($session => wheelrun_send_network_reply =>
	{
		output_per_target => $output_per_target,
		use_flush         => 1,
	});
	
	
	log_enabled && logline "onewire %s", $result;
}


sub onewire_stderr_line
{
	my ($kernel, $session, $heap, $line) = @_[KERNEL, SESSION, HEAP, ARG0];
	
	
	log_enabled && logline "line = '%s'", $line;
	
	
	return unless $line =~ /^ready$/i;
	
	
	$line = lc $line;
	
	
	my $output_per_target;
	
	
	$output_per_target->{tcpserver} = sprintf "ONEWIRE %s", $line;
	
	$output_per_target->{tcpclient} = sprintf "%s onewire %s",
		POECLIENT_CMD_PREFIX,
		$line;
	
	
	#foreach my $wheel_id (keys %{$heap->{tcpclient}->{connections}})
	#{
	#	next unless $heap->{tcpclient}->{connections}->{$wheel_id};
	#	
	#	next unless $heap->{tcpclient}->{connections}->{$wheel_id}->{wheel};
	#	
	#	
	#	$kernel->yield(tcpclient_output =>
	#	{
	#		wheel_id => $wheel_id,
	#		output   => $output,
	#	});
	#}
	
	
	$kernel->call($session => wheelrun_send_network_reply =>
	{
		output_per_target => $output_per_target,
	});
}


1;