use crate::{endpoint::Endpoint, event::InternalEvent};
use async_trait::async_trait;
use tokio::sync::{mpsc,oneshot,Mutex};
use std::sync::Arc;
use eyre::Result;
use crate::event::{EventKind,Event, EventResponse};

pub struct IrcEndpoint {
}

impl IrcEndpoint {
    fn new() -> Result<Self> {
        Ok( IrcEndpoint {
        })
    }
}

#[async_trait]
impl Endpoint for IrcEndpoint {
    fn name(&self) -> String {
        "test irc_endpoint".into()
    }

    fn is_active(&self) -> bool {
        true
    }

    async fn listen(self: Arc<Self>, event_sink_sender: oneshot::Sender<Result<mpsc::Sender<Event>>>,
    event_handler: mpsc::Sender<Event>) {
        //TODO find apropiate defeault or size
        let (s,r) = mpsc::channel(64);
        event_sink_sender.send(Ok(s));


        loop {
            let (event_response_send, event_response_recv) = oneshot::channel();
            event_handler.send(
                Event {
                    kind: EventKind::Internal(InternalEvent::Test),
                    result_sender: event_response_send,
                }).await;

            //TODO don't unwrap
            match event_response_recv.await.unwrap() {
                EventResponse::Success => {},
                _ => {},
            };
        }

    }
}