#pragma once

#include <filesystem>
#include <string>
#include <utility>
#include <vector>

#include "constants.hpp"
#include "data/dynamic.hpp"
#include "typedefs.hpp"
#include "Content.hpp"

namespace fs = std::filesystem;

enum class ContentIssueType {
    REORDER,
    MISSING,
};

struct ContentIssue {
    ContentIssueType issueType;
    ContentType contentType;
};

struct ContentEntry {
    ContentType type;
    std::string name;
};

class WorldFiles;

template <typename T, class U>
class ContentUnitLUT {
    std::vector<T> indices;
    std::vector<std::string> names;
    bool missingContent = false;
    bool reorderContent = false;
    T missingValue;
    ContentType type;
public:
    ContentUnitLUT(
        size_t count,
        const ContentUnitIndices<U>& unitIndices,
        T missingValue,
        ContentType type
    )
        : missingValue(missingValue), type(type) {
        for (size_t i = 0; i < count; i++) {
            indices.push_back(i);
        }
        for (auto unit : unitIndices.getIterable()) {
            names.push_back(unit->name); 
        }
        for (size_t i = unitIndices.count(); i < count; i++) {
            names.emplace_back("");
        }
    }
    void setup(dynamic::List* list, const ContentUnitDefs<U>& defs) {
        if (list) {
            for (size_t i = 0; i < list->size(); i++) {
                std::string name = list->str(i);
                if (auto def = defs.find(name)) {
                    set(i, name, def->rt.id);
                } else {
                    set(i, name, missingValue);
                }
            }
        }
    }
    void getMissingContent(std::vector<ContentEntry>& entries) const {
        for (size_t i = 0; i < count(); i++) {
            if (indices[i] == missingValue) {
                auto& name = names[i];
                entries.push_back(ContentEntry {type, name});
            }
        }
    }
    inline const std::string& getName(T index) const {
        return names[index];
    }
    inline T getId(T index) const {
        return indices[index];
    }
    inline void set(T index, std::string name, T id) {
        indices[index] = id;
        names[index] = std::move(name);
        if (id == missingValue) {
            missingContent = true;
        } else if (index != id) {
            reorderContent = true;
        }
    }
    inline ContentType getContentType() const {
        return type;
    }
    inline size_t count() const {
        return indices.size();
    }
    inline bool hasContentReorder() const {
        return reorderContent;
    }
    inline bool hasMissingContent() const {
        return missingContent;
    }
};

/// @brief Content indices lookup table or report
/// used to convert world with different indices
/// Building with indices.json
class ContentLUT {
public:
    ContentUnitLUT<blockid_t, Block> blocks;
    ContentUnitLUT<itemid_t, ItemDef> items;

    std::vector<ContentIssue> issues;

    ContentLUT(
        const ContentIndices* indices, 
        size_t blocks, 
        size_t items
    );

    static std::shared_ptr<ContentLUT> create(
        const std::shared_ptr<WorldFiles>& worldFiles,
        const fs::path& filename,
        const Content* content
    );

    inline bool hasContentReorder() const {
        return blocks.hasContentReorder() || items.hasContentReorder();
    }
    inline bool hasMissingContent() const {
        return blocks.hasMissingContent() || items.hasMissingContent();
    }
    void buildIssues();

    const std::vector<ContentIssue>& getIssues() const;
    std::vector<ContentEntry> getMissingContent() const;
};