#ifndef __JABYENGINE_IOPORT_HPP__
#define __JABYENGINE_IOPORT_HPP__
#include "../../Auxiliary/types.hpp"
#include "../../Auxiliary/bits.hpp"

namespace JabyEngine {
    namespace IOPort {
        struct IOValueType {
            template<typename T>
            struct Normal {
                typedef T Value;
                typedef T UnderlyingValue;
            };

            template<typename T>
            struct Volatile {
                typedef volatile T Value;
                typedef          T UnderlyingValue;
            };
        };
    }

    namespace IOAdress {
        constexpr uintptr_t patch_adr(uintptr_t adr) {
            constexpr uintptr_t Mask = 0xF0000000;
            constexpr uintptr_t Base = 0x10000000; // We might want to change this later to 0xB0000000 for caching and stuff (More research needed)

            return (Base + (adr & ~Mask));
        }
    }

    #define __declare_new_named_io_port(type, name, adr) \
        static inline auto& name = *reinterpret_cast<type##_v*>(IOAdress::patch_adr(adr))

    #define __declare_new_io_port(name, adr) \
        __declare_new_named_io_port(name, name, adr)

    #define __declare_new_const_io_port(name, adr) \
        __declare_new_named_io_port(const name, name, adr)
        
    #define __declare_new_io_port_array(name, adr, size) \
        static inline auto& name = reinterpret_cast<name##_v(&)[size]>(*reinterpret_cast<name##_v*>(adr))

    // We need this construct to ensure the types end up being a POD - Inheritance doesn't qualify for a POD
    #define __declare_io_type(name, type, ...)                                                                  \
        template<template<typename> typename T>                                                                 \
        struct name##_io_base {                                                                                 \
            typedef T<type>::UnderlyingValue UnderlyingValue;                                                   \
            typedef name##_io_base Self;                                                                        \
                                                                                                                \
            T<type>::Value raw_value = 0;                                                                       \
                                                                                                                \
            __VA_ARGS__                                                                                         \
                                                                                                                \
            template<typename...ARGS>                                                                           \
            static constexpr Self from(const ARGS&...args) {                                                    \
                return Self().set_va(args...);                                                                  \
            }                                                                                                   \
                                                                                                                \
            constexpr Self& set(Bit bit) {                                                                      \
                this->raw_value = bit::set(this->raw_value, bit);                                               \
                return *this;                                                                                   \
            }                                                                                                   \
                                                                                                                \
            constexpr Self& set(ClearBit bit) {                                                                 \
                this->raw_value = bit::set(this->raw_value, bit);                                               \
                return *this;                                                                                   \
            }                                                                                                   \
                                                                                                                \
            constexpr Self& set(BitRange bits, UnderlyingValue value) {                                         \
                this->raw_value = bit::value::set_normalized(this->raw_value, bits, value);                     \
                return *this;                                                                                   \
            }                                                                                                   \
                                                                                                                \
            template<typename S>                                                                                \
            constexpr Self& set(const BitRange::RangeValuePair<S>& value) {                                     \
                this->raw_value = bit::value::set_normalized(this->raw_value, value);                           \
                return *this;                                                                                   \
            }                                                                                                   \
                                                                                                                \
            template<typename S>                                                                                \
            constexpr Self& set_va(const S& head) {                                                             \
                return this->set(head);                                                                         \
            }                                                                                                   \
                                                                                                                \
            template<typename S, typename...ARGS>                                                               \
            constexpr Self& set_va(const S& head, const ARGS&...tail) {                                         \
                return this->set(head).set_va(tail...);                                                         \
            }                                                                                                   \
                                                                                                                \
            constexpr UnderlyingValue get(BitRange bits) const {                                                \
                return bit::value::get_normalized(this->raw_value, bits.pos, bits.length);                      \
            }                                                                                                   \
                                                                                                                \
            constexpr Self& clear(Bit bit) {                                                                    \
                this->raw_value = bit::clear(this->raw_value, bit);                                             \
                return *this;                                                                                   \
            }                                                                                                   \
                                                                                                                \
            constexpr bool is_set(Bit bit) const {                                                              \
                return bit::is_set(this->raw_value, bit);                                                       \
            }                                                                                                   \
                                                                                                                \
            constexpr void operator=(UnderlyingValue value) {                                                   \
                this->raw_value = value;                                                                        \
            }                                                                                                   \
                                                                                                                \
            constexpr operator UnderlyingValue() const {                                                        \
                return this->raw_value;                                                                         \
            }                                                                                                   \
        };                                                                                                      \
                                                                                                                \
        typedef name##_io_base<IOPort::IOValueType::Volatile> name##_v;                                         \
        typedef name##_io_base<IOPort::IOValueType::Normal>   name##_t

    struct __no_align ubus32_t {
        __declare_io_type(uint16_t, uint16_t,);
        uint16_t_v low;
        uint16_t_v high;

        constexpr ubus32_t(uint32_t value) : low{0}, high{0} {
            *this = value;
        }

        constexpr void write(uint32_t value) {
            *this = value;
        }

        constexpr operator uint32_t() const {
            const uint32_t high = this->high;
            const uint32_t low  = this->low;

            return ((high << 16) | low);
        }

        constexpr ubus32_t& operator=(uint32_t value) {
            this->low  = (value & 0xFFFF);
            this->high = (value >> 16);

            return *this;
        }
    };
}
#endif //!__JABYENGINE_IOPORT_HPP__