use generic_array::{ArrayLength, GenericArray};
use zeroize::{Zeroize, ZeroizeOnDrop};


/// Fig 16 on page 34
#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub(crate) struct SlhDsaSig<
    A: ArrayLength,
    D: ArrayLength,
    HP: ArrayLength,
    K: ArrayLength,
    LEN: ArrayLength,
    N: ArrayLength,
> {
    pub(crate) randomness: GenericArray<u8, N>,
    pub(crate) fors_sig: ForsSig<A, K, N>,
    pub(crate) ht_sig: HtSig<D, HP, LEN, N>,
}


#[derive(Clone, Default, Zeroize, ZeroizeOnDrop)]
pub struct SlhPublicKey<N: ArrayLength> {
    pub(crate) pk_seed: GenericArray<u8, N>,
    pub(crate) pk_root: GenericArray<u8, N>,
}


#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub struct SlhPrivateKey<N: ArrayLength> {
    pub(crate) sk_seed: GenericArray<u8, N>,
    pub(crate) sk_prf: GenericArray<u8, N>,
    pub(crate) pk_seed: GenericArray<u8, N>,
    pub(crate) pk_root: GenericArray<u8, N>,
}


/// Fig 13 on page 29
#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub(crate) struct ForsSig<A: ArrayLength, K: ArrayLength, N: ArrayLength> {
    pub(crate) private_key_value: GenericArray<GenericArray<u8, N>, K>,
    pub(crate) auth: GenericArray<Auth<A, N>, K>,
}


#[derive(Clone, Default, Zeroize, ZeroizeOnDrop)]
pub(crate) struct ForsPk<N: ArrayLength> {
    pub(crate) key: GenericArray<u8, N>,
}


/// Fig 10?
#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub(crate) struct Auth<A: ArrayLength, N: ArrayLength> {
    pub(crate) tree: GenericArray<GenericArray<u8, N>, A>,
}


#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub(crate) struct HtSig<D: ArrayLength, HP: ArrayLength, LEN: ArrayLength, N: ArrayLength> {
    pub(crate) xmss_sigs: GenericArray<XmssSig<HP, LEN, N>, D>,
}


#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub struct WotsSig<LEN: ArrayLength, N: ArrayLength> {
    pub(crate) data: GenericArray<GenericArray<u8, N>, LEN>,
}


#[derive(Clone, Default, Zeroize, ZeroizeOnDrop)]
pub struct WotsPk<N: ArrayLength>(pub(crate) GenericArray<u8, N>);


#[derive(Clone, Debug, Default, Zeroize, ZeroizeOnDrop)]
pub struct XmssSig<HP: ArrayLength, LEN: ArrayLength, N: ArrayLength> {
    pub(crate) sig_wots: WotsSig<LEN, N>,
    pub(crate) auth: GenericArray<GenericArray<u8, N>, HP>,
}


impl<HP: ArrayLength, LEN: ArrayLength, N: ArrayLength> XmssSig<HP, LEN, N> {
    pub(crate) fn get_wots_sig(&self) -> &WotsSig<LEN, N> { &self.sig_wots }

    pub(crate) fn get_xmss_auth(&self) -> &GenericArray<GenericArray<u8, N>, HP> { &self.auth }
}


pub(crate) const WOTS_HASH: u32 = 0;
pub(crate) const WOTS_PK: u32 = 1;
pub(crate) const TREE: u32 = 2;
pub(crate) const FORS_TREE: u32 = 3;
pub(crate) const FORS_ROOTS: u32 = 4;
pub(crate) const WOTS_PRF: u32 = 5;
pub(crate) const FORS_PRF: u32 = 6;


/// Straddling the line between struct, enum and union...
#[derive(Clone, Default, Zeroize, ZeroizeOnDrop)]
#[repr(align(32))]
pub(crate) struct Adrs {
    pub(crate) f0: [u8; 4],
    // layer address
    pub(crate) f1: [u8; 4],
    // tree address
    pub(crate) f2: [u8; 4],
    // tree address
    pub(crate) f3: [u8; 4],
    // tree address
    pub(crate) f4: [u8; 4],
    // type
    pub(crate) f5: [u8; 4],
    // key pair address OR padding
    pub(crate) f6: [u8; 4],
    // chain address OR padding OR tree height
    pub(crate) f7: [u8; 4], // hash address OR padding OR tree index OR hash address = 0
}