#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include "Core/Object.h"
#include "Core/Property.h"
#include "Core/Serializable.h"

#include "Core/Serializable.h"

using namespace uLib;

class ReadOnlyTestObject : public Object {
public:
    int m_value;
    int getValue() const { return m_value; }
    
    enum State { State1, State2 };
    State m_state;
    State getState() const { return m_state; }

    ReadOnlyTestObject() : m_value(10), m_state(State1) {
        ULIB_ACTIVATE_PROPERTIES(*this);
    }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        // Lvalue reference - should be NOT read-only
        ar & HRP("lvalue_prop", m_value);
        
        // Rvalue from getter - should be read-only
        ar & HRP("rvalue_prop", getValue());
        
        // Enum lvalue - should be NOT read-only
        ar & boost::serialization::make_hrp_enum("lvalue_enum", (int&)m_state, {"State1", "State2"});
        
        // Enum rvalue - should be read-only
        ar & boost::serialization::make_hrp_enum("rvalue_enum", (int)getState(), {"State1", "State2"});
    }
};

int main() {
    std::cout << "Testing Read-Only Property Feature..." << std::endl;
    
    ReadOnlyTestObject obj;
    const auto& props = obj.GetProperties();
    
    std::cout << "Registered Properties in ReadOnlyTestObject:" << std::endl;
    bool found_lvalue = false;
    bool found_rvalue = false;
    bool found_lvalue_enum = false;
    bool found_rvalue_enum = false;

    for (auto* p : props) {
        bool ro = p->IsReadOnly();
        std::cout << "  - Name: " << p->GetName() 
                  << " | Type: " << p->GetTypeName() 
                  << " | ReadOnly: " << (ro ? "YES" : "NO") << std::endl;
        
        if (p->GetName() == "lvalue_prop") {
            if (ro) { std::cerr << "FAIL: lvalue_prop should NOT be read-only" << std::endl; return 1; }
            found_lvalue = true;
        } else if (p->GetName() == "rvalue_prop") {
            if (!ro) { std::cerr << "FAIL: rvalue_prop SHOULD be read-only" << std::endl; return 1; }
            found_rvalue = true;
        } else if (p->GetName() == "lvalue_enum") {
            if (ro) { std::cerr << "FAIL: lvalue_enum should NOT be read-only" << std::endl; return 1; }
            found_lvalue_enum = true;
        } else if (p->GetName() == "rvalue_enum") {
            if (!ro) { std::cerr << "FAIL: rvalue_enum SHOULD be read-only" << std::endl; return 1; }
            found_rvalue_enum = true;
        }
    }
    
    if (found_lvalue && found_rvalue && found_lvalue_enum && found_rvalue_enum) {
        std::cout << "TEST PASSED SUCCESSFULLY!" << std::endl;
        return 0;
    } else {
        std::cerr << "TEST FAILED: Some properties were not found!" << std::endl;
        return 1;
    }
}