#pragma once

#include <ckitty/memory/primitives.hpp>
#include <ckitty/memory/array.hpp>

#include <type_traits>

namespace ckitty {

    namespace bits {

        /**
         * Unpacks a value into bytes.
         */
        template<typename T>
        inline ckitty::array<u8> unpack(const T value, bool endianness) {
            const size bytelen = sizeof(T);
            ckitty::array<u8> bytes(bytelen);
            for(size i = 0; i < bytelen; i++) {
                size j = endianness ? bytelen - i - 1 : i;
                bytes[i] = (value >> (j * 8)) & 0xFF;
            }
            return bytes;
        }
        
        /**
         * Packs bytes into a value.
         */
        template<typename T>
        inline T pack(const u8* bytes, bool endianness) {
            const size bytelen = sizeof(T);
            T type(0);
            for(size i = 0; i < bytelen; i++) {
                size j = endianness ? bytelen - i - 1 : i;
                type |= T(bytes[i] << (j * 8)) & 0xFF;
            }
            return type;
        }

        template<typename T>
        inline bool read(const T value, size bitno) {
            return (value >> bitno) & 1;
        }

        template<typename T>
        inline T write(const T value, size bitno, bool bitval) {
            size mask = T(1) << bitno;
            return bitval ? (value | mask) : (value & ~mask);
        }

        template<typename T>
        inline void write_r(T& value, size bitno, bool bitval) {
            value = write(value, bitno, bitval);
        }

    }

}