use bevy::prelude::*;

extern crate vrpn;
extern crate bytes;

// extern crate tokio;

use bytes::Bytes;
use std::net::{SocketAddr, TcpStream};
use vrpn::{
    constants::MAGIC_DATA,
    cookie::check_ver_nonfile_compatible,
    handler::{HandlerCode, TypedHandler},
    sync_io::{read_cookie, write_cookie, EndpointSyncTcp},
    tracker::PoseReport,
    CookieData, Message, Result, TypeDispatcher, Unbuffer,
};

#[derive(Component)]
pub struct Tracker {
    // stream: ConnectionIpStream,
    // connection: Arc<ConnectionIp>
}

#[derive(Debug)]
struct TrackerHandler {}

impl TypedHandler for TrackerHandler {
    type Item = PoseReport;
    fn handle_typed(&mut self, msg: &Message<PoseReport>) -> Result<HandlerCode> {
        info!("{:?}\n   {:?}", msg.header, msg.body);
        Ok(HandlerCode::ContinueProcessing)
    }
}

impl Tracker {
    pub fn from_info(server_ip: &str, port: u16) -> Result<()> {
        // let server = format!("tcp://{}:{}", server_ip, port)
        //     .parse::<ServerInfo>()
        //     .unwrap();

        // let connection = ConnectionIp::new_client(server, None, None).expect("msg");

        // let sender = connection
        //     .register_sender(StaticSenderName(b"Tracker0"))
        //     .expect("should be able to register sender");

        // let ping_client = ping::Client::new(sender, Arc::clone(&connection))
        //     .expect("should be able to create ping client");


        let addr: SocketAddr = "127.0.0.1:3883".parse().unwrap();
        let mut stream = TcpStream::connect(addr)?;
        stream.set_nodelay(true)?;
    
        // We first write our cookie, then read and check the server's cookie, before the loop.
        write_cookie(&mut stream, CookieData::from(MAGIC_DATA))?;
        let cookie_buf = read_cookie(&mut stream)?;
        let mut cookie_buf = Bytes::from(&cookie_buf[..]);
    
        // CookieData::unbuffer_ref(&mut cookie_buf)
        //     .and_then(|msg| check_ver_nonfile_compatible(msg.version))?;
    
        let mut endpoint = EndpointSyncTcp::new(stream);
        let mut dispatcher = TypeDispatcher::new();
        let _ = dispatcher.add_typed_handler(Box::new(TrackerHandler {}), None)?;

        // Ok(Self {
        //     // stream: ConnectionIpStream::new(Arc::clone(&connection)),
        //     // connection
        // })
    }


}

pub fn setup_tracker(mut commands: Commands)
{
    commands.spawn(Tracker::from_info("127.0.0.1",3883));

}

pub fn update_tracker(mut query:Query<&mut Tracker>)
{
    for mut tracker in query.iter_mut() {

        // tracker.connection.poll_endpoints();
        // tracker
    }
}