use test::{JRPCServer,Result,Test};
use test::server::{TestService,TestServiceHandler};
use std::io::{BufReader,BufRead,Write};
use std::sync::mpsc::channel;

#[derive(Clone, Copy)]
struct MyCtx {}

struct TestServiceImplementation {}

impl TestService<MyCtx> for TestServiceImplementation {
   fn GetTest(&self, name: String, age: i64, _context: &MyCtx) -> Result<Test> {
      return Ok(Test { name, age });
   }

   fn TestNot(&self, _: &MyCtx) -> Result<()> {
      return Ok(());
   }
}

pub fn main() {
   let mut srv = JRPCServer::<MyCtx>::new();
   srv.add_service(TestServiceHandler::new(Box::from(TestServiceImplementation {})));

   let listener = std::net::TcpListener::bind("127.0.0.1:4321").expect("Could not start listener!");

   for stream in listener.incoming() {
      println!("Got Connection!");
      let (stx, srx) = channel::<String>();
      let (rtx, rrx) = channel::<String>();

      let mut stream = stream.expect("Bad stream");
      let mut r = BufReader::new(stream.try_clone().unwrap());
      let mut line = String::new();

      srv.start_session(srx, rtx, MyCtx {});


      r.read_line(&mut line).expect("Could not read line!");
      println!("Got line: {}", line);
      stx.send(line).expect("Could not send packet to handler!");
      println!("Sending to handler succeeded");
      let response = rrx.recv().expect("Could not get reponse from handler!");
      println!("Prepared response {}", response);
      
      stream.write((response + "\n").as_bytes()).expect("Could not send reponse!");
   }

   println!("Hello World");

   // return Ok(());
}