#pragma once

#include <string>
#include <set>
#include <vector>
#include <sstream>
#include <tree/ParseTree.h>

namespace trygvis {
namespace elfinfo {

class LdParseException : public std::runtime_error {
public:
    explicit LdParseException(const std::vector<std::string> &messages) :
        runtime_error("Parse error"), messages(messages) {}

    const std::vector<std::string> messages;
};

class LdInternalErrorException : public std::runtime_error {
public:
    explicit LdInternalErrorException(const std::string &what) : runtime_error(what) {}
};

enum class MemoryAttribute {
    R, W, X
};

static char to_str(const MemoryAttribute &type) {
    switch (type) {
        case MemoryAttribute::R:
            return 'r';
        case MemoryAttribute::W:
            return 'w';
        case MemoryAttribute::X:
            return 'x';
    }
}

struct Section {
    std::string name;
};

struct MemoryArea {
    std::string name;
    uint64_t origin;
    uint64_t length;
    std::set<MemoryAttribute> attributes;

    bool contains(uint64_t address, uint64_t size) const {
        return contains(address) && contains(address + size);
    }

    bool contains(uint64_t address) const {
        return origin <= address && address < origin + length;
    }

    std::string attributes_string() const {
        char buf[4];
        buf[0] = attributes.find(MemoryAttribute::R) == attributes.end() ? '-' : 'r';
        buf[1] = attributes.find(MemoryAttribute::W) == attributes.end() ? '-' : 'w';
        buf[2] = attributes.find(MemoryAttribute::X) == attributes.end() ? '-' : 'x';
        buf[3] = '\0';
        return std::string(buf);
    }
};

struct LdScript {
    std::vector<MemoryArea> memoryAreas;
};

class LdScriptLoader {
public:
    LdScriptLoader();

    LdScript load(std::string path);

    void setDebug(bool debug);

private:
    bool debug_;
};

} // namespace elfinfo
} // namespace trygvis