POE::Component::Server::Bayeux::Client - An object representing a single client of the server

package POE::Component::Server::Bayeux::Client;

use strict;
use warnings;
use Params::Validate;
use Data::UUID;
use POE;

use base qw(Class::Accessor);
__PACKAGE__->mk_accessors(qw(
    request id ip
    is_error
    flags
    server_heap
    heap
    session
));

my $uuid = Data::UUID->new();

sub new {
    my $class = shift;

    my %self = validate(@_, {
        server_heap => 1,
        request => 0,
        id => 0,
        session => 0,

        flags => { default => {} },
        heap  => { default => {} },
    });
    my $self = bless \%self, $class;

    if ($self->request) {
        $self->ip( $self->request->ip );
    }

    # Don't let the client id be arbitrarily defined save by a POE session
    if ($self->id && ! $self->session && ! $self->server_heap->{clients}{$self->id}) {
        $self->is_error("Client id '".$self->id."' is invalid");
        return $self;
    }

    if (! $self->id || ($self->session && ! $self->server_heap->{clients}{$self->id})) {
        # Create a new client id
        $self->id( $uuid->create_str() ) unless $self->id();
        my $heap = {
            created => time,
            ip => $self->ip,
            flags => {
                last_connect => time,
            },
            session => $self->session,
        };
        $self->server_heap->{clients}{ $self->id } = $heap;

        # Let the manager server know so it can do notifications
        $poe_kernel->post( $self->server_heap->{manager},
            'client_connect', {
                client_id => $self->id,
                ($self->session ? (
                    session => $self->session,
                ) : (
                    ip => $self->ip,
                )),
            },
        );
    }

    $self->heap( $self->server_heap->{clients}{$self->id} );
    $self->session( $self->heap->{session} ) if ! $self->session && $self->heap->{session};
    $self->flags( $self->heap->{flags} );

    # Special: if is_polling, make sure it's still a pending request
    if (my $req_id = $self->heap->{flags}{is_polling}) {
        delete $self->heap->{flags}{is_polling}
            if ! defined $self->server_heap->{requests}{$req_id};
    }

    return $self;
}

sub disconnect {
    my ($self) = @_;

    $self->complete_poll();

    # Let the manager server know so it can do notifications and unsubscribes
    $poe_kernel->post( $self->server_heap->{manager},
        'client_disconnect', { client_id => $self->id });
}

sub complete_poll {
    my ($self) = @_;
    if (my $req_id = $self->flags->{is_polling}) {
        $poe_kernel->post( $self->server_heap->{manager},
            'complete_request', $req_id );
    }
}

sub message_acl {
    my ($self, $message) = @_;

    # If the client has asked for comment filtered JSON, pass this along to the
    # request which will be encapsulating the results.
    if ($self->flags->{'json-comment-filtered'}) {
        $message->request->json_comment_filtered(1);
    }

    # All messages fail if I'm in error
    if ($self->is_error) {
        $message->is_error($self->is_error);
        return;
    }

    $self->server_config->{MessageACL}->($self, $message);
    return if $message->is_error;
}

sub is_subscribed {
    my ($self, $channel) = @_;

    return exists $self->heap->{subscriptions}{$channel};
}

sub send_message {
    my ($self, $message, $subscription_args) = @_;

    if ($subscription_args->{no_callback}) {
        return;
    }

    if ($self->session) {
        my $state = $subscription_args->{state} || 'deliver';
        $poe_kernel->post( $self->session, $state, $message );
        return;
    }

    $self->check_timeout();
    if ($self->is_error()) {
        $self->logger->error("Not sending message to client ".$self->id.": ".$self->is_error);
        return;
    }

    $self->logger->debug("Queuing message to client ".$self->id);
    push @{ $self->heap->{queued_responses} }, $message;

    # Delay flush_queue so that if other responses need to be queued, they'll go out at the same time
    $poe_kernel->post($self->server_heap->{manager}, 'delay_sub', 'flush_queue.' . $self->id, 0, sub { $self->flush_queue });
}

sub check_timeout {
    my ($self) = @_;

    return if $self->session;
    return if $self->flags->{is_polling};
    my $connect_timeout = $self->server_heap->{args}{ConnectTimeout};
    if (time - $self->flags->{last_connect} < $connect_timeout) {
        return;
    }

    $self->is_error("Connect timeout; removing client");
    $self->disconnect();
}

    
sub flush_queue {
    my ($self) = @_;

    return if ! $self->heap->{queued_responses};
    return if ! $self->flags->{is_polling};

    my $request = $self->server_heap->{requests}{ $self->flags->{is_polling} };
    return if ! $request;

    my $queue = delete $self->heap->{queued_responses};
    return if ! ref $queue || ref $queue ne 'ARRAY' || int @$queue == 0;

    $self->logger->debug("Flushing queue to active request on ".$self->id);

    $request->add_response($_) foreach @$queue;
    $self->complete_poll();
}

sub logger {
    my ($self) = @_;

    return $self->server_heap->{logger};
}

sub server_config {
    my ($self) = @_;

    return $self->server_heap->{args};
}

1;