use embedded_hal::delay::DelayNs;
use embedded_hal::digital::{InputPin, OutputPin};
use crate::{Error, Interface, Pn532};
use crate::types::felica::{CardSession, FelicaLiteSBlock};
use crate::types::felica::felica_lite_s::auth::{AuthSession, CardKey, CardKeyVersion};
use crate::types::felica::felica_lite_s::config::MemoryConfig;

impl<RST, IRQ, DELAY, B, const N: usize> Pn532<RST, IRQ, DELAY, B, N>
where
    RST: OutputPin,
    IRQ: InputPin,
    DELAY: DelayNs,
    B: Interface<RST, IRQ, DELAY>
{
    pub fn set_id(&mut self, card: &CardSession, arbitrary: [u8; 6], dfc: Option<[u8; 2]>) -> Result<(), Error<B::TransportError>> {
        let dfc = dfc.unwrap_or_default();
        let mut block = [0u8; 16];
        block[8] = dfc[0];
        block[9] = dfc[1];
        block[10..16].copy_from_slice(&arbitrary);
        self.write_block(
            card,
            &[FelicaLiteSBlock::ID],
            &[block]
        )
    }
    
    pub fn get_id(&mut self, card: &CardSession) -> Result<[u8; 16], Error<B::TransportError>> {
        let mut block = [[0u8; 16]];
        self.read_block(
            card,
            &[FelicaLiteSBlock::ID],
            &mut block
        )?;
        crate::trace!("ID block: {:02X}", block);
        Ok(block[0])
    }
    
    pub fn set_ck(&mut self, card: &CardSession, key: &CardKey) -> Result<(), Error<B::TransportError>> {
        self.write_block(
            card,
            &[FelicaLiteSBlock::CK],
            &[**key]
        )
    }
    
    pub fn set_ck_with_mac(&mut self, card: &CardSession, session: &AuthSession, key: &CardKey) -> Result<(), Error<B::TransportError>> {
        self.write_with_mac(
            card,
            session,
            FelicaLiteSBlock::CK,
            &**key
        )
    }
    
    pub fn set_ckv(&mut self, card: &CardSession, version: &CardKeyVersion) -> Result<(), Error<B::TransportError>> {
        self.write_block(
            card,
            &[FelicaLiteSBlock::CKV],
            &[version.as_block()]
        )
    }

    pub fn set_ckv_with_mac(&mut self, card: &CardSession, session: &AuthSession, version: &CardKeyVersion) -> Result<(), Error<B::TransportError>> {
        self.write_with_mac(
            card,
            session,
            FelicaLiteSBlock::CKV,
            &version.as_block()
        )
    }
    
    pub fn get_ckv(&mut self, card: &CardSession) -> Result<CardKeyVersion, Error<B::TransportError>> {
        let mut block = [[0u8; 16]];
        self.read_block(
            card,
            &[FelicaLiteSBlock::CKV],
            &mut block
        )?;
        crate::trace!("CKV block: {:02X}", block);
        Ok(CardKeyVersion::from(block[0]))
    }
    
    pub fn get_mc(&mut self, card: &CardSession) -> Result<MemoryConfig, Error<B::TransportError>> {
        let mut block = [[0u8; 16]];
        self.read_block(
            card,
            &[FelicaLiteSBlock::MemoryConfig],
            &mut block
        )?;
        crate::trace!("MC block: {:02X}", block[0]);
        Ok(MemoryConfig::from(block[0]))
    }
    
    pub fn set_mc(&mut self, card: &CardSession, config: MemoryConfig) -> Result<(), Error<B::TransportError>> {
        let block: [u8; 16] = config.into();
        self.write_block(
            card,
            &[FelicaLiteSBlock::MemoryConfig],
            &[block]
        )
    }
}