#ifndef VALUE_HPP
#define VALUE_HPP
#include <cstdint>
#include <string>
#include <variant>

#include "Token.hpp"
#include "VariableTypes.hpp"

class Value {
  public:
    Variables::Type          type = Variables::Type::VT_NULL;
    Variables::DataContainer data;
    Token                    token;

    Value() : type(Variables::Type::VT_NULL) {}

    //Value(Variables::Type t, double val) : type(t), data(std::move(val)) {}

    //Value(Variables::Type t, int val) : type(t), data(std::move(val)) {}

    //Value(Variables::Type t, const std::string & val) : type(t), data(val) {}

    //Value(Variables::Type t, bool val) : type(t), data(std::move(val)) {}

    Value(Variables::Type variable_type, const Token & token) : type(variable_type), token(token) {
        if (type == Variables::Type::VT_INT) {
            data = std::stoi(token.lexeme);
        } else if (type == Variables::Type::VT_DOUBLE) {
            data = std::stod(token.lexeme);
        } else if (type == Variables::Type::VT_BOOLEAN) {
            data = token.lexeme == "true";
        } else if (type == Variables::Type::VT_NULL) {
            data = Variables::TypeToString(type);
        } else if (type == Variables::Type::VT_NOT_DEFINED) {
            data = Variables::TypeToString(type);
        } else {
            data = token.lexeme;
        }
    }

    //Value(const Token & token) : token(token), type(token.variableType), data(token.lexeme) {}

    //static Value fromInt(int val) { return Value(Variables::Type::VT_INT, val); }

    //static Value fromDouble(double val) { return Value(Variables::Type::VT_DOUBLE, val); }

    //static Value fromString(const std::string & val) { return { Variables::Type::VT_STRING, val }; }

    //static Value fromBoolean(bool val) { return { Variables::Type::VT_BOOLEAN, val }; }

    static Value fromInt(const Token & token) { return Value(Variables::Type::VT_INT, token); }

    static Value fromDouble(const Token & token) { return Value(Variables::Type::VT_DOUBLE, token); }

    static Value fromString(const Token & token) { return Value(Variables::Type::VT_STRING, token); }

    static Value fromBoolean(const Token & token, bool state) {
        auto result = Value(Variables::Type::VT_BOOLEAN, token);
        result.data = state;
        return result;
    }

    std::string ToString() const { return decodeEscapes(Variables::ToString(data, type)); }

    int ToInt() const { return std::get<int>(data); }

    double ToDouble() const { return std::get<double>(data); }

    bool ToBool() const { return std::get<bool>(data); }

    std::string TypeToString() const { return Variables::TypeToString(type); }

    void SetToken(const Token & token) { this->token = token; }

    const Token & GetToken() const { return token; }

  private:
    Value(Variables::Type t, std::variant<int, double, std::string, bool> && val) : type(t), data(std::move(val)) {}

    static std::string decodeEscapes(const std::string & input) {
        std::string result;
        size_t      i = 0;

        auto hexToChar = [](const std::string & hex) -> char {
            return static_cast<char>(std::stoi(hex, nullptr, 16));
        };

        auto hexToUTF8 = [](uint32_t codepoint) -> std::string {
            std::string out;
            if (codepoint <= 0x7F) {
                out += static_cast<char>(codepoint);
            } else if (codepoint <= 0x7FF) {
                out += static_cast<char>(0xC0 | ((codepoint >> 6) & 0x1F));
                out += static_cast<char>(0x80 | (codepoint & 0x3F));
            } else if (codepoint <= 0xFFFF) {
                out += static_cast<char>(0xE0 | ((codepoint >> 12) & 0x0F));
                out += static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F));
                out += static_cast<char>(0x80 | (codepoint & 0x3F));
            } else if (codepoint <= 0x10FFFF) {
                out += static_cast<char>(0xF0 | ((codepoint >> 18) & 0x07));
                out += static_cast<char>(0x80 | ((codepoint >> 12) & 0x3F));
                out += static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F));
                out += static_cast<char>(0x80 | (codepoint & 0x3F));
            }
            return out;
        };

        while (i < input.size()) {
            if (input[i] == '\\' && i + 1 < input.size()) {
                char esc = input[i + 1];

                // Standard short escape sequences
                switch (esc) {
                    case 'n':
                        result += '\n';
                        i += 2;
                        continue;
                    case 't':
                        result += '\t';
                        i += 2;
                        continue;
                    case 'r':
                        result += '\r';
                        i += 2;
                        continue;
                    case 'b':
                        result += '\b';
                        i += 2;
                        continue;
                    case 'f':
                        result += '\f';
                        i += 2;
                        continue;
                    case 'v':
                        result += '\v';
                        i += 2;
                        continue;
                    case 'a':
                        result += '\a';
                        i += 2;
                        continue;
                    case '\\':
                        result += '\\';
                        i += 2;
                        continue;
                    case '"':
                        result += '"';
                        i += 2;
                        continue;
                    case '\'':
                        result += '\'';
                        i += 2;
                        continue;
                    case '?':
                        result += '?';
                        i += 2;
                        continue;
                    case '0':
                        result += '\0';
                        i += 2;
                        continue;
                    case 'x':
                        {
                            // Hexadecimal escape: \xHH
                            size_t      j = i + 2;
                            std::string hex;
                            while (j < input.size() && std::isxdigit(input[j]) && hex.size() < 2) {
                                hex += input[j++];
                            }
                            if (!hex.empty()) {
                                result += hexToChar(hex);
                                i = j;
                                continue;
                            }
                        }
                        break;
                    case 'u':
                    case 'U':
                        {
                            // Unicode escape: \uHHHH or \UHHHHHHHH
                            size_t      expected_len = (esc == 'u') ? 4 : 8;
                            size_t      j            = i + 2;
                            std::string hex;
                            while (j < input.size() && std::isxdigit(input[j]) && hex.size() < expected_len) {
                                hex += input[j++];
                            }
                            if (hex.size() == expected_len) {
                                uint32_t codepoint = std::stoul(hex, nullptr, 16);
                                result += hexToUTF8(codepoint);
                                i = j;
                                continue;
                            }
                        }
                        break;
                }

                // Ha ide jutunk, ismeretlen vagy érvénytelen escape
                result += '\\';
                result += esc;
                i += 2;
            } else {
                result += input[i++];
            }
        }

        return result;
    }
};
#endif  // VALUE_HPP