use bytes::BytesMut;
use futures::Future; // 0.1.28
use futures::future::ok;
use tokio;
use tokio::codec::{Framed, Encoder, Decoder};
use tokio::net::TcpStream;

use std::io::Error;
use std::thread;

/// Exonum message
pub struct SignedMessage;

// Exonum handshake return type (no generic param)
type HandshakeResult =
    Box<dyn Future<Item = (Framed<TcpStream, MessageCodec>, Vec<u8>), Error = failure::Error>>;

// Exonum handshake trait (no generic params and self by uniq alias)
pub trait Handshake {
    fn listen(&mut self, stream: TcpStream) -> HandshakeResult;
    fn send(&mut self, stream: TcpStream) -> HandshakeResult;
}

/// Exonum's noise handshake
pub struct NoiseHandshake;

impl Handshake for NoiseHandshake {
    #[allow(unreachable_code, unused_variables)]
    fn listen(&mut self, stream: TcpStream) -> HandshakeResult {
        let connect_msg = unimplemented!("Same as original impl");
        // Build generic codec using results of noise handshake
        let noise_codec = MessageCodec { codec_impl: Box::new(NoiseCodec {}) };
        Box::new(ok((Framed::new(stream, noise_codec), connect_msg)))
    }

    #[allow(unreachable_code, unused_variables)]
    fn send(&mut self, stream: TcpStream) -> HandshakeResult {
        let connect_msg = unimplemented!("Same as original impl");
        // Build generic codec using results of noise handshake
        let noise_codec = MessageCodec { codec_impl: Box::new(NoiseCodec {}) };
        Box::new(ok((Framed::new(stream, noise_codec), connect_msg)))
    }
}

/// Plain handshake
pub struct PlainHandshake;

impl Handshake for PlainHandshake {
    #[allow(unreachable_code, unused_variables)]
    fn listen(&mut self, stream: TcpStream) -> HandshakeResult {
        let connect_msg = unimplemented!("Receive Connect message");
        unimplemented!("Send connect message");
        // Build generic codec using plain codec
        let plain_codec = MessageCodec { codec_impl: Box::new(PlainCodec {}) };
        Box::new(ok((Framed::new(stream, plain_codec), connect_msg)))
    }

    #[allow(unreachable_code, unused_variables)]
    fn send(&mut self, stream: TcpStream) -> HandshakeResult {
        unimplemented!("Send Connect message");
        let connect_msg = unimplemented!("Receive connect message");
        // Build generic codec using plain codec
        let plain_codec = MessageCodec { codec_impl: Box::new(PlainCodec {}) };
        Box::new(ok((Framed::new(stream, plain_codec), connect_msg)))
    }
}

/// Same as `Encoder + Decoder`, but with explicitly specified associated types.
pub trait Codec {
    fn encode(&mut self, msg: SignedMessage, buf: &mut BytesMut) -> Result<(), Error>;
    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Vec<u8>>, Error>;
}

/// Conrete codec for Noise. Same as existing exonum `MessageCodec`.
pub struct NoiseCodec;

impl Codec for NoiseCodec {
    fn encode(&mut self, _msg: SignedMessage, _buf: &mut BytesMut) -> Result<(), Error> {
        unimplemented!("Same as original impl of Encode for MessageCodec")
    }
    fn decode(&mut self, _buf: &mut BytesMut) -> Result<Option<Vec<u8>>, Error> {
        unimplemented!("Same as original impl of Decode for MessageCodec")
    }
}

/// Concrete codec for a cannel with disabled Noise.
pub struct PlainCodec;

impl Codec for PlainCodec {
    fn encode(&mut self, _msg: SignedMessage, _buf: &mut BytesMut) -> Result<(), Error> {
        unimplemented!(
            "Same as original impl of Encode for MessageCodec, \
            but without self.session.encrypt_msg")
    }
    fn decode(&mut self, _buf: &mut BytesMut) -> Result<Option<Vec<u8>>, Error> {
        unimplemented!(
            "Same as original impl of Decode for MessageCodec, \
            but without self.session.decrypt_msg")
    }
}

/// Dynamically parametrized codec that will actually be used for communication.
pub struct MessageCodec {
    codec_impl: Box<Codec + 'static>,
}

impl Decoder for MessageCodec {
    type Item = Vec<u8>;
    type Error = Error;
    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        self.codec_impl.decode(buf)
    }
}

impl Encoder for MessageCodec {
    type Item = SignedMessage;
    type Error = Error;
    fn encode(&mut self, msg: Self::Item, buf: &mut BytesMut) -> Result<(), Self::Error> {
        self.codec_impl.encode(msg, buf)
    }
}

#[allow(unreachable_code, unused_variables)]
pub fn handshake() {
    let (initiator, receiver): (TcpStream, TcpStream) = unimplemented!();

    thread::spawn(move || {
        let mut handshake: Box<dyn Handshake> = Box::new(NoiseHandshake {});
        let (stream, connect_message) = handshake.listen(initiator).wait().unwrap();
    });

    thread::spawn(move || {
        let mut handshake: Box<dyn Handshake> = Box::new(NoiseHandshake {});
        let (stream, connect_message) = handshake.send(receiver).wait().unwrap();
    });
}

fn main() {}