use log::info;
use tokio::sync::mpsc::{channel, Receiver, Sender};

use crate::events::{ActorMessage};
use crate::BoxError;
use futures_util::stream::TryStreamExt;
use futures_util::StreamExt;

use std::net::SocketAddr;

use tokio::net::{TcpListener, TcpStream};
use tokio_tungstenite::accept_async;

#[derive(Debug)]
pub struct FrontendManager {
    receiver: Receiver<ActorMessage>,
}

impl FrontendManager {
    pub fn new(receiver: Receiver<ActorMessage>) -> Self {
        Self { receiver }
    }

    async fn handle_ws_connection(stream: TcpStream, addr: SocketAddr) -> Result<(), BoxError> {
        let websocket = accept_async(stream).await?;
        info!("Received WebSocket connection <{:?}>", addr);

        let (_, ws_in) = websocket.split();

        let on_received = ws_in.try_for_each(move |msg| {
            info!(
                "Received a message from {:?}: {}",
                addr,
                msg.to_text().unwrap()
            );

            futures_util::future::ok(())
        });

        tokio::spawn(on_received);

        Ok(())
    }

    pub async fn websocket() -> Result<(), BoxError> {
        let server = TcpListener::bind("127.0.0.1:3012").await?;

        while let Ok((stream, addr)) = server.accept().await {
            tokio::spawn(FrontendManager::handle_ws_connection(stream, addr));
        }

        Ok(())
    }

    pub async fn handle_message(&mut self, message: ActorMessage) -> Result<(), BoxError> {
        match message.message {
            _ => {}
        }

        Ok(message
            .respond_to
            .send((None, None))
            .map_err(|_| BoxError::from("Could not send message."))?)
    }
}

pub struct FrontendManagerHandle {
    sender: Sender<ActorMessage>,
}

impl FrontendManagerHandle {
    // async fn run_frontend_manager(mut manager: FrontendManager) {
    //     info!("Frontend handler ready");
    //
    //     while let Some(msg) = manager.receiver.recv().await {
    //         manager.handle_message(msg).await.unwrap();
    //     }
    // }

    pub fn new() -> Self {
        let (sender, receiver) = channel(1);

        let _frontend = FrontendManager::new(receiver);

        tokio::spawn(FrontendManager::websocket());
        // tokio::spawn(FrontendManagerHandle::run_frontend_manager(frontend));

        Self { sender }
    }
}