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

namespace JabyEngine {
    namespace New {
        namespace internal {
            template<typename T, typename S>
            struct IOValue {
                typedef S UnderlyingType;

                UnderlyingType raw;

                template<typename...ARGS>
                static constexpr T from(const ARGS&...args) {
                    return T{0}.set2(args...);
                }
                
                constexpr T& set2(Bit bit) {
                    this->raw = bit::set(this->raw, bit);
                    return static_cast<T&>(*this);
                }
                
                constexpr T& set2(ClearBit bit) {
                    this->raw = bit::set(this->raw, bit);
                    return static_cast<T&>(*this);
                }
                
                constexpr T& set_range(const BitRange& bits, UnderlyingType value) {
                    this->raw = bit::value::set_normalized(this->raw, bits, value);
                    return static_cast<T&>(*this);
                }
                
                template<typename U>
                constexpr T& set2(const BitRange::RangeValuePair<U>& value) {
                    this->raw = bit::value::set_normalized(this->raw, value);
                    return static_cast<T&>(*this);
                }
                
                template<typename U, typename...ARGS>
                constexpr T& set2(const U& head, const ARGS&...tail) {
                    return this->set2(head).set2(tail...);
                }
                
                constexpr IOValue<T, S>::UnderlyingType get2(BitRange bits) const {
                    return bit::value::get_normalized(this->raw, bits.pos, bits.length);
                }
                
                constexpr T& clear2(Bit bit) {          
                    this->raw = bit::clear(this->raw, bit);
                    return static_cast<T&>(*this);
                }
                
                constexpr bool is_set2(Bit bit) const {      
                    return bit::is_set(this->raw, bit);
                }
            };
        }

        struct ubus32_t {
            uint16_t low;
            uint16_t high;

            static ubus32_t from(uint32_t value) {
                return {.low = static_cast<uint16_t>(value & 0xFFFF), .high = static_cast<uint16_t>(value >> 16)};
            }
        };

        template<typename T>
        struct IOPort {
            T value;

            T read() const {
                return {const_cast<const volatile IOPort<T>*>(this)->value.raw};
            }

            void write(T value) {
                const_cast<volatile IOPort<T>*>(this)->value.raw = value.raw;
            }
        };

        template<>
        struct IOPort<ubus32_t> {
            ubus32_t value;

            ubus32_t read() const {
                auto*const cv_this = const_cast<const volatile IOPort<ubus32_t>*>(this);
                
                return {.low = cv_this->value.low, .high = cv_this->value.high};
            }

            void write(ubus32_t value) {
                auto*const cv_this = const_cast<volatile IOPort<ubus32_t>*>(this);

                cv_this->value.low  = value.low;
                cv_this->value.high = value.high;
            }

            void write(uint32_t value) {
                IOPort<ubus32_t>::write(ubus32_t::from(value));
            }
        };

        #define __new_declare_io_value(name, type)                struct name : public ::JabyEngine::New::internal::IOValue<struct name, type>
        #define __new_declare_value_at(cv, type, name, adr)       static cv auto& name = *reinterpret_cast<type*>(IOAdress::patch_adr(adr))
        #define __new_declare_array_at(cv, type, name, size, adr) static cv auto& name = reinterpret_cast<type(&)[size]>(*reinterpret_cast<type*>(IOAdress::patch_adr(adr)))
        #define __new_declare_io_port_w_type(cv, type, name, adr) __new_declare_value_at(cv, ::JabyEngine::New::IOPort<type>, name, adr)
        #define __new_declare_io_port(cv, name, adr)              __new_declare_io_port_w_type(cv, struct name, name, adr)        
        #define __new_declare_io_port_array(cv, name, size, adr)  __new_declare_array_at(cv, struct name, name, size, adr)
    }

    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

    #pragma pack(push, 1)
    struct 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;
        }
    };
    #pragma pack(pop)
}
#endif //!__JABYENGINE_IOPORT_HPP__