rpc_port    int    = 8099

import setup

struct Command {

struct Actor {
	out      chan Command
	rpc_port int
}
pub struct Command {

pub fn setup(c chan Command) {
	l := net.listen_tcp(8099) or {

pub fn init(c chan Command, config setup.Config) Actor {
	mut self := Actor{
		out: c
		rpc_port: config.rpc_port
	}
	return self
}
pub fn (mut self Actor) setup() {
	l := net.listen_tcp(self.rpc_port) or {

	println('rpc listening 8099')

	println('rpc listening $self.rpc_port')

					cmd := json.decode(Command, line) or { panic('a') }

					cmd := json.decode(Command, line) or { panic(err) }

					c <- cmd

					self.out <- cmd

		//self.room_state(rooms[0])

		// self.room_state(rooms[0])

import x.json2

import setup
import net
import rpc
import json

	jstr := r'{"$a":2}'
	println('($jstr.len) $jstr')
	wtf := json2.raw_decode(jstr) ?
	println('cli $wtf')

	config := setup.config()
	host := '127.0.0.1:$config.rpc_port'
	println(host)
	if conn := connect(host) {
		a := conn.peer_addr() or { panic(err) }
		println(a)
		irc_add(conn)
		println(conn.read_line())
		println('after')
	} else {
		println('cant connect to $host $err')
	}
}
fn connect(host string) ?net.TcpConn {
	return net.dial_tcp(host)
}
fn irc_add(conn net.TcpConn) {
	mut params := map[string]string{}
	params['host'] = "irc.freenode.net:6667"
	cmd := rpc.Command{
		verb: 'connect'
		params: params
	}
	conn.write(json.encode(cmd).bytes())

pub fn (mut self AppsvcActor) process_request(headers map[string]string, mut reader &io.BufferedReader) {

pub fn (mut self AppsvcActor) process_request(headers map[string]string, mut reader io.BufferedReader) {

	rpc    &rpc.Actor

	rpc_chan := chan rpc.Command{}

		rpc: &rpc.init(rpc_chan, config)

	rpc_chan := chan rpc.Command{}
	go rpc.setup(rpc_chan)

	go main.rpc.setup()

	v -o bin/app src/app.v
	v -o bin/cli src/cli.v

	v -keepc -showcc -o bin/app src/app.v
	v -keepc -showcc -o bin/cli src/cli.v