###########################################################################
# package Net::SIP::ReceiveChain
# used to put Authorize, Registrar, StatelessProxy etc together so that
# the object first in chain will try to handle the packets first and
# pass them only to the next object if it was not fully handled by the
# previous object
# each object in chain returns TRUE from method receive if it handled
# the packet fully
###########################################################################

use strict;
use warnings;

package Net::SIP::ReceiveChain;
use fields qw( objects filter );
use Net::SIP::Util 'invoke_callback';

###########################################################################
# creates new ReceiveChain object
# Args: ($class,$objects,%args)
#   $objects: \@list of objects which it should put in the chain
#   %args:
#      filter: callback invoked on each packet to find out if it should
#         be processed by this chain
#      methods: \@list of methods, used if no filter is given
# Returns: $self
###########################################################################
sub new {
    my ($class,$objects,%args) = @_;
    my $self = fields::new( $class );
    if ( ! ( $self->{filter} = $args{filter} )) {
	if ( my $m = $args{methods} ) {
	    # predefined filter to filter based on method
	    my %m = map { $_ => 1 } @$m;
	    my $method_filter = sub {
		my ($hm,$packet) = @_;
		return $hm->{ $packet->method }
	    };
	    $self->{filter} = [ $method_filter, \%m ];
	}
    }
    $self->{objects} = $objects;
    return $self;
}

###########################################################################
# handle packet, called from Net::SIP::Dispatcher on incoming requests
# Args: ($self,$packet,$leg,$addr)
#  $packet: Net::SIP::Packet
#  $leg: Net::SIP::Leg where request came in (and response gets send out)
#  $addr: ip:port where request came from and response will be send
# Returns: TRUE if it handled the packet
###########################################################################
sub receive {
    my Net::SIP::ReceiveChain $self = shift;
    my ($packet,$leg,$addr) = @_;

    if ( my $f = $self->{filter} ) {
	# check if packet should be handled by filter
	return if ! invoke_callback($f,$packet,$leg,$addr);
    }
    foreach my $object (@{ $self->{objects} }) {
	my $handled = $object->receive($packet,$leg,$addr);
	return $handled if $handled;
    }
    return; # not handled
}

1;