#ifndef AE_COMMON_H
#define AE_COMMON_H

#include <stddef.h>
#include <stdint.h>
#include <string.h>

#include "cipher.h"
#include "parameters.h"


static inline uint8_t upper_nibble(uint8_t i)
{
    return i >> 4;
}

static inline uint8_t lower_nibble(uint8_t i)
{
    return i & 0x0f;
}

static inline void encrypt(const uint8_t K[KEY_BYTES],
                           const uint8_t T[TWEAK_BYTES],
                           const uint8_t M[BLOCK_BYTES],
                           uint8_t C[BLOCK_BYTES])
{
    lilliput_tbc_encrypt(K, T, M, C);
}

static inline void decrypt(const uint8_t K[KEY_BYTES],
                           const uint8_t T[TWEAK_BYTES],
                           const uint8_t C[BLOCK_BYTES],
                           uint8_t M[BLOCK_BYTES])
{
    lilliput_tbc_decrypt(K, T, C, M);
}

static inline void xor_into(uint8_t dest[BLOCK_BYTES], const uint8_t src[BLOCK_BYTES])
{
    for (size_t i=0; i<BLOCK_BYTES; i++)
        dest[i] ^= src[i];
}

static inline void xor_arrays(size_t len, uint8_t out[len], const uint8_t a[len], const uint8_t b[len])
{
    for (size_t i=0; i<len; i++)
        out[i] = a[i] ^ b[i];
}

static inline void pad10(size_t X_len, const uint8_t X[X_len], uint8_t padded[BLOCK_BYTES])
{
    /* pad10*(X) = X || 1 || 0^{n-|X|-1} */

    /* Assume that len<BLOCK_BYTES. */

    size_t pad_len = BLOCK_BYTES-X_len;

    memcpy(padded+pad_len, X, X_len);

    padded[pad_len-1] = 0x80;

    if (pad_len > 1)
    {
        memset(padded, 0, pad_len-1);
    }
}


#endif /* AE_COMMON_H */