use std::thread::yield_now;

use bevy_ecs::system::Resource;
//use crossbeam::channel::{unbounded, Receiver, Sender};
use crate::networking::websocket::Websocket;
use futures::{
    channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender},
    SinkExt,
};
use starkingdoms_common::packet::{ClientLoginPacket, Packet};
use wasm_bindgen::{prelude::Closure, JsCast, JsValue};
use wasm_bindgen_futures::spawn_local;
use web_sys::{MessageEvent, WebSocket};

const PORT: u16 = 3000;

#[derive(Debug)]
pub struct Socket(WebSocket);
unsafe impl Send for Socket {}
unsafe impl Sync for Socket {}

#[derive(Resource, Debug)]
pub struct Ws {
    socket: Socket,
    pub sender: UnboundedSender<Packet>,
    pub receiver: UnboundedReceiver<Packet>,
    packet_receiver: UnboundedReceiver<Packet>,
}

impl Websocket for Ws {
    fn new() -> Self {
        let window = web_sys::window().unwrap();
        /*let ws = WebSocket::new(&format!(
            "ws://{}:{}",
            window.location().hostname().unwrap(),
            PORT
        ))*/
        let ws = WebSocket::new("ws://localhost:3000").expect("Couldn't connect to server");
        let (packet_sender, receiver) = unbounded();
        //let packet_sender = Rc::new(RwLock::new(packet_sender));
        let (sender, packet_receiver) = unbounded();

        let ws_clone = ws.clone();
        let onopen_callback = Closure::<dyn FnMut()>::new(move || {
            let packet = Packet::ClientLogin(ClientLoginPacket {
                username: String::new(),
                save: None,
                jwt: None,
            });

            ws_clone
                .send_with_str(
                    &serde_json::to_string(&packet).expect("Couldn't convert packet to string"),
                )
                .expect("Failed to send packet");
        });
        ws.set_onopen(Some(onopen_callback.as_ref().unchecked_ref()));
        onopen_callback.forget();
        let onmessage_callback = Closure::<dyn FnMut(_)>::new(move |e: MessageEvent| {
            //tracing::error!("{}", ws.ready_state());
            let data = e
                .data()
                .as_string()
                .expect("Expected string, found some other type");
            let data: Packet =
                serde_json::from_str(&data).expect("Received invalid json from server");
            let mut sender_clone = packet_sender.clone();
            spawn_local(async move {
                sender_clone
                    .send(data)
                    .await
                    .expect("Couldn't transmit packet to client");
            });
        });
        ws.set_onmessage(Some(onmessage_callback.as_ref().unchecked_ref()));
        onmessage_callback.forget();
        Ws {
            socket: Socket(ws),
            sender,
            receiver,
            packet_receiver,
        }
    }
    fn send_packet(&mut self, packet: Packet) {
        let socket = self.socket.0.clone();
        spawn_local(async move {
            //while socket.ready_state() != 1 {  }
            socket
                .send_with_str(
                    &serde_json::to_string(&packet).expect("Couldn't convert packet to json"),
                )
                .expect("Couldn't send packet to server");
        });
    }
}