#pragma once

#include <concepts>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>

namespace sliger::json {

enum class Type {
    Null,
    String,
    Number,
    Bool,
    Array,
    Object,
};

struct Value {
    virtual ~Value() = default;
    virtual auto type() const -> Type = 0;

    template <typename T>
        requires std::derived_from<T, Value>
    inline auto as() & -> T&
    {
        return static_cast<T&>(this);
    }
};

struct Null final : public Value {
    auto type() const -> Type override { return Type::Null; }
};

struct String final : public Value {
    auto type() const -> Type override { return Type::String; }

    std::string value;
};

struct Number final : public Value {
    auto type() const -> Type override { return Type::Number; }

    double value;
};

struct Bool final : public Value {
    auto type() const -> Type override { return Type::Bool; }

    bool value;
};

struct Array final : public Value {
    auto type() const -> Type override { return Type::Array; }

    std::vector<std::unique_ptr<Value>> values;
};

struct Object final : public Value {
    auto type() const -> Type override { return Type::Object; }
};

struct Pos {
    int line;
    int col;
};

enum class TokTyp {
    Error,
    Eof,
    String,
    Float,
    False,
    True,
    Null,
    LBrace,
    RBrace,
    LBracket,
    RBracket,
    Comma,
    Colon,
};

struct Tok {
    Tok(TokTyp typ)
        : typ(typ)
        , val_id(0)
    {
    }
    Tok(TokTyp typ, size_t val_id)
        : typ(typ)
        , val_id(val_id)
    {
    }
    Tok(TokTyp typ, double float_val)
        : typ(typ)
        , float_val(float_val)
    {
    }
    Tok(TokTyp typ, bool bool_val)
        : typ(typ)
        , bool_val(bool_val)
    {
    }

    TokTyp typ;
    union {
        size_t val_id;
        double float_val;
        bool bool_val;
    };
};

class Lexer {
public:
    Lexer(std::string_view text)
        : text(text)
    {
    }

    auto next() -> Tok;

    inline auto pos() const -> Pos { return { this->line, this->col }; }

private:
    inline void step() { this->i += 1; }

    inline auto test_in(std::string_view chs) const -> bool
    {
        for (auto ch : chs)
            if (test(ch))
                return true;
        return false;
    }
    inline auto test(char ch) const -> bool { return !done() && cur() == ch; }
    inline auto done() const -> bool { return this->i >= this->text.size(); }
    inline auto cur() const -> char { return this->text.at(this->i); }

    std::string_view text;
    size_t i = 0;
    int line = 1;
    int col = 1;
};

class Parser {
public:
    Parser(std::string_view text)
        : lexer(text)
        , cur(lexer.next())
    {
    }

private:
    Lexer lexer;
    Tok cur;
};

struct Jsonable {
    virtual ~Jsonable() = default;

    virtual auto to_json() const -> std::string = 0;
};

template <typename T> auto from_json() -> T { T::from_json(); }

}