#pragma once

#include <memory>
#include <thread>
#include <string>
#include "../data/safe_queue.hpp"
#include "../data/safe_priority_queue.hpp"
#include "../data/circular_buffer.hpp"
#include "Chunk.hpp"
#include "Region.hpp"
#include "../data/geometry/Ray.hpp"
#include <shared_mutex>

#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
            circular_buffer<float> chunk_count = circular_buffer<float>(REPORT_BUFFER_SIZE, 0); // MAYBE: store int
            /// Loaded chunks
            circular_buffer<float> chunk_load = circular_buffer<float>(REPORT_BUFFER_SIZE, 0);
            /// Saved chunks
            circular_buffer<float> chunk_unload = circular_buffer<float>(REPORT_BUFFER_SIZE, 0);
        };

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

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

        /// Get nearest voxel colliding ray
        /// @note ray in world scale
        std::optional<std::pair<voxel_pos, Voxel>> raycast(const geometry::Ray &ray) const;
        /// Set voxel at pos
        std::optional<Item> set(const voxel_pos &pos, const Voxel &val);
        /// Set cube of voxel with pos as center
        ItemList setCube(const voxel_pos &pos, const Voxel &val, int radius);

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

    private:
        chunk_pos last_pos = chunk_pos(INT_MAX);

        /// Data
        robin_hood::unordered_map<chunk_pos, std::shared_ptr<Chunk>> chunks;

        std::optional<std::shared_ptr<Chunk>> at(const chunk_pos& pos) const {
            const auto it = chunks.find(pos);
            if(it == chunks.end())
                return {};
            return {it->second};
        }

        Generator generator;

        bool running = true;
        std::vector<std::thread> loadWorkers;
        safe_priority_queue<chunk_pos, int> loadQueue;
        safe_queue<robin_hood::pair<chunk_pos, std::shared_ptr<Chunk>>> loadedQueue;

        std::vector<std::thread> saveWorkers;
        safe_queue<robin_hood::pair<chunk_pos, std::shared_ptr<Chunk>>> saveQueue; //NOTE: consider const Chunk

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

        std::shared_mutex regionMutex; //MAYBE: shared_guard
        robin_hood::unordered_map<region_pos, std::shared_ptr<Region>> regionCache;
        //TODO: region pick list
        std::shared_ptr<Region> getRegion(const region_pos &);

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