use bevy::prelude::*;

extern crate bytes;
extern crate vrpn;

// use futures_lite::future;
use rand::Rng;
use std::time::{Duration, Instant};

use bytes::{Bytes, BytesMut};
use std::{
    io::{self, Read},
    net::{SocketAddr, TcpStream},
};

use std::sync::mpsc::{Receiver,channel};

use vrpn::{
    codec::peek_u32,
    constants::MAGIC_DATA,
    cookie::check_ver_nonfile_compatible,
    handler::{HandlerCode, TypedHandler},
    message::MessageSize,
    sync_io::{read_cookie, write_cookie, EndpointSyncTcp},
    tracker::PoseReport,
    unbuffer, CookieData, Message, Result, SequencedGenericMessage, TypeDispatcher, Unbuffer, TypedBodylessHandler,
};


struct TrackerProxy;


#[derive(Resource,Debug)]
struct Tracker;

impl Tracker {

    pub fn start_tracker(&self) {

        std::thread::spawn(move || {

            let (sender, receiver): (_, Receiver<PoseReport>) = channel();


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

            
            // setup a channel
            // let (tx, rx) = mpsc::channel();
    
            loop {
    
                // vrpn implementation is rather verbose - we need to see what specific errors 
                // should be handled properly!
                endpoint.poll_endpoint(&mut dispatcher).unwrap_or_else(|err| {
                    info!("error from tracker thread {:?}",err);
                })
    
                // dispatcher.han
    
            }
        });

        


    }
    
}

// impl TypedBodylessHandler for Tracker {
//     type Item = PoseReport;
//     fn handle_typed_bodyless(&mut self, header: &vrpn::MessageHeader) -> Result<HandlerCode> {

//         Ok(HandlerCode::ContinueProcessing)
//     }
// }

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

impl FromWorld for Tracker {
    fn from_world(world: &mut World) -> Self {
        Self {} 
    }
}























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

pub fn setup_threaded_tracker(mut commands: Commands) {
    // let (tx, rx) = bounded::<u32>(10);
    std::thread::spawn(move || {
        let addr: SocketAddr = "127.0.0.1:3883".parse().unwrap();
        let mut stream = TcpStream::connect(addr).unwrap();
        stream.set_nodelay(true).unwrap();

        // We first write our cookie, then read and check the server's cookie, before the loop.
        write_cookie(&mut stream, CookieData::from(MAGIC_DATA)).unwrap();
        let cookie_buf = read_cookie(&mut stream).unwrap();
        let mut cookie_buf = Bytes::from(&cookie_buf[..]);

        CookieData::unbuffer_ref(&mut cookie_buf)
            .and_then(|msg| check_ver_nonfile_compatible(msg.version)).unwrap();

        let mut endpoint = EndpointSyncTcp::new(stream);
        let mut dispatcher = TypeDispatcher::new();

        let _ = dispatcher.add_typed_handler(Box::new(TrackerHandler {}), None).unwrap();

        
        // setup a channel
        // let (tx, rx) = mpsc::channel();

        loop {

            // vrpn implementation is rather verbose - we need to see what specific errors 
            // should be handled properly!
            endpoint.poll_endpoint(&mut dispatcher).unwrap_or_else(|err| {
                info!("error from tracker thread {:?}",err);
            })

            // dispatcher.han

        }
    });
}