#ifndef CAMELLYA_VALUE_H
#define CAMELLYA_VALUE_H

#include <memory>
#include <vector>
#include <map>
#include <string>
#include <variant>
#include <functional>

namespace camellya {

class Value;

using ValuePtr = std::shared_ptr<Value>;
using NativeFunction = std::function<ValuePtr(const std::vector<ValuePtr>&)>;

enum class Type {
    NIL,
    NUMBER,
    STRING,
    BOOL,
    LIST,
    MAP,
    FUNCTION,
    CLASS,
    INSTANCE
};

class Value {
public:
    virtual ~Value() = default;
    virtual Type type() const = 0;
    virtual std::string to_string() const = 0;
    virtual ValuePtr clone() const = 0;
};

class NilValue : public Value {
public:
    Type type() const override { return Type::NIL; }
    std::string to_string() const override { return "nil"; }
    ValuePtr clone() const override { return std::make_shared<NilValue>(); }
};

class NumberValue : public Value {
public:
    double value;
    
    explicit NumberValue(double value) : value(value) {}
    Type type() const override { return Type::NUMBER; }
    std::string to_string() const override;
    ValuePtr clone() const override { return std::make_shared<NumberValue>(value); }
};

class StringValue : public Value {
public:
    std::string value;
    
    explicit StringValue(std::string value) : value(std::move(value)) {}
    Type type() const override { return Type::STRING; }
    std::string to_string() const override { return value; }
    ValuePtr clone() const override { return std::make_shared<StringValue>(value); }
};

class BoolValue : public Value {
public:
    bool value;
    
    explicit BoolValue(bool value) : value(value) {}
    Type type() const override { return Type::BOOL; }
    std::string to_string() const override { return value ? "true" : "false"; }
    ValuePtr clone() const override { return std::make_shared<BoolValue>(value); }
};

class ListValue : public Value {
public:
    std::vector<ValuePtr> elements;
    
    ListValue() = default;
    explicit ListValue(std::vector<ValuePtr> elements) : elements(std::move(elements)) {}
    
    Type type() const override { return Type::LIST; }
    std::string to_string() const override;
    ValuePtr clone() const override;
    
    void push(ValuePtr value) { elements.push_back(std::move(value)); }
    ValuePtr get(size_t index) const;
    void set(size_t index, ValuePtr value);
    size_t size() const { return elements.size(); }
};

class MapValue : public Value {
public:
    std::map<std::string, ValuePtr> pairs;
    
    MapValue() = default;
    explicit MapValue(std::map<std::string, ValuePtr> pairs) : pairs(std::move(pairs)) {}
    
    Type type() const override { return Type::MAP; }
    std::string to_string() const override;
    ValuePtr clone() const override;
    
    void set(const std::string& key, ValuePtr value) { pairs[key] = std::move(value); }
    ValuePtr get(const std::string& key) const;
    bool has(const std::string& key) const { return pairs.find(key) != pairs.end(); }
};

// Forward declarations
struct FunctionDecl;
class ClassValue;
class InstanceValue;

class FunctionValue : public Value {
public:
    std::string name;
    std::vector<std::pair<std::string, std::string>> parameters;
    std::string return_type;
    std::shared_ptr<FunctionDecl> declaration;
    NativeFunction native_func;
    bool is_native;
    std::shared_ptr<InstanceValue> bound_instance;
    
    // Script function
    FunctionValue(std::string name, std::shared_ptr<FunctionDecl> declaration,
                  std::shared_ptr<InstanceValue> bound_instance = nullptr)
        : name(std::move(name)), declaration(std::move(declaration)),
          is_native(false), bound_instance(std::move(bound_instance)) {}
    
    // Native function
    FunctionValue(std::string name, NativeFunction func)
        : name(std::move(name)), native_func(std::move(func)), is_native(true) {}
    
    Type type() const override { return Type::FUNCTION; }
    std::string to_string() const override { return "<function " + name + ">"; }
    ValuePtr clone() const override { return std::make_shared<FunctionValue>(*this); }
};

class ClassValue : public Value {
public:
    std::string name;
    std::map<std::string, std::string> fields; // field_name -> type_name
    std::map<std::string, std::shared_ptr<FunctionValue>> methods;
    
    explicit ClassValue(std::string name) : name(std::move(name)) {}
    
    Type type() const override { return Type::CLASS; }
    std::string to_string() const override { return "<class " + name + ">"; }
    ValuePtr clone() const override;
    
    void add_field(const std::string& name, const std::string& type) {
        fields[name] = type;
    }
    
    void add_method(const std::string& name, std::shared_ptr<FunctionValue> method) {
        methods[name] = std::move(method);
    }
};

class InstanceValue : public Value, public std::enable_shared_from_this<InstanceValue> {
public:
    std::shared_ptr<ClassValue> klass;
    std::map<std::string, ValuePtr> fields;
    
    explicit InstanceValue(std::shared_ptr<ClassValue> klass) : klass(std::move(klass)) {
        // Initialize fields with nil
        for (const auto& [field_name, type_name] : this->klass->fields) {
            fields[field_name] = std::make_shared<NilValue>();
        }
    }
    
    Type type() const override { return Type::INSTANCE; }
    std::string to_string() const override { return "<instance of " + klass->name + ">"; }
    ValuePtr clone() const override;
    
    ValuePtr get(const std::string& name) const;
    void set(const std::string& name, ValuePtr value);
};

// Helper functions
inline bool is_truthy(const ValuePtr& value) {
    if (!value || value->type() == Type::NIL) return false;
    if (value->type() == Type::BOOL) {
        return std::dynamic_pointer_cast<BoolValue>(value)->value;
    }
    return true;
}

inline bool values_equal(const ValuePtr& a, const ValuePtr& b) {
    if (!a || !b) return false;
    if (a->type() != b->type()) return false;
    
    switch (a->type()) {
        case Type::NIL:
            return true;
        case Type::NUMBER:
            return std::dynamic_pointer_cast<NumberValue>(a)->value ==
                   std::dynamic_pointer_cast<NumberValue>(b)->value;
        case Type::STRING:
            return std::dynamic_pointer_cast<StringValue>(a)->value ==
                   std::dynamic_pointer_cast<StringValue>(b)->value;
        case Type::BOOL:
            return std::dynamic_pointer_cast<BoolValue>(a)->value ==
                   std::dynamic_pointer_cast<BoolValue>(b)->value;
        default:
            return false;
    }
}

} // namespace camellya

#endif // CAMELLYA_VALUE_H