TySON.hpp

//
// Created by felix on 29.01.23.
//
 
#ifndef ANNADB_DRIVER_TYSON_HPP
#define ANNADB_DRIVER_TYSON_HPP
 
#include <algorithm>
#include <ranges>
#include <string_view>
#include "utils.hpp"
 
namespace tyson
{
    enum class TySonType
    {
        Number,
        String,
        Bool,
        Null,
        Timestamp,
        Link,
        Vector,
        Map,
        Object,
        ID,
        Objects,
        IDs,
        Value,
        ProjectValue,
        Keep,
    };
    
    template<std::convertible_to<TySonType> Obj>
    std::string_view TySonType_repr(Obj &&obj) noexcept
    {
        switch (obj)
        {
            case TySonType::Number:
                return "TySON-Number";
            case TySonType::String:
                return "TySON-String";
            case TySonType::Bool:
                return "TySON-Bool";
            case TySonType::Null:
                return "TySON-Null";
            case TySonType::Timestamp:
                return "TySON-Timestamp";
            case TySonType::Link:
                return "TySON-Link";
            case TySonType::Vector:
                return "TySON-Vector";
            case TySonType::Map:
                return "TySON-Map";
            case TySonType::Object:
                return "TySON-Object";
            case TySonType::ID:
                return "TySON-ID";
            case TySonType::Objects:
                return "TySON-Objects";
            case TySonType::IDs:
                return "TySON-IDs";
            case TySonType::Value:
                return "TySON-Value";
            case TySonType::ProjectValue:
                return "TySON-ProjectValue";
            case TySonType::Keep:
                return "TySON-Keep";
        }
        return "";
    }
 
    class TySonObject
    {
        std::vector<TySonObject> vector_{};
        std::map<TySonObject, TySonObject> map_{};
        std::pair<std::string, std::string> link_{};
        TySonType type_;
        std::string value_;
 
        void parse_vector_elements(std::string_view object) noexcept
        {
            const auto to_tyson_object = [](std::string &val) -> TySonObject
            {
                return TySonObject{val};
            };
 
            auto end_type_sep = object.find_first_of('[') + 1;
            auto end_value_sep = (object.size() - 1) - end_type_sep;
 
            auto vector_data = object.substr(end_type_sep, end_value_sep);
 
            auto vec_data = utils::split(vector_data, ',');
            std::transform(vec_data.begin(), vec_data.end(), std::back_inserter(vector_), to_tyson_object);
        }
 
        [[ nodiscard ]] std::vector<TySonObject> parse_map_element(std::string_view object) noexcept
        {
            const auto to_tyson_object = [](std::string &val) -> TySonObject
            {
                return TySonObject{val};
            };
 
            auto vec_data = utils::split(object, ':');
 
            std::vector<TySonObject> result;
            result.reserve(vec_data.size());
 
            std::transform(vec_data.begin(), vec_data.end(), std::back_inserter(result), to_tyson_object);
            return result;
        }
 
        void parse_map_elements(std::string_view object) noexcept
        {
            auto end_type_sep = object.find_first_of('{') + 1;
            auto end_value_sep = (object.size() - 1) - end_type_sep;
            auto map_data = object.substr(end_type_sep, end_value_sep);
 
            auto vec_data = utils::split(map_data, ',');
 
            auto to_map_element = [this](auto &val) -> std::vector<TySonObject>
            {
                return parse_map_element(val);
            };
 
            std::vector<std::vector<TySonObject>> result;
            std::transform(vec_data.begin(), vec_data.end(), std::back_inserter(result), to_map_element);
            std::for_each(result.begin(), result.end(), [this](auto key_val)
            {
                map_.try_emplace(key_val[0], key_val[1]);
            });
        }
 
        friend std::ostream& operator<<(std::ostream &out, TySonObject const &obj) noexcept
        {
            switch (obj.type())
            {
                case TySonType::Number:
                    return out << "n|" << obj.value_ << "|";
                case TySonType::String:
                    return out << "s|" << obj.value_ << "|";
                case TySonType::Bool:
                    return out << "b|" << obj.value_ << "|";
                case TySonType::Null:
                    return out << "null";
                case TySonType::Timestamp:
                    return out << "utc|" << obj.value_ << "|";
                case TySonType::Link:
                    return out << std::get<0>(obj.link_) << "|" << std::get<1>(obj.link_) << "|";
                case TySonType::Value:
                    return out << "value|" << obj.map_.begin()->first.value_ << "|:" << obj.map_.begin()->second;
                case TySonType::Vector:
                {
                    std::stringstream sstream;
                    std::for_each(obj.vector_.begin(),
                                  obj.vector_.end(),
                                  [&sstream](const auto &val){ sstream << val << ","; });
 
                    return out << "v[" << sstream.str() << "]";
                }
                case TySonType::Map:
                {
                    std::stringstream sstream;
                    std::for_each(obj.map_.begin(),
                                  obj.map_.end(),
                                  [&sstream](const std::pair<TySonObject, TySonObject> &val)
                                  {
                                        sstream << val.first << ":" << val.second << ",";
                                  });
 
                    return out << "m{" << sstream.str() << "}";
                }
                case TySonType::ProjectValue:
                {
                    return out << "value|" << obj.map_.begin()->first.value_ << "|";
                }
                case TySonType::Keep:
                {
                    return out << "keep";
                }
                default:
                    return out << "";
            }
        }
        
        TySonType cast_type_string(char &_type)
        {
            switch (_type)
            {
                case 'n':
                    return tyson::TySonType::Number;
                case 's':
                    return tyson::TySonType::String;
                case 'b':
                    return tyson::TySonType::Bool;
                case 'u':
                    return tyson::TySonType::Timestamp;
                case 'l':
                    return tyson::TySonType::Link;
                case 'v':
                    return tyson::TySonType::Vector;
                case 'm':
                    return tyson::TySonType::Map;
                default:
                    return tyson::TySonType::Object;
            }
        }
 
    public:
 
        TySonObject() noexcept : type_(tyson::TySonType::Null) {};
        ~TySonObject() = default;
 
        explicit TySonObject(std::string_view object) noexcept
        {
            auto end_type_sep = object.find_first_of('|');
            auto end_value_sep = (object.size() - 1) - (end_type_sep + 1);
            auto type = object.substr(0, end_type_sep);
 
            if (object == "null")
            {
                type_ = TySonType::Null;
                value_ = {};
                return;
            }
 
            if (object.starts_with("uts"))
            {
                type_ = TySonType::Timestamp;
                value_ = object.substr(end_type_sep + 1, end_value_sep);
            }
            else if (object.substr(0, 2) == "v[")
            {
                type_ = TySonType::Vector;
 
                parse_vector_elements(object);
            }
            else if (object.substr(0, 2) == "m{")
            {
                type_ = TySonType::Map;
                parse_map_elements(object);
            }
            else if (end_type_sep > 1)
            {
                type_ = TySonType::Link;
                auto val = object.substr(end_type_sep + 1, end_value_sep);
                link_ = std::make_pair(type, val);
            }
            else
            {
                type_ = cast_type_string(const_cast<char &>(type.at(0)));
                value_ = object.substr(end_type_sep + 1, end_value_sep);
            }
        }
 
        [[ nodiscard ]] bool operator==(const TySonObject &rhs) const noexcept
        {
            return std::tie(this->type_, this->value_, this->vector_, this->map_, this->link_) ==
                   std::tie(rhs.type_, rhs.value_, rhs.vector_, rhs.map_, rhs.link_);
        }
    
        [[ nodiscard ]] bool operator<(const TySonObject &rhs) const noexcept
        {
            return std::tie(this->type_, this->value_, this->vector_) < std::tie(rhs.type_, rhs.value_, rhs.vector_);
        }
        
        bool emplace(const std::string &key, tyson::TySonObject &&value)
        {
            if (type_ != TySonType::Map)
            {
                std::stringstream sstream;
                sstream << "Can not be used with";
                sstream << TySonType_repr(type_);
                throw std::invalid_argument(sstream.str());
            }
            const auto [it, success]  = map_.try_emplace(TySonObject::String(key), std::move(value));
            return success;
        }
 
        template<typename T>
        requires std::is_integral_v<T>
        [[ nodiscard ]] static TySonObject Number(T number) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.value_ = std::to_string(number);
            tySonObject.type_ = TySonType::Number;
            return tySonObject;
        }
 
 
        [[ nodiscard ]] static TySonObject String(const std::string &str) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.value_ = str;
            tySonObject.type_ = TySonType::String;
            return tySonObject;
        }
 
        [[ nodiscard ]] static TySonObject Bool(bool bl) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.value_ = bl ? "true" : "false";
            tySonObject.type_ = TySonType::Bool;
            return tySonObject;
        }
 
        [[ nodiscard ]] static TySonObject Null() noexcept
        {
            TySonObject tySonObject {};
            tySonObject.value_ = "null";
            tySonObject.type_ = TySonType::Null;
            return tySonObject;
        }
    
        [[ nodiscard ]] static TySonObject Keep() noexcept
        {
            TySonObject tySonObject {};
            tySonObject.value_ = "keep";
            tySonObject.type_ = TySonType::Keep;
            return tySonObject;
        }
    
    
        [[ nodiscard ]] static TySonObject Timestamp(unsigned long long seconds) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.value_ = std::to_string(seconds);
            tySonObject.type_ = TySonType::Timestamp;
            return tySonObject;
        }
 
        [[ nodiscard ]] static TySonObject Link(const std::string &collection, const std::string &uuid) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.link_ = {collection, uuid};
            tySonObject.type_ = TySonType::Link;
            return tySonObject;
        }
 
        template<std::convertible_to<tyson::TySonObject> ...Values>
        [[ nodiscard ]] static TySonObject Vector(Values &&...objs) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.vector_.reserve(sizeof ...(objs));
            (tySonObject.vector_.emplace_back(objs), ...);
            tySonObject.type_ = TySonType::Vector;
            return tySonObject;
        }
 
        [[ nodiscard ]] static TySonObject Value(const std::string &field, TySonObject &&val) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.map_.try_emplace(TySonObject::String(field), val);
            tySonObject.type_ = TySonType::Value;
            return tySonObject;
        }
    
        [[ nodiscard ]] static TySonObject ProjectValue(const std::string &value) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.map_.try_emplace(TySonObject::String(value), value);
            tySonObject.type_ = TySonType::ProjectValue;
            return tySonObject;
        }
 
        [[ nodiscard ]] static TySonObject Map(std::map<std::string, TySonObject> &objs) noexcept
        {
            TySonObject tySonObject {};
            std::for_each(objs.begin(), objs.end(),
                          [&tySonObject](std::pair<const std::string, TySonObject> &val)
                          {
                                tySonObject.map_.try_emplace(TySonObject::String(val.first), std::move(val.second));
                          });
            tySonObject.type_ = TySonType::Map;
            return tySonObject;
        }
    
        [[ nodiscard ]] static TySonObject Map(const std::string &key, TySonObject &&obj) noexcept
        {
            TySonObject tySonObject {};
            tySonObject.map_.try_emplace(TySonObject::String(key), std::move(obj));
            tySonObject.type_ = TySonType::Map;
            return tySonObject;
        }
    
        [[ nodiscard ]] static TySonObject Map() noexcept
        {
            TySonObject tySonObject {};
            tySonObject.type_ = TySonType::Map;
            return tySonObject;
        }
 
        [[ nodiscard ]] std::optional<TySonObject> operator[](const std::string_view key) const noexcept
        {
            if (type_ == TySonType::Map)
            {
                TySonObject result;
                std::for_each(map_.begin(),
                              map_.end(),
                              [&result, &key](const std::pair<TySonObject, TySonObject> &obj)
                              {
                                  if (obj.first.value_ == key)
                                  {
                                      result = obj.second;
                                  }
                              });
                return result;
            }
            else
            {
                return {};
            }
        }
 
        [[nodiscard]] TySonType type() const noexcept
        {
            return type_;
        }
 
        template<TySonType T>
        [[nodiscard]] std::string value() const noexcept
        {
            return value_;
        }
 
        template<TySonType T>
        requires (T == TySonType::Bool)
        [[nodiscard]] bool value() const noexcept
        {
            return value_ == "true";
        }
 
        template<TySonType T>
        requires (T == TySonType::Null)
        [[nodiscard]] std::string value() const noexcept
        {
            return "";
        }
 
        template<TySonType T>
        requires (T == TySonType::Link)
        [[nodiscard]] std::pair<std::string, std::string> value() const noexcept
        {
            return link_;
        }
 
        template<TySonType T>
        requires (T == TySonType::Vector)
        [[nodiscard]] std::vector<TySonObject> value() const noexcept
        {
            return vector_;
        }
 
        template<TySonType T>
        requires (T == TySonType::Map)
        [[nodiscard]] std::map<TySonObject, TySonObject> value() const noexcept
        {
            return map_;
        }
 
        template<typename T>
        requires std::is_arithmetic_v<T>
        [[nodiscard]] T value() const
        {
            if (type_ == TySonType::Number || type_ == TySonType::Bool || type_ == TySonType::Timestamp)
            {
                std::size_t pos{};
 
                switch (*typeid(T).name())
                {
                    case 's':
                    case 'j':
                    case 'i':
                        return std::stoi(value_, &pos);
                    case 'l':
                        return std::stol(value_, &pos);
                    case 'f':
                        return static_cast<T>(std::stof(value_, &pos));
                    case 'd':
                        return static_cast<T>(std::stod(value_, &pos));
                    case 'x':
                        return std::stoll(value_, &pos);
                    case 'e':
                        return static_cast<T>(std::stold(value_, &pos));
                    case 'b':
                        return value_ == "true";
                    case 'c':
                        return value_.c_str()[0];
                }
            }
 
            throw std::invalid_argument("Invalid Type");
        }
    };
 
 
    class TySonCollectionObject
    {
        std::vector<TySonObject> collection_ids_{};
        std::vector<std::pair<TySonObject, TySonObject>> collection_objects_{};
 
    public:
        TySonCollectionObject() = default;
        explicit TySonCollectionObject(size_t size, bool objects = false)
        {
            if (objects)
            {
                collection_objects_.reserve(size);
            }
            else
            {
                collection_ids_.reserve(size);
            }
        }
        ~TySonCollectionObject() = default;
 
        void add(const std::string &object)
        {
            auto tyson_str_data = utils::split(object, '|');
            collection_ids_.emplace_back(TySonObject::Link(tyson_str_data[0], tyson_str_data[1]));
        };
 
        void add(const std::string &link, const std::string &value)
        {
            const auto new_val = std::make_pair(TySonObject(link), TySonObject(value));
            collection_objects_.emplace_back(new_val);
        };
 
        template<TySonType T>
        requires (T == TySonType::Object)
        [[ nodiscard ]] std::optional<std::pair<TySonObject, TySonObject>> get(std::string_view obj_id) noexcept
        {
            for (const auto &val: collection_objects_)
            {
                if (val.first.value<TySonType::Link>().second == obj_id)
                {
                    return val;
                }
            }
            return {};
        }
 
        template<TySonType T>
        requires (T == TySonType::Objects)
        [[ nodiscard ]] std::vector<std::pair<TySonObject, TySonObject>> get(std::string_view collection) noexcept
        {
            std::vector<std::pair<TySonObject, TySonObject>> result{};
            std::for_each(collection_objects_.begin(), collection_objects_.end(),
                          [&collection, &result](const std::pair<TySonObject, TySonObject> &val)
                          {
                              if (val.first.value<TySonType::Link>().first == collection)
                              {
                                  result.emplace_back(val);
                              }
                          });
            return result;
        }
 
        template<TySonType T>
        requires (T == TySonType::Object)
        [[ nodiscard ]] std::optional<std::pair<TySonObject, TySonObject>> get(std::string_view collection, std::string_view obj_id) noexcept
        {
            for (const std::pair<TySonObject, TySonObject> &val: collection_objects_)
            {
                auto tysonLink = val.first.value<TySonType::Link>();
                if (std::tie(tysonLink.first, tysonLink.second) == std::tie(collection, obj_id))
                {
                    return val;
                }
            }
 
            return {};
        }
 
        template<TySonType T>
        requires (T == TySonType::ID)
        [[ nodiscard ]] std::optional<TySonObject> get(std::string_view obj_id) noexcept
        {
            for (const TySonObject &val: collection_ids_)
            {
                if (val.value<TySonType::Link>().second == obj_id)
                {
                    return val;
                }
            }
            return {};
        }
 
        template<TySonType T>
        requires (T == TySonType::IDs)
        [[ nodiscard ]] std::vector<TySonObject> get(std::string_view collection) noexcept
        {
            std::vector<TySonObject> result{};
            std::for_each(collection_ids_.begin(), collection_ids_.end(),
                         [&result, &collection](const TySonObject &val)
                         {
                             if (val.value<TySonType::Link>().first == collection)
                             {
                                 result.emplace_back(val);
                             }
                         });
            return result;
        }
 
        template<TySonType T>
        requires (T == TySonType::ID)
        [[ nodiscard ]] std::optional<TySonObject> get(std::string_view collection, std::string_view obj_id) noexcept
        {
            for (const TySonObject &val: collection_ids_)
            {
                auto tysonLink = val.value<TySonType::Link>();
                if (std::tie(tysonLink.first, tysonLink.second) == std::tie(collection, obj_id))
                {
                    return val;
                }
            }
 
            return {};
        }
    };
}
 
#endif //ANNADB_DRIVER_TYSON_HPP