Rircd/src/irc_endpoint.rs

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_state_handler_sender: oneshot::Sender<Result<mpsc::Sender<Event>>>,
    event_handler: mpsc::Sender<Event>) {
        //TODO find apropiate defeault or size
        let (event_sender,event_receiver) = mpsc::channel(64);

        let (event_response_send, event_response_recv) = oneshot::channel();
        event_state_handler_sender.send(Ok(event_sender));
        event_handler.send(
            Event {
                kind: EventKind::Internal(InternalEvent::Test),
                result_sender: event_response_send,
                sender_name: self.name(),
            }).await;

        return;

        loop {
            //TODO impl
            break;
            //tokio::select! {
            //    //socket.recv().parse_ircshit();
            //};
            //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 => {},
            //    _ => {},
            //};
        }

    }
}