#!/usr/bin/perl
use Filter::Template;
const XNode POE::Filter::XML::Node

use warnings;
use strict;

use POE;
use POE::Component::Jabber;
use	POE::Component::Jabber::Error; 			#include error constants
use	POE::Component::Jabber::Status; 		#include status constants
use	POE::Component::Jabber::ProtocolFactory;#include connection type constants
use POE::Filter::XML::Node; 				#include to build nodes
use POE::Filter::XML::NS qw/ :JABBER :IQ /; #include namespace constants
use POE::Filter::XML::Utils; 				#include some general utilites
use POE::Component::RSSAggregator;
use Carp;
use Data::Dumper;

# First we create our own session within POE to interact with PCJ
POE::Session->create(
		     inline_states => {
				       _start => \&_start,
				       _stop => \& _stop,
				       input_event => \&input_event,
				       error_event => \&error_event,
				       status_event => \&status_event,
				       test_message => \&test_message,
				       output_event => \&output_event,
				       Command => \&Command,
				       HasFeed => \&HasFeed,
				       GetQueue => \&GetQueue,
				       InitRss =>\&InitRss,
				      },
		     heap => {
			      Queue =>[],
			     }
);


sub _start {
    my ($kernel, $session,$heap) = @_[KERNEL, SESSION, HEAP];
    $kernel->alias_set('Tester');
    $heap->{'component'} =
      POE::Component::Jabber->new(
				  IP => '213.180.203.18',
				  Port => '5222',
				  Hostname => 'jabber.ru',
				  Username => 'mayperl',
				  Password => 'geo18data7',
				  Alias => 'COMPONENT',
				  ConnectionType => +XMPP,
				  resource =>'POE',
				  Debug => 0,
				  States => {
					     StatusEvent => 'status_event',
					     InputEvent => 'input_event',
					     ErrorEvent => 'error_event',
					    }
				 );
    $kernel->post('COMPONENT', 'connect');
}

sub _stop {
      my $kernel = $_[KERNEL];
      $kernel->alias_remove();
  }

sub InitRss {
    my ($kernel, $session,$heap) = @_[KERNEL, SESSION, HEAP];
    $heap->{rssagg}=POE::Component::RSSAggregator->new
      (
       alias    => 'rssagg',
       debug    => 1,
       callback => $session->postback("HasFeed"),
       tmpdir   => '/tmp',
       name     =>'rssagg',
      );
    $kernel->post( 'rssagg', 'add_feed',
		   {
		    url =>'http://ivan.serezhkin.com/t.rss',
		    name => 'VANY',
		    delay =>60,
		   },);
    $kernel->post( 'rssagg', 'add_feed',
		   {
		    url =>'http://www.linux.org.ru/section-rss.jsp',
		    name => 'LOR',
		    delay =>300,
		   },);

}

sub status_event {
    my ($kernel, $sender, $heap, $state) = @_[KERNEL, SENDER, HEAP, ARG0];
    if($state == +PCJ_INIT_FINISHED) {
	my $jid = $heap->{'component'}->jid();
	print "INIT FINISHED! \n";
	print "JID: $jid \n";
	print 'SID: '.$sender->ID()."\n\n";
	$heap->{'jid'} = $jid;
	$heap->{'sid'} = $sender->ID();
	$kernel->post('COMPONENT', 'output_handler', XNode->new('presence'));
	$kernel->post('COMPONENT', 'purge_queue');
	$kernel->yield('test_message');
	$kernel->yield('InitRss');
    }
    print "Status received: $state \n";

}

sub input_event() {
    my ($kernel, $heap, $node) = @_[KERNEL, HEAP, ARG0];
    if ( $node->attr('from') eq 'deepone@jabber.ru/Psi' and
	 $node->attr('type') eq 'chat' ) {
	$kernel->yield(Command=>$node);
    } elsif ($node->attr('type') eq 'chat') {
	print 'FROM: '.$node->attr('from')."\n";
	print 'SUBJECT: '.$node->get_tag('subject')->to_str()."\n";
	print 'BODY: '.$node->get_tag('body')->to_str()."\n";
	print ".\n";
    } else {
	print "\n===PACKET RECEIVED===\n";
	print $node->to_str();
	print "=====================\n\n";
	$kernel->yield('test_message');
    }
}

sub Command {
    my ($kernel, $session, $heap, $node) = @_[KERNEL, SESSION, HEAP, ARG0];
    print "COMMAND\n";
    my $data="\n".Dumper(eval $node->get_tag('body')->data() or "$@$!" or 'Done');
    my $Snode = XNode->new('message');
    $Snode->attr('to', $node->attr('from'));
    $Snode->attr('type', 'chat');
    $Snode->insert_tag('body')->data($data);
    $kernel->yield('output_event', $Snode, $heap->{'sid'});
}

sub HasFeed {
    my ($kernel,$heap,$arg)=@_[KERNEL,HEAP,ARG1];
    print "\n\nHAS FEED\n\n";
    for my $feed ($arg->[0]->late_breaking_news) {
	warn $feed->headline."  BZINK\n";
	push @{$heap->{Queue}}, $feed;
    }
}

sub GetQueue {
    my ($kernel,$heap,$arg)=@_[KERNEL,HEAP,ARG1];
    while (my $ev = shift @{$heap->{Queue}}) {
	my $Snode = XNode->new('message');
	$Snode->attr('to', 'deepone@jabber.ru');
	$Snode->attr('type', 'chat');
	$Snode->insert_tag('body')->data($ev->{description});
	$Snode->insert_tag('subject')->data($ev->{headline});
	$kernel->yield('output_event', $Snode, $heap->{'sid'});
    }
}

sub test_message()
{
	my ($kernel, $heap) = @_[KERNEL, HEAP];
	my $node = XNode->new('message');
	$node->attr('to', 'deepone@jabber.ru');
	$node->attr('type', 'chat');
	$node->insert_tag('body')->data('Listen to you command , Master !');
	$kernel->yield('output_event', $node, $heap->{'sid'});

}

sub output_event()
{
	my ($kernel, $heap, $node, $sid) = @_[KERNEL, HEAP, ARG0, ARG1];
	print "\n===PACKET SENT===\n";
	print $node->to_str() . "\n";
	print "=================\n\n";
	$kernel->post($sid, 'output_handler', $node);
}

sub error_event()
{
	my ($kernel, $sender, $heap, $error) = @_[KERNEL, SENDER, HEAP, ARG0];

	if($error == +PCJ_SOCKETFAIL)
	{
		my ($call, $code, $err) = @_[ARG1..ARG3];
		print "Socket error: $call, $code, $err\n";
		print "Reconnecting!\n";
		$kernel->post($sender, 'reconnect');
	} elsif($error == +PCJ_SOCKETDISCONNECT) {
		print "We got disconneted\n";
		print "Reconnecting!\n";
		$kernel->post($sender, 'reconnect');
	} elsif($error == +PCJ_CONNECTFAIL) {
		print "Connect failed\n";
		print "Retrying connection!\n";
		$kernel->post($sender, 'reconnect');
	} elsif ($error == +PCJ_SSLFAIL) {
		print "TLS/SSL negotiation failed\n";
	} elsif ($error == +PCJ_AUTHFAIL) {
		print "Failed to authenticate\n";
	} elsif ($error == +PCJ_BINDFAIL) {
		print "Failed to bind a resource\n";
	} elsif ($error == +PCJ_SESSIONFAIL) {
		print "Failed to establish a session\n";
	} elsif ($error == +PCJ_NODESENT) {
		print "NODESENT\n";
	}
}
POE::Kernel->run();






package J;