//! v1 compatibility wrappers
//!
//! This module provides wrappers to support use of v2 implementations with
//! v1 consumers. v2 traits must be explicitly cast to the v1 version using
//! `.into()`, and will panic on internal errors
//!
//! ```
//! extern crate embedded_hal;
//! use embedded_hal::digital::{v1, v2, v1_compat::OldOutputPin};
//!
//! struct NewOutputPinImpl {}
//!
//! impl v2::OutputPin for NewOutputPinImpl {
//!     type Error = ();
//!     fn set_low(&mut self) -> Result<(), Self::Error> { Ok(()) }
//!     fn set_high(&mut self) -> Result<(), Self::Error>{ Ok(()) }
//! }
//!
//! struct OldOutputPinConsumer<T: v1::OutputPin> {
//!     _pin: T,
//! }
//!
//! impl <T>OldOutputPinConsumer<T>
//! where T: v1::OutputPin {
//!     pub fn new(pin: T) -> OldOutputPinConsumer<T> {
//!         OldOutputPinConsumer{ _pin: pin }
//!     }
//! }
//!
//! fn main() {
//!     let pin = NewOutputPinImpl{};
//!     let _consumer: OldOutputPinConsumer<OldOutputPin<_>> = OldOutputPinConsumer::new(pin.into());
//! }
//! ```
//!

#[allow(deprecated)]
use super::v1;
use super::v2;

/// Wrapper to allow fallible `v2::OutputPin` traits to be converted to `v1::OutputPin` traits
pub struct OldOutputPin<T> {
    pin: T,
}

impl<T, E> OldOutputPin<T>
where
    T: v2::OutputPin<Error = E>,
    E: core::fmt::Debug,
{
    /// Create a new OldOutputPin wrapper around a `v2::OutputPin`
    pub fn new(pin: T) -> Self {
        Self { pin }
    }

    /// Fetch a reference to the inner `v2::OutputPin` impl
    #[cfg(test)]
    fn inner(&self) -> &T {
        &self.pin
    }
}

impl<T, E> From<T> for OldOutputPin<T>
where
    T: v2::OutputPin<Error = E>,
    E: core::fmt::Debug,
{
    fn from(pin: T) -> Self {
        OldOutputPin { pin }
    }
}

/// Implementation of `v1::OutputPin` trait for fallible `v2::OutputPin` output pins
/// where errors will panic.
#[allow(deprecated)]
impl<T, E> v1::OutputPin for OldOutputPin<T>
where
    T: v2::OutputPin<Error = E>,
    E: core::fmt::Debug,
{
    fn set_low(&mut self) {
        self.pin.set_low().unwrap()
    }

    fn set_high(&mut self) {
        self.pin.set_high().unwrap()
    }
}

/// Implementation of `v1::StatefulOutputPin` trait for `v2::StatefulOutputPin` fallible pins
/// where errors will panic.
#[cfg(feature = "unproven")]
#[allow(deprecated)]
impl<T, E> v1::StatefulOutputPin for OldOutputPin<T>
where
    T: v2::StatefulOutputPin<Error = E>,
    E: core::fmt::Debug,
{
    fn is_set_low(&self) -> bool {
        self.pin.is_set_low().unwrap()
    }

    fn is_set_high(&self) -> bool {
        self.pin.is_set_high().unwrap()
    }
}

/// Wrapper to allow fallible `v2::InputPin` traits to be converted to `v1::InputPin` traits
/// where errors will panic.
#[cfg(feature = "unproven")]
pub struct OldInputPin<T> {
    pin: T,
}

#[cfg(feature = "unproven")]
impl<T, E> OldInputPin<T>
where
    T: v2::InputPin<Error = E>,
    E: core::fmt::Debug,
{
    /// Create an `OldInputPin` wrapper around a `v2::InputPin`.
    pub fn new(pin: T) -> Self {
        Self { pin }
    }
}

#[cfg(feature = "unproven")]
impl<T, E> From<T> for OldInputPin<T>
where
    T: v2::InputPin<Error = E>,
    E: core::fmt::Debug,
{
    fn from(pin: T) -> Self {
        OldInputPin { pin }
    }
}

/// Implementation of `v1::InputPin` trait for `v2::InputPin` fallible pins
/// where errors will panic.
#[cfg(feature = "unproven")]
#[allow(deprecated)]
impl<T, E> v1::InputPin for OldInputPin<T>
where
    T: v2::InputPin<Error = E>,
    E: core::fmt::Debug,
{
    fn is_low(&self) -> bool {
        self.pin.is_low().unwrap()
    }

    fn is_high(&self) -> bool {
        self.pin.is_high().unwrap()
    }
}

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

    #[allow(deprecated)]
    use crate::digital::v1;
    use crate::digital::v2;

    use crate::digital::v1::OutputPin;

    #[derive(Clone)]
    struct NewOutputPinImpl {
        state: bool,
        res: Result<(), ()>,
    }

    impl v2::OutputPin for NewOutputPinImpl {
        type Error = ();

        fn set_low(&mut self) -> Result<(), Self::Error> {
            self.state = false;
            self.res
        }
        fn set_high(&mut self) -> Result<(), Self::Error> {
            self.state = true;
            self.res
        }
    }

    #[allow(deprecated)]
    struct OldOutputPinConsumer<T: v1::OutputPin> {
        _pin: T,
    }

    #[allow(deprecated)]
    impl<T> OldOutputPinConsumer<T>
    where
        T: v1::OutputPin,
    {
        pub fn new(pin: T) -> OldOutputPinConsumer<T> {
            OldOutputPinConsumer { _pin: pin }
        }
    }

    #[test]
    fn v1_v2_output_explicit() {
        let i = NewOutputPinImpl {
            state: false,
            res: Ok(()),
        };
        let _c: OldOutputPinConsumer<OldOutputPin<_>> = OldOutputPinConsumer::new(i.into());
    }

    #[test]
    fn v1_v2_output_state() {
        let mut o: OldOutputPin<_> = NewOutputPinImpl {
            state: false,
            res: Ok(()),
        }
        .into();

        o.set_high();
        assert_eq!(o.inner().state, true);

        o.set_low();
        assert_eq!(o.inner().state, false);
    }

    #[test]
    #[should_panic]
    fn v1_v2_output_panic() {
        let mut o: OldOutputPin<_> = NewOutputPinImpl {
            state: false,
            res: Err(()),
        }
        .into();

        o.set_high();
    }

    #[cfg(feature = "unproven")]
    use crate::digital::v1::InputPin;

    #[cfg(feature = "unproven")]
    struct NewInputPinImpl {
        state: Result<bool, ()>,
    }

    #[cfg(feature = "unproven")]
    impl v2::InputPin for NewInputPinImpl {
        type Error = ();

        fn is_low(&self) -> Result<bool, Self::Error> {
            self.state.map(|v| v == false)
        }
        fn is_high(&self) -> Result<bool, Self::Error> {
            self.state.map(|v| v == true)
        }
    }

    #[cfg(feature = "unproven")]
    #[allow(deprecated)]
    struct OldInputPinConsumer<T: v1::InputPin> {
        _pin: T,
    }

    #[cfg(feature = "unproven")]
    #[allow(deprecated)]
    impl<T> OldInputPinConsumer<T>
    where
        T: v1::InputPin,
    {
        pub fn new(pin: T) -> OldInputPinConsumer<T> {
            OldInputPinConsumer { _pin: pin }
        }
    }

    #[cfg(feature = "unproven")]
    #[test]
    fn v1_v2_input_explicit() {
        let i = NewInputPinImpl { state: Ok(false) };
        let _c: OldInputPinConsumer<OldInputPin<_>> = OldInputPinConsumer::new(i.into());
    }

    #[cfg(feature = "unproven")]
    #[test]
    fn v1_v2_input_state() {
        let i: OldInputPin<_> = NewInputPinImpl { state: Ok(false) }.into();

        assert_eq!(i.is_low(), true);
        assert_eq!(i.is_high(), false);
    }

    #[cfg(feature = "unproven")]
    #[test]
    #[should_panic]
    fn v1_v2_input_panic() {
        let i: OldInputPin<_> = NewInputPinImpl { state: Err(()) }.into();

        i.is_low();
    }
}