//
// Created by selim on 27.11.22.
//

#include "Snapshot.h"
#include <stdexcept>
#include <ranges>
#include <sstream>

namespace Dart {

    Snapshot::Snapshot(const std::byte *data) {
        _magic = *(uint32_t*)data;
        data += sizeof(_magic);

        if(_magic != MAGIC) {
            throw std::runtime_error("Snapshot magic mismatch");
        }

        _size = *(uint64_t*)data;
        data += sizeof(_size);

        _kind = *(Kind*)data;
        data += sizeof(Kind);

        _versionHash.assign((char*)data, 32);
        data += _versionHash.size();

        auto features = std::string((char*)data);
        data += features.size() + 1;
        _features = split(features);

        _baseObjectsCount = Leb128Int(data);
        data += _baseObjectsCount.size();

        _allObjectsCount = Leb128Int(data);
        data += _allObjectsCount.size();

        _clustersCount = Leb128Int(data);
        data += _clustersCount.size();

        _fieldTableLength = Leb128Int(data);
        data += _fieldTableLength.size();

        auto nextInt = Leb128Int(data);
        auto val = nextInt.value();
        auto size = nextInt.size();
    }

    uint64_t Snapshot::size() const {
        return _size;
    }

    std::string Snapshot::kindString() const {
        switch (_kind) {
            case Kind::FULL: return "Full";
            case Kind::FULL_JIT: return "Full JIT";
            case Kind::FULL_AOT: return "Full AOT";
            case Kind::MESSAGE: return "Message";
            case Kind::NONE: return "None";
            case Kind::INVALID: return "Invalid";
        }

        return "";
    }

    std::string Snapshot::versionHash() const {
        return _versionHash;
    }

    std::string Snapshot::featuresString() const {
        std::stringstream ss;
        size_t size = _features.size();
        for(size_t i = 0; i < size; ++i) {
            ss << _features[i];
            if(i < size - 1) {
                ss << ", ";
            }
        }

        return ss.str();
    }

    std::vector<std::string> Snapshot::split(const std::string &str) {
        std::vector<std::string> result;
        std::stringstream ss(str);
        std::string item;

        while (std::getline (ss, item, ' ')) {
            result.push_back (item);
        }

        return result;
    }

    uint64_t Snapshot::baseObjectsCount() const {
        return _baseObjectsCount.value();
    }

    uint64_t Snapshot::allObjectsCount() const {
        return _allObjectsCount.value();
    }

    uint64_t Snapshot::clustersCount() const {
        return _clustersCount.value();
    }

    uint64_t Snapshot::fieldTableLength() const {
        return _fieldTableLength.value();
    }

}