extern crate futures; // 0.1.21

use futures::{Async, AsyncSink, Poll, Stream, Sink, StartSend, IntoFuture};
use futures::sync::mpsc::{Receiver, UnboundedSender};

struct Frame;
struct Event;
struct MyCodec;

struct Handler<S> {
    stream: S,
    tx: UnboundedSender<Event>,
    rx: Receiver<Frame>,
}

impl Stream for MyCodec {
    type Item = Frame;
    type Error = ();

    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
        Ok(Async::Ready(None))
    }
}

impl Sink for MyCodec {
    type SinkItem = Option<Frame>;
    type SinkError = ();

    fn start_send(&mut self, item: Self::SinkItem) -> StartSend<Self::SinkItem, Self::SinkError> {
        Ok(AsyncSink::Ready)
    }

    fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
        Ok(Async::Ready(()))
    }

    fn close(&mut self) -> Poll<(), Self::SinkError> {
        self.poll_complete()
    }
}

impl<S: Stream> IntoFuture for Handler<S> {
    type Future = (); // What would this be?
    type Item = ();
    type Error = ();

    fn into_future(self) -> <Self as IntoFuture>::Future {
        let Handler {
            stream, tx, rx,
        } = self;

        let codec = MyCodec::new(stream);
        let (writer, reader) = codec.split();

        reader
            .map(|frame| {
                // handle frame
                None
            })
            .select(
                rx.map_err(|_err| ()).map(|frame| Some(frame))
            )
            .forward(writer)
            .map_err(|_err| ())
    }
}