use bytes::Buf;
use bytes::BytesMut;
use std::io;
use tokio_util::codec::Decoder;
use tokio_util::codec::Encoder;

use crate::protocol::ethernet::{self};

/******************************************************************************
 * Decoder/Encoder
 ******************************************************************************/

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
pub struct EthCodec<C>(C);

impl<C> EthCodec<C> {
    pub fn new(c: C) -> Self {
        EthCodec(c)
    }
}

impl<C> Decoder for EthCodec<C>
where
    C: Decoder,
    std::io::Error: From<<C as Decoder>::Error>,
{
    type Item = C::Item;
    type Error = io::Error;

    fn decode(&mut self, data: &mut BytesMut) -> Result<Option<Self::Item>, io::Error> {
        println!("EthCodec -> decode(), handle data len: {}", data.len());

        if data.len() < 14 {
            println!("EthCodec decode: no enough data");
            return Ok(None);
        } else {
            let parsed_eth_frame = ethernet::parse_ethernet(data);
            if let Ok((eth_payload, eth_header)) = parsed_eth_frame {
                println!("{:?}, Payload: {}", eth_header, eth_payload.len());

                // Skip the 14-byte length.
                data.advance(14);

                /*
                match proto {
                    IPv4 => ipv4.decoder();
                    IPv6 => IPv6.decoder();
                }
                */

                let decoded = self.0.decode(data)?;
                match decoded {
                    None => {
                        return Err(std::io::Error::new(
                            std::io::ErrorKind::InvalidData,
                            format!("xxxxxx."),
                        ));
                    }
                    Some(inner) => Ok(Some(inner)),
                }
            } else {
                return Err(std::io::Error::new(
                    std::io::ErrorKind::InvalidData,
                    format!("Invalid ethernet frame"),
                ));
            }
        }
    }
}

impl<C, T> Encoder<T> for EthCodec<C>
where
    C: Encoder<T>,
    std::io::Error: From<C::Error>,
{
    type Error = io::Error;

    fn encode(&mut self, _item: T, _buf: &mut BytesMut) -> Result<(), io::Error> {
        // TODO
        Ok(())
    }
}