#pragma once

#include <string>
#include <thread>
#include "../data/math.hpp"
#include "../data/safe_queue.hpp"
#include "../data/safe_priority_queue.hpp"
#include "../data/circular_buffer.hpp"
#include "../data/geometry/Ray.hpp"
#include "forward.h"
#include "Area.hpp"
#include "Voxel.hpp"

#define REPORT_BUFFER_SIZE 128

namespace contouring {
    class Abstract;
};

using namespace data;
/// Universe data
namespace world {
    /// Whole universe container
    class Universe {
    public:
        /// Distance management
        struct options {
            /// Radius in chunks to load if missing
            int loadDistance = 5;
            /// Radius in chunks to keep in memory
            int keepDistance = 6;
            /// Storage path
            std::string folderPath = "world";
        };
        /// Reports to UI
        struct report {
            /// Chunks in memory
            report_buffer chunk_count;
            /// Loaded chunks
            report_buffer chunk_load;
            /// Saved chunks
            report_buffer chunk_unload;
            /// Regions in memory
            report_buffer region_count;
        };

        Universe(const options &);
        ~Universe();

        /// Update physics and contouring
        void update(const voxel_pos &pos, float deltaTime, report &rep);
        /// Apply new options
        void setOptions(const options &);

        struct ray_target {
            area_<voxel_pos> pos;
            Voxel value;
            voxel_pos offset;
        };
        /// Get nearest voxel colliding ray
        /// @note ray in world scale
        std::optional<ray_target> raycast(const geometry::Ray &ray) const;
        /// Set voxel at pos
        std::optional<Item> set(const area_<voxel_pos> &pos, const Voxel &val);
        /// Set cube of voxel with pos as center
        /// MAYBE: allow set multi area
        ItemList setCube(const area_<voxel_pos> &pos, const Voxel &val, int radius);

        /// Change contouring worker
        void setContouring(const std::shared_ptr<contouring::Abstract>& ct);
        /// Get current contouring worker
        std::shared_ptr<contouring::Abstract> getContouring() const {
            return contouring;
        }

    private:
        chunk_pos last_pos = chunk_pos(INT_MAX);

        /// Alive areas containing chunks
        area_map areas;
        using area_it_t = robin_hood::pair<area_id, std::shared_ptr<Area>>;
        /// Dead areas
        data::generational::vector<Area::params> far_areas;
        void saveAreas() const;

        bool running = true;
        std::vector<std::thread> loadWorkers;
        safe_priority_queue_map<area_<chunk_pos>, std::shared_ptr<Area>, int, area_hash> loadQueue; //NOTE: consider Area const (getRegion uses mutex)
        safe_queue<robin_hood::pair<area_<chunk_pos>, std::shared_ptr<Chunk>>> loadedQueue;

        std::vector<std::thread> saveWorkers;
        using save_task_t = std::pair<area_it_t, robin_hood::pair<chunk_pos, std::shared_ptr<Chunk>>>;
        data::safe_queue<save_task_t> saveQueue; //NOTE: consider Area and Chunk const

        int loadDistance;
        int keepDistance;
        std::string folderPath;

        dict_set dicts;

        /// Contouring worker
        std::shared_ptr<contouring::Abstract> contouring;
    };
}