use alloc::vec::Vec;
use core::convert::Infallible;
use embedded_hal::i2c::I2c;
use esp_hal::time::{Duration, Instant};
use log::{error, info};
use pn532::i2c::I2CInterface;
use pn532::requests::SAMMode;
use pn532::{nb, Pn532, Request};

/// Timer implementation required by `pn532::CountDown`.
pub struct TimerWrapper {
    start: Instant,
    duration: Duration,
    counter: u32,
}

impl TimerWrapper {
    pub fn new() -> Self {
        Self {
            start: Instant::now(),
            duration: Duration::ZERO,
            counter: 0,
        }
    }
}

impl Default for TimerWrapper {
    fn default() -> Self {
        Self::new()
    }
}

impl pn532::CountDown for TimerWrapper {
    type Time = Duration;

    fn start<T>(&mut self, timeout: T)
    where
        T: Into<Self::Time>,
    {
        self.start = Instant::now();
        self.duration = timeout.into();
        self.counter = 0;
    }

    fn wait(&mut self) -> nb::Result<(), Infallible> {
        let elapsed = self.start.elapsed();
        self.counter += 1;
        if elapsed >= self.duration {
            Ok(())
        } else {
            Err(nb::Error::WouldBlock)
        }
    }
}

pub type Pn532Device<I2C> = Pn532<I2CInterface<I2C>, (), 32>;

/// PN532 NFC reader driver.
pub struct NfcPn532Driver<I2C>
where
    I2C: I2c,
{
    pn532: Pn532Device<I2C>,
}

impl<I2C> NfcPn532Driver<I2C>
where
    I2C: I2c,
{
    pub fn new(i2c: I2C) -> Self {
        let pn532 = Pn532::new_async(I2CInterface { i2c });
        Self { pn532 }
    }

    pub async fn configure_sam(&mut self) -> Result<(), ()> {
        if let Err(e) = self.pn532.process_async(
            &Request::sam_configuration(SAMMode::Normal, false),
            0,
        ).await {
            error!("PN532 SAM configuration failed over I2C: {e:?}");
            Err(())
        } else {
            info!("PN532 SAM configuration successful on shared I2C bus");
            Ok(())
        }
    }

    pub async fn poll_target(&mut self) -> Result<(), ()> {
        match self.pn532.process_async(&Request::INLIST_ONE_ISO_A_TARGET, 23).await {
            Ok(uid) => {
                info!("PN532 detected NFC target UID: {uid:?}");
                Ok(())
            }
            Err(e) => {
                info!("No NFC card found on shared I2C bus: {e:?}");
                Err(())
            }
        }
    }

    pub fn parse_nfc_page(iteration: u8, bytes: &[u8]) -> Result<[u8; 4], ()> {
        let success = bytes.first().is_some_and(|x| *x == 0);
        if success {
            let mut arr = [0; 4];
            arr.copy_from_slice(&bytes[1..5]);
            Ok(arr)
        } else {
            info!("err  {iteration}: {:02x?}", bytes);
            Err(())
        }
    }

    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
        if let Err(e) = self.poll_target().await {
            error!("PN532 I2C target poll failed before reading card data: {e:?}");
            return Err(e);
        }

        let mut data: Vec<u8> = Vec::with_capacity(858);

        for i in 0x0B..=230 {
            let mut parse_result = Err(());
            while parse_result.is_err() {
                let Ok(result) = self.pn532.process_async(&Request::ntag_read(i), 17).await else {
                    continue;
                };
                parse_result = Self::parse_nfc_page(i, result);
            }
            let bytes = parse_result.unwrap();
            let bytes = if i == 0x0B {
                &bytes[1..]
            } else {
                &bytes
            };
            data.extend(bytes);
        }

        info!("PN532 full card payload read over I2C: {:02x?}", data);
        Ok(data)
    }
    
    pub fn device_mut(&mut self) -> &mut Pn532Device<I2C> {
        &mut self.pn532
    }
}