use crate::frame::FrameError;
use crate::interface::can::CanError;
#[cfg(feature = "std")]
use crate::interface::serial::SerialError;
use crate::interface::usart::UsartError;
use crate::packet::Packet;
use crate::packet::PacketBuilderError;

pub mod can;
#[cfg(feature = "std")]
pub mod serial;
pub mod usart;

#[derive(Debug)]
pub enum InterfaceError {
    CanError(CanError),
    UsartError(UsartError),
    #[cfg(feature = "std")]
    SerialError(SerialError),
    BuilderError(PacketBuilderError),
    FrameError(FrameError),
    NoPacketReceived,
}

pub trait Interface {
    fn try_get_packet(&mut self) -> Result<Packet, InterfaceError>;
    fn try_send_packet(&mut self, packet: &Packet) -> Result<(), InterfaceError>;
}

#[cfg(feature = "test")]
pub mod test {
    use alloc::vec::Vec;

    use crate::packet::Packet;
    use crate::interface::{Interface, InterfaceError};

    pub struct InterfaceMock {
        expected_packets: Vec<Packet>,
        queued_packets: Vec<Packet>,
    }

    impl InterfaceMock {
        pub fn new(expected_packets: Vec<Packet>, queued_packets: Vec<Packet>) -> Self {
            Self {
                expected_packets,
                queued_packets,
            }
        }
    }

    impl Interface for InterfaceMock {
        fn try_get_packet(&mut self) -> Result<Packet, InterfaceError> {
            let result = match self.queued_packets.first() {
                Some(packet) => {
                    Ok(packet.clone())
                },
                None => panic!("Expected a packet"),
            };

            self.queued_packets.drain(0..1);

            result
        }
    
        fn try_send_packet(&mut self, packet: &Packet) -> Result<(), InterfaceError> {
            match self.expected_packets.first() {
                Some(expected_packet) => {
                    assert_eq!(expected_packet.is_error, packet.is_error);
                    assert_eq!(expected_packet.device_address, packet.device_address);
                    assert_eq!(expected_packet.data, packet.data);
                },
                None => panic!("Unexpected packet: {:?}", packet),
            }

            self.expected_packets.drain(0..1);

            Ok(())
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        use alloc::vec;
        
        #[test]
        #[should_panic(expected = "Expected a packet")]
        fn interface_mock_try_get_packet_expected_packet_test() {
            let mut can_mock = InterfaceMock::new(
                vec![],
                vec![]);

            can_mock.try_get_packet().unwrap();
        }

        #[test]
        fn interface_mock_try_get_packet_queued_packets_test() {
            let mut can_mock = InterfaceMock::new(
                vec![],
                vec![
                    Packet {
                        is_error: true,
                        device_address: 0x1111,
                        data: vec![0x11, 0x11, 0x11],
                    },
                    Packet {
                        is_error: false,
                        device_address: 0x2222,
                        data: vec![0x22, 0x22, 0x22],
                    },
                    Packet {
                        is_error: true,
                        device_address: 0x3333,
                        data: vec![0x33, 0x33, 0x33],
                    },
                ],
            );

            let first_packet = can_mock.try_get_packet().unwrap();
            let second_packet = can_mock.try_get_packet().unwrap();
            let third_packet = can_mock.try_get_packet().unwrap();

            assert_eq!(first_packet.is_error, true);
            assert_eq!(first_packet.device_address, 0x1111);
            assert_eq!(first_packet.data, vec![0x11, 0x11, 0x11]);

            assert_eq!(second_packet.is_error, false);
            assert_eq!(second_packet.device_address, 0x2222);
            assert_eq!(second_packet.data, vec![0x22, 0x22, 0x22]);

            assert_eq!(third_packet.is_error, true);
            assert_eq!(third_packet.device_address, 0x3333);
            assert_eq!(third_packet.data, vec![0x33, 0x33, 0x33]);
        }
    
        #[test]
        #[should_panic(expected = "Unexpected packet: ")]
        fn interface_mock_try_send_packet_unexpected_packet_test() {
            let mut can_mock = InterfaceMock::new(
                vec![],
                vec![]);

            can_mock.try_send_packet(&Packet {
                is_error: true,
                device_address: 0x1111,
                data: vec![0x11, 0x11, 0x11],
            }).unwrap();
        }

        #[test]
        fn interface_mock_try_send_packet_expected_packets_test() {
            let mut can_mock = InterfaceMock::new(
                vec![
                    Packet {
                        is_error: true,
                        device_address: 0x1111,
                        data: vec![0x11, 0x11, 0x11],
                    },
                    Packet {
                        is_error: false,
                        device_address: 0x2222,
                        data: vec![0x22, 0x22, 0x22],
                    },
                    Packet {
                        is_error: true,
                        device_address: 0x3333,
                        data: vec![0x33, 0x33, 0x33],
                    },
                ],
                vec![],
            );

            can_mock.try_send_packet(&Packet {
                    is_error: true,
                    device_address: 0x1111,
                    data: vec![0x11, 0x11, 0x11],
            }).unwrap();
            can_mock.try_send_packet(&Packet {
                    is_error: false,
                    device_address: 0x2222,
                    data: vec![0x22, 0x22, 0x22],
            }).unwrap();
            can_mock.try_send_packet(&Packet {
                    is_error: true,
                    device_address: 0x3333,
                    data: vec![0x33, 0x33, 0x33],
            }).unwrap();
        }
    }
}