#ifndef __JABYENGINE_FILE_PROCESSOR_HPP__
#define __JABYENGINE_FILE_PROCESSOR_HPP__
#include "../File_Types.hpp"

namespace FileProcessor {
    class State {
    private:
        struct Reserved {
            uint32_t reserved[4];     
        };

        struct Configuration;
        typedef bool (*ProcessRoutine)(Configuration&, Reserved&);

        struct Configuration {
            ProcessRoutine  process_routine = nullptr;
            const uint32_t* data_adr        = nullptr;
            size_t          data_word_size  = 0ull;

            template<typename T>
            static __always_inline Configuration from(bool (*process_routine)(Configuration&, T&), const uint32_t* data_adr) {
                return {reinterpret_cast<ProcessRoutine>(process_routine), data_adr};
            }
            
            constexpr void processed(size_t words) {
                this->data_adr       += words;
                this->data_word_size -= words;
            }
        };

    private:
        Configuration config;
        Reserved      reserved;

        template<typename T>
        static __always_inline State from(const T& reserved, const uint32_t* data_adr, bool (*process_routine)(Configuration&, T&)) {
            return {Configuration::from(process_routine, data_adr), *reinterpret_cast<const Reserved*>(&reserved)};
            static_assert(sizeof(T) <= sizeof(Reserved));
        }

    public:
        bool process(size_t word_size) {
            this->config.data_word_size += word_size;
            return (*this->config.process_routine)(this->config, this->reserved);
        }
    };

    State create(const uint32_t* data_adr, const SimpleTIM& file);
}

#endif // !__JABYENGINE_FILE_PROCESSOR_HPP__