#!/usr/bin/perl -w
use warnings;
use strict;
use Carp qw(carp croak);

use POE qw( Wheel::SocketFactory Driver::SysRW Wheel::ReadWrite);

{ package POE::Filter::SimpleQueryString;
  use Carp qw(carp croak);
  
  sub new { 
    my $class = shift;
    my $self = bless {}, $class;
    return $self;
  }
  
  sub get {
    my $self = shift;
    my $buffer = shift;
    my @chunks; 
    foreach my $record (@$buffer) { 
      $record =~ s/\x0d\x0a$//;
      my @pairs = split(/&/, $record);
  
      my %chunk;
      foreach my $pair (@pairs) {
        my ($key, $value) = split(/=/, $pair, 2);
        
        if(defined $chunk{$key}) {
          if(ref $chunk{$key} eq 'ARRAY') {
            push @{ $chunk{$key} }, $value;
          } else {
            $chunk{$key} = [ $chunk{$key}, $value ],
          }
        } else {
          $chunk{$key} = $value;
        }
      }
      push @chunks, \%chunk;
    }
    return \@chunks;
  }
  
  sub put { 
    my $self = shift;
    my $records = shift;
    
    print "$self\n$records\n";
    
    my @raw;
    foreach my $record (@$records) {
      my @chunks;
      foreach my $key (sort keys %$record) {
        if(ref $record->{$key}) {
          if(ref $record->{$key} eq 'ARRAY') {
            foreach my $value ( @{ $record->{$key} } ) {
              push @chunks, $key."=".$value;
            }
          } else {
            carp __PACKAGE__." cannot handle data of type 
            ".ref $record->{$key};
          }
        } else {
          push @chunks, $key."=".$record->{$key};
        }
      }
      push @raw, join('&',@chunks)."\x0d\x0a";
    }
    return \@raw;
  }
}

sub start {
  $_[HEAP]->{factory} = POE::Wheel::SocketFactory->new( BindAddress    => '127.0.0.1',
                                                        BindPort       => '31337',
                                                        SuccessEvent   => 'factory_success',
                                                        FailureEvent   => 'fatal_error',
                                                        SocketProtocol => 'tcp',
                                                        Reuse          => 'on',
                                                      );
}

sub factory_success {
  my ($handle, $wheel_id) = @_[ARG0, ARG3];


  my $temp_rw_id = POE::Wheel::ReadWrite->new( Handle      => $handle,
                                               Driver      => POE::Driver::SysRW->new(),
                                               Filter      => POE::Filter::SimpleQueryString->new(),
                                               InputEvent  => 'client_input',
                                             );
  
  $_[HEAP]->{clients}->{$wheel_id}        = $temp_rw_id;                                                            
  $_[HEAP]->{current_client}->{$temp_rw_id->ID} = $wheel_id;
  
  print "factory_success called, creating wheel $wheel_id for handle $handle | ( ".$temp_rw_id->ID." )\n";
}

sub client_input {
  my ($input, $wheel_id) = @_[ARG0, ARG1];
  my $factory_id = $_[HEAP]->{current_client}->{$wheel_id};
  
  use Data::Dumper;
  print Dumper $input;
  print "wheel_id is: $wheel_id\n";
  print "factory_id is: $factory_id\n";

  $_[HEAP]->{clients}->{$factory_id}->put($input);
}

POE::Session->create( inline_states => { _start          => \&start,
                                         factory_success => \&factory_success,
                                         client_input    => \&client_input,
                                         client_error    => \&client_error,
                                         fatal_error     => sub { die "A fatal error occurred" },
                                         _stop           => sub {},
                                       },
                    );

POE::Kernel->run();