#include <iostream>
#include <deque>
#include <memory>
#include <stack>

class JsonValue {
public:
    typedef enum ValueType {
        Integer,
        Float,
        String,
        Boolean,
        Object,
        Array,
    } ValueType;
public:
    JsonValue() = default;

    virtual ~JsonValue() = default;

    virtual ValueType type() = 0;
};

template<typename T>
class PrimeValue : public JsonValue {
public:
    PrimeValue(const T &data) : data_(data) {}

    ValueType type() override {
        if (std::is_same_v<T, int>) {
            return ValueType::Integer;
        } else if (std::is_same_v<T, bool>) {
            return ValueType::Boolean;
        } else if (std::is_same_v<T, float> || std::is_same_v<T, double>) {
            return ValueType::Float;
        } else if (std::is_same_v<T, std::string>) {
            return ValueType::String;
        } else {
            static_assert("PrimeValue type instance failed!");
        }
    }

public:
    void set(const T &value) { data_ = value; }

    const T &get() const { return data_; }

private:
    T data_;
};

class ArrayValue : public JsonValue {
public:
    ArrayValue() = default;

    ValueType type() override { return ValueType::Array; }

    void AddValue(const std::shared_ptr<JsonValue> &value) {
        data_.push_back(value);
    }

private:
    std::deque<std::shared_ptr<JsonValue>> data_;
};

class NamedValue {
public:
    NamedValue() = default;

    explicit NamedValue(const std::string &name) : name_(name) { std::cout << name << '\n'; }

public:
    void setValue(const std::shared_ptr<JsonValue> &value) {
        data_ = value;
    }

    template<typename T>
    void setValue(const T &value) {
        data_ = std::make_shared<PrimeValue<T>>(value);
    }

    const std::string &getName() const { return name_; }

    template<typename T>
    const T &getValue() {
        return (dynamic_pointer_cast<PrimeValue<T>>(data_))->get();
    }

private:
    std::string name_;
    std::shared_ptr<JsonValue> data_;
};

class ObjectValue : public JsonValue {
public:
    ObjectValue() = default;

    explicit ObjectValue(const std::string &str) {}

    ValueType type() override { return ValueType::Object; }

    void AddValue(const std::shared_ptr<NamedValue> &value) {
        data_.push_back(value);
    }

    bool Contains(const std::string &key) {
        return data_.end() !=
               std::find_if(data_.begin(), data_.end(), [&key](const auto &item) {
                   return key == item->getName();
               });
    }

    template<typename T>
    T getValue(const std::string &key) const {
        auto it = std::find_if(data_.begin(), data_.end(), [&key](const auto &item) {
            return key == item->getName();
        });
        if (data_.end() != it) {
            return (*it)->template getValue<T>();
        }
        return T{};
    }

private:
    std::deque<std::shared_ptr<NamedValue>> data_;
};

std::shared_ptr<JsonValue> Parse(const std::string &json_string) {
    int pair_index{-1};
    int colon_index{-1};
    std::vector<char> memory;
    std::shared_ptr<JsonValue> root_node{nullptr};
    std::vector<std::shared_ptr<JsonValue>> parents;
    std::shared_ptr<JsonValue> parent_node{nullptr};
    std::shared_ptr<NamedValue> next_value{nullptr};
    for (int i = 0; i < json_string.size(); ++i) {
        char c = json_string[i];
        switch (c) {
            case '"':
                if (pair_index >= 0 && pair_index < memory.size()) {
                    std::string str{};
                    std::cout << "i: " << i << ", pair_index: " << pair_index << ", memory.size(): " << memory.size()
                              << '\n';
                    for (int j = pair_index + 1; j < memory.size(); ++j) {
                        str += memory[j];
                    }
                    printf("%s, size: %d\n", str.c_str(), str.size());
                    memory.erase(memory.begin() + pair_index, memory.end());
                    if (colon_index >= 0 && next_value) {
                        next_value->setValue(str);
                        std::shared_ptr<ObjectValue> parent_object = dynamic_pointer_cast<ObjectValue>(parent_node);
                        parent_object->AddValue(next_value);
                        next_value = nullptr;
                    } else {
                        if (colon_index < 0 && parent_node->type() == JsonValue::ValueType::Object) {
                            next_value = std::make_shared<NamedValue>(str);
                        } else if (colon_index < 0 && parent_node->type() == JsonValue::ValueType::Array) {
                            std::shared_ptr<ArrayValue> parent_array = dynamic_pointer_cast<ArrayValue>(parent_node);
                            parent_array->AddValue(std::make_shared<PrimeValue<std::string>>(str));
                        }
                    }
                    pair_index = -1;
                } else {
                    pair_index = memory.size();
                    memory.push_back(c);
                }
                break;
            case ',': {
                bool point_existed{false};
                bool all_digit{true};
                std::string tmp;
                for (int j = 0; j < memory.size(); ++j) {
                    tmp += memory[j];
                    if (memory[j] == '.') {
                        point_existed = true;
                    } else if (all_digit && !std::isdigit(memory[j])) {
                        all_digit = false;
                    }
                }
                memory.clear();
                printf("%s\n", tmp.c_str());
                if (!tmp.empty()) {
                    if (all_digit) {
                        if (point_existed) {
                            auto double_value = std::stod(tmp);
                            if (next_value) {
                                next_value->setValue(double_value);
                                std::shared_ptr<ObjectValue> parent_object = dynamic_pointer_cast<ObjectValue>(
                                        parent_node);
                                parent_object->AddValue(next_value);
                                next_value.reset();
                            } else {
                                std::shared_ptr<ArrayValue> parent_array = dynamic_pointer_cast<ArrayValue>(
                                        parent_node);
                                parent_array->AddValue(std::make_shared<PrimeValue<double>>(double_value));
                            }
                        } else {
                            auto int_value = std::stoi(tmp);
                            if (next_value) {
                                next_value->setValue(int_value);
                                std::shared_ptr<ObjectValue> parent_object = dynamic_pointer_cast<ObjectValue>(
                                        parent_node);
                                parent_object->AddValue(next_value);
                                next_value.reset();
                            } else {
                                std::shared_ptr<ArrayValue> parent_array = dynamic_pointer_cast<ArrayValue>(
                                        parent_node);
                                parent_array->AddValue(std::make_shared<PrimeValue<int>>(int_value));
                            }
                        }
                    } else {
                        bool bool_value;
                        if (tmp == "true") {
                            bool_value = true;
                        } else if (tmp == "false") {
                            bool_value = false;
                        } else {
                            static_assert("Parse value error!");
                        }
                        if (next_value) {
                            next_value->setValue(bool_value);
                            std::shared_ptr<ObjectValue> parent_object = dynamic_pointer_cast<ObjectValue>(parent_node);
                            parent_object->AddValue(next_value);
                            next_value.reset();
                        } else {
                            std::shared_ptr<ArrayValue> parent_array = dynamic_pointer_cast<ArrayValue>(parent_node);
                            parent_array->AddValue(std::make_shared<PrimeValue<bool>>(bool_value));
                        }
                    }
                }
                colon_index = -1;
                break;
            }
            case '{':
                parents.push_back(std::make_shared<ObjectValue>());
                parent_node = parents.back();
                if (parents.size() == 1) {
                    root_node = parents[0];
                }
                break;
            case '}':
                parents.pop_back();
                parent_node = parents.back();
                break;
            case '[':
                parents.push_back(std::make_shared<ArrayValue>());
                parent_node = parents.back();
                if (parents.size() == 1) {
                    root_node = parents[0];
                }
            case ']':
                parents.pop_back();
                parent_node = parents.back();
                break;
            case ':':
                colon_index = i;
                break;
            default:
                memory.push_back(c);
                break;
        }

    }
    return root_node;
}

int main() {
    auto json_obj = Parse(R"({"name":"tianlei","age":27,"is_student":true,"assets":["book","phone","computer",],})");
    std::cout << json_obj->type() << '\n';
    if (json_obj->type() == JsonValue::Object) {
        auto obj_value = std::dynamic_pointer_cast<ObjectValue>(json_obj);
        std::cout << "name: " << obj_value->getValue<std::string>("name") << '\n';
        std::cout << "age: " << obj_value->getValue<int>("age") << '\n';
        std::cout << "is_student: " << obj_value->getValue<bool>("is_student") << '\n';
    }

    return 0;
}