#!/opt/bin/perl

# lots of things have been hardcoded. search for #d# to find the places

use KGS::Protocol;
use KGS::Listener::Debug;

use IO::Socket::INET;
use Event;

use GetOpt::Long;
use Carp;

$VERSION = 0.0; # be more confident....

$SIG{QUIT} = sub { Carp::confess "SIGQUIT" };

my $kgs;
my $verbose = 1;
my $user = "guest";
my $pass = undef;

sub usage {
   print STDERR <<EOF
Usage: $0 [options] -- engine engine-args...
           -u username    usernmae to connect
           -p password    optional password to connect (none => guest)
           -v             increase verbosity
           -q             decrease verbosity

$0 connects to the kiseido go server, starts the named engine
and communicates with it using GTP protocol using it's stdin and stdout.

If no engine is given, uses stdin/stdout itself for communications.

The engine can optionally act as controller, too, as long as it isn't
confused by responses on it's command input stream.

Command extension used by the controller:

kgs-login message      # login successful
...

Commands usable by the client:

...

EOF
   exit shift;
}

GetOptions (
      "u=s" => \$user,
      "v"   => sub { $verbose++ },
      "q"   => sub { $verbose-- },
      "h"   => sub { usage(0) };
) or die usage(1);

package kgs;

use base KGS::Listener;

my $conn = new KGS::Protocol;

sub new {
   my $class = shift;
   my $self = bless { @_ }, $class;

   print STDERR "$0 version $VERSION connecting...\n" if $verbose;

   my $sock = new IO::Socket::INET PeerHost => $ENV{KGSHOST} || "kgs.kiseido.com", PeerPort => "2379"
      or die "connect: $!";

   $sock->blocking (1);
   $conn->handshake ($sock);

   $self->listen ($conn, "any");

   # Listener for kgs data
   $self->{w} = Event->io (fd => $sock, poll => 'r', cb => sub {
      my $len = sysread $sock, my $buf, 16384;
      if ($len) {
         $conn->feed_data($buf);
      } elsif (defined $len || (!$!{EINTR} and !$!{EAGAIN})) {
         print STDERR "disconnected\n" if $verbose;
         Event::unloop;
      }
   });

   # Listener for keyboard input. Needs a tty
   $self->{kbd} = Event->io (fd => \*STDIN, poll => 'r', cb => sub {
      $self->inject_cmd (<STDIN>);
   });

   $conn->login ("kgsclient 0.0", $self->{user}, delete $self->{password});

   $self;
}

sub inject_login {
   my ($self, $msg) = @_;

   print STDERR "login: $msg->{message}\n" if $verbose;
#   $self->send (join_room =>
#                channel => 13,
#                user => { name => $self->{user} });
}

sub inject_msg_room {
   my ($self, $msg) = @_;
   print "$msg->{name}#$msg->{channel}: $msg->{message}\n";
}

sub inject_any {
   my ($self, $msg) = @_;
   print "DEBUG: $msg->{type}#$msg->{channel}" if $verbose;
   for (sort keys %$msg) {
      print "   $_<$msg->{$_}>";
   }
   print "\n";
}

# user input
sub inject_cmd {
   my ($self, $cmd) = @_;
   chomp $cmd;
   print ">>>>> $cmd\n" if $verbose;
   $self->send (msg_room =>
                channel => 13,
                name => $self->{user},
                message => $cmd);
}

package gtp;

sub new {
   my $class = shift;
   bless { @_ }, $class;
}

sub set_fh {
   my ($self, $in, $out) = @_;

   $self->{i} = $in;
   $self->{o} = $out;

   Event->io (fd =>
}

sub run_engine {
}

package main;

$kgs = new kgs user => "kgsclient", undef; #d#

Event::loop;

1;