#pragma once
#include "sol/sol.hpp"

#include <string>
#include <map>
#include <unordered_map>
#include <memory>
#include <functional>
#include <optional>

#include "U_StringTemplate.h"

static bool lua_equal(const sol::object& a, const sol::object& b)
{
    sol::state_view lua = a.lua_state();
    if (a.get_type() != b.get_type())
    {
        return false;
    }

    switch (a.get_type())
    {
        case sol::type::nil:
            return true;
        case sol::type::boolean:
            return a.as<bool>() == b.as<bool>();
        case sol::type::number:
            return a.as<double>() == b.as<double>();
        case sol::type::string:
            return a.as<std::string>() == b.as<std::string>();
        default:
            break;
    }

    sol::function eq = lua["__cpp_eq"];
    if (!eq.valid())
    {
        lua["__cpp_eq"] = lua.safe_script
        (
            "return function(a, b) return a == b end",
            sol::script_pass_on_error
        );
        eq = lua["__cpp_eq"];
    }
    return eq(a, b);
}

class CScriptFieldBase
{
public:
    CScriptFieldBase() = delete;
    CScriptFieldBase(bool readonly = false) : ReadOnly(readonly) {}

	bool ReadOnly = false;
	
	virtual void SetObject(sol::object obj) = 0;
    virtual sol::object GetObject(sol::state_view s) = 0;
};

template<typename T>
class CScriptField : public CScriptFieldBase
{
public:
    CScriptField() : CScriptFieldBase(false) {}
    CScriptField(const T& val, bool readonly = false) : CScriptFieldBase(readonly), Value(val) {}
    CScriptField(bool readonly) : CScriptFieldBase(readonly) {}

	T Value;

	void SetObject(sol::object obj) override
	{
        if constexpr(std::is_same_v<T, sol::object>)
        {
            Value = obj;
        }
        else
        {
		    Value = obj.as<T>();
        }
	};

    sol::object GetObject(sol::state_view s) override
    {
        if constexpr(std::is_same_v<T, sol::object>)
        {
            return Value;
        }
        else
        {
            return sol::make_object<T>(s, Value);
        }
    }
};

template<typename T>
class CProxyScriptField : public CScriptFieldBase
{
public:
    CProxyScriptField() = delete;
    CProxyScriptField(T& val, bool readonly = false) : CScriptFieldBase(readonly), Value(val) {}

	T& Value;

	void SetObject(sol::object obj) override
	{
        if constexpr(std::is_same_v<T, sol::object>)
        {
            Value = obj;
        }
        else
        {
		    Value = obj.as<T>();
        }
	};

    sol::object GetObject(sol::state_view s) override
    {
        if constexpr(std::is_same_v<T, sol::object>)
        {
            return Value;
        }
        else
        {
            return sol::make_object<T>(s, Value);
        }
    }
};

class CFunctionalScriptField : public CScriptFieldBase
{
public:
    using SetterFunc = std::function<void(sol::object)>;
    using GetterFunc = std::function<sol::object(sol::state_view)>;

    using SetterFuncPtr = std::unique_ptr<SetterFunc>;
    using GetterFuncPtr = std::unique_ptr<GetterFunc>;

    SetterFuncPtr Setter;
    GetterFuncPtr Getter;

    CFunctionalScriptField() = delete;
    CFunctionalScriptField(GetterFunc getter, SetterFunc setter, bool readonly = false);
    CFunctionalScriptField(GetterFunc getter); //only readonly

	void SetObject(sol::object obj) override;
    sol::object GetObject(sol::state_view s) override;
};

class CScriptFieldsManager //manages __index and __newindex
{
public:
    class CKeyBase
    {
    public:
        virtual ~CKeyBase() = default;
        virtual bool operator==(const sol::object& obj) const { return false; }
        virtual bool operator==(const CKeyBase* obj) const { return false; }

        virtual std::string GetString() const { return std::string(); }
        virtual std::size_t Hash() const { return 0; }
    };

    template<typename T>
    class CKey : public CKeyBase
    {
    public:
        T Value;
        CKey(T val) : Value(val) {} //TODO is ref needed?

        bool operator==(const sol::object& obj) const override
        {
            if constexpr (std::is_same_v<T, sol::object>)
            {
                return obj.valid() && lua_equal(obj, Value);
            }
            else
            {
                return obj.valid() && obj.is<T>() && obj.as<T>() == Value;
            }
        }

        bool operator==(const CKeyBase* other) const override
        {
            const CKey<T>* otherKey = dynamic_cast<const CKey<T>*>(other);
            return otherKey && otherKey->Value == Value;
        }

        std::string GetString() const override
        {
            if constexpr (std::is_same_v<T, sol::object>)
            {
                if(Value.template is<std::string>())
                {
                    return "sol::object (string): " + Value.template as<std::string>();
                }
                else if(Value.template is<int>())
                {
                    return "sol::object (int): " + std::to_string(Value.template as<int>());
                }
                return "sol::object";
            }
            else if constexpr (std::is_same_v<T, sol::table>)
            {
                return "sol::table";
            }
            else if constexpr (std::is_same_v<T, std::string>)
            {
                return Value;
            }
            else if constexpr (std::is_same_v<T, std::wstring>)
            {
                return "std::wstring";
            }
            else
            {
                return std::to_string(Value);
            }
        }

        std::size_t Hash() const override
        {
            if constexpr (std::is_same_v<T, sol::object>)
            {
                if (!Value.valid())
                {
                    return 0;
                }

                sol::type t = Value.get_type();
                switch (t)
                {
                    case sol::type::number:
                        return std::hash<double>()(Value.template as<double>());
                    case sol::type::string:
                        return std::hash<std::string>()(Value.template as<std::string>());
                    case sol::type::boolean:
                        return std::hash<bool>()(Value.template as<bool>());
                    case sol::type::userdata:
                    case sol::type::lightuserdata:
                    case sol::type::table:
                    case sol::type::function:
                    {
                        lua_State* L = Value.lua_state();
                        Value.push();
                        const void* ptr = lua_topointer(L, -1);
                        lua_pop(L, 1);
                        return std::hash<const void*>()(ptr);
                    }
                    case sol::type::nil:
                    default:
                        return 0;
                }
            }
            else
            {
                return std::hash<T>()(Value);
            }
        }
    };

    using CKeyPtr = std::unique_ptr<CKeyBase>;

    struct CKeyPtrHash
    {
        std::size_t operator()(const CKeyPtr& k) const
        {
            return k ? k->Hash() : 0;
        }
    };

    struct CKeyPtrEqual
    {
        bool operator()(const CKeyPtr& lhs, const CKeyPtr& rhs) const
        {
            if (!lhs || !rhs) { return lhs == rhs; }
            return *lhs == rhs.get();
        }
    };

    using Optional = std::optional<sol::object>;
    using IndexFunc = std::function<Optional(sol::table, sol::object, sol::this_state)>;
    using NewIndexFunc = std::function<std::optional<sol::object>(sol::table, sol::object, sol::object, sol::this_state)>;

    bool FieldCreationAbility = true;
    std::unordered_map<CKeyPtr, CKeyPtr, CKeyPtrHash, CKeyPtrEqual> Aliases;
    std::unordered_map<CKeyPtr, std::unique_ptr<CScriptFieldBase>, CKeyPtrHash, CKeyPtrEqual> Fields;

    std::vector<IndexFunc> IndexCheckers;
    std::vector<NewIndexFunc> NewIndexCheckers;

    CScriptFieldBase* AddField(std::unique_ptr<CKeyBase>&& key, std::unique_ptr<CScriptFieldBase>&& ptr)
    {
        if (!ptr || !key) { return nullptr; }

        auto ret = Fields.emplace(std::make_pair(std::move(key), std::move(ptr)));
        return ret.second ? ret.first->second.get() : nullptr;
    }

    template<typename T>
    CScriptFieldBase* AddField(const T& key, std::unique_ptr<CScriptFieldBase>&& ptr)
    {
        auto normalized_key = normalize_string(key);
        using KeyType = decltype(normalized_key);

        auto key_ptr = std::make_unique<CKey<KeyType>>(normalized_key);
        return AddField(std::unique_ptr<CKeyBase>(std::move(key_ptr)), std::move(ptr));
    }

    auto FindAliasForObject(sol::object obj)
    {
        return std::find_if(Aliases.begin(), Aliases.end(), [obj](auto& kv) -> bool
        {
            return (kv.first && obj.valid()) && (*kv.first) == obj;
        });
    }

    auto GetFieldForObject(sol::object obj)
    {
        auto alias = FindAliasForObject(obj);
        if(alias != Aliases.end())
        {
            auto& aliased_key = alias->second;

            auto aliased_it = std::find_if(Fields.begin(), Fields.end(), [&aliased_key, obj](auto& kv) -> bool
            {
                return (kv.first && obj.valid()) && ((*kv.first) == aliased_key.get());
            });

            if(aliased_it != Fields.end()) { return aliased_it; }
        }

        auto it = std::find_if(Fields.begin(), Fields.end(), [obj](auto& kv) -> bool
        {
            return (kv.first && obj.valid()) && (*kv.first) == obj;
        });

        return it;
    }

    auto FindAlias(CKeyBase* alias)
    {
        return std::find_if(Aliases.begin(), Aliases.end(), [&alias](auto& kv) -> bool
        {
            return (kv.first && alias) && (*kv.first) == alias;
        });
    }

    auto GetFieldIterator(CKeyBase* key)
    {
        if(!key) { return Fields.end(); }

        auto alias = FindAlias(key);
        if(alias != Aliases.end())
        {
            auto& aliased_key = alias->second;
            auto aliased_it = std::find_if(Fields.begin(), Fields.end(), [&aliased_key](auto& kv) -> bool
            {
                return (kv.first && aliased_key && kv.second) && ((*kv.first) == aliased_key.get() && kv.second.operator bool());
            });

            if(aliased_it != Fields.end()) { return aliased_it; }
        }

        auto it = std::find_if(Fields.begin(), Fields.end(), [&key](auto& kv) -> bool
        {
            return (kv.first && kv.second && key) && ((*kv.first) == key && kv.second.operator bool());
        });

        return it;
    }

    auto GetFieldIterator(std::unique_ptr<CKeyBase>&& key)
    {
        return GetFieldIterator(key.get());
    }

    template<typename T>
    auto GetFieldIterator(const T& key)
    {
        auto key_ptr = std::make_unique<CKey<T>>(key);
        return GetFieldIterator(static_cast<CKeyBase*>(key_ptr.get()));
    }

    CScriptFieldBase* GetField(CKeyBase* key)
    {
        auto it = GetFieldIterator(key);
        return (it != Fields.end()) ? it->second.get() : nullptr;
    }

    CScriptFieldBase* GetField(std::unique_ptr<CKeyBase>&& key)
    {
        return GetField(key.get());
    }

    template<typename T>
    CScriptFieldBase* GetField(const T& key)
    {
        auto key_ptr = std::make_unique<CKey<T>>(key);
        return GetField(static_cast<CKeyBase*>(key_ptr.get()));
    }

    void SetMetaFunctions(sol::table meta_table)
    {
        meta_table["__index"] = [this](sol::table table, sol::object key, sol::this_state s) -> sol::object
        {
            auto it = GetFieldForObject(key);

            if(it != Fields.end())
            {
                return it->second->GetObject(sol::state_view(s));
            }

            for(auto& checker : IndexCheckers)
            {
                auto ret = checker(table, key, s);

                if(ret.has_value())
                {
                    return ret.value();
                }
            }

            return sol::lua_nil;
        };
        
        meta_table["__newindex"] = [this](sol::table table, sol::object key, sol::object value, sol::this_state s) -> void
        {
            auto it = GetFieldForObject(key);
            
            if(it != Fields.end() && !it->second->ReadOnly)
            {
                return it->second->SetObject(value);
            }

            bool checkerFound = false;
            for(auto& checker : NewIndexCheckers)
            {
                auto ret = checker(table, key, value, s);

                if(ret.has_value())
                {
                    ret.value() = value;
                    checkerFound = true;
                }
            }

            if(!checkerFound && it == Fields.end() && FieldCreationAbility)
            {
                //auto field = std::make_unique<CScriptField<sol::object>>(value);
                //AddField(key, std::move(field));

                table.raw_set(key, value);
            }
        };
    }

    bool AddAlias(std::unique_ptr<CKeyBase>&& alias, std::unique_ptr<CKeyBase>&& target_key)
    {
        if(!alias || !target_key || FindAlias(alias.get()) != Aliases.end()) { return false; }

        auto ret = Aliases.emplace(std::make_pair(std::move(alias), std::move(target_key)));
        return ret.second;
    }

    template<typename TypeAlias>
    bool AddAlias(const TypeAlias& alias, std::unique_ptr<CKeyBase>&& target_key)
    {
        auto alias_ptr = std::make_unique<CKey<TypeAlias>>(alias);
        return AddAlias(std::unique_ptr<CKeyBase>(std::move(alias_ptr)), std::move(target_key));
    }

    template<typename TypeTarget>
    bool AddAlias(std::unique_ptr<CKeyBase>&& alias, const TypeTarget& target_key)
    {
        auto target_ptr = std::make_unique<CKey<TypeTarget>>(target_key);
        return AddAlias(std::move(alias), std::unique_ptr<CKeyBase>(std::move(target_ptr)));
    }

    template<typename TypeAlias, typename TypeTarget>
    bool AddAlias(const TypeAlias& alias, const TypeTarget& target_key)
    {
        auto alias_ptr = std::make_unique<CKey<TypeAlias>>(alias);
        auto target_ptr = std::make_unique<CKey<TypeTarget>>(target_key);

        return AddAlias(std::unique_ptr<CKeyBase>(std::move(alias_ptr)), std::unique_ptr<CKeyBase>(std::move(target_ptr)));
    }

    bool IsAliasExist(CKeyBase* alias)
    {
        return FindAlias(alias) != Aliases.end();
    }

    bool IsAliasExist(std::unique_ptr<CKeyBase>&& alias)
    {
        return FindAlias(alias.get()) != Aliases.end();
    }

    template<typename TypeAlias>
    bool IsAliasExist(const TypeAlias& alias)
    {
        auto alias_ptr = std::make_unique<CKey<TypeAlias>>(alias);
        return FindAlias(alias_ptr.get()) != Aliases.end();
    }

    bool DeleteAlias(std::unique_ptr<CKeyBase>&& alias)
    {
        auto it = FindAlias(alias.get());
        if(it == Aliases.end()) { return false; }

        Aliases.erase(it);
        return true;
    }

    bool DeleteAlias(CKeyBase* alias)
    {
        auto it = FindAlias(alias);
        if(it == Aliases.end()) { return false; }

        Aliases.erase(it);
        return true;
    }

    template<typename TypeAlias>
    bool DeleteAlias(const TypeAlias& alias)
    {
        auto alias_ptr = std::make_unique<CKey<TypeAlias>>(alias);
        auto it = FindAlias(alias_ptr.get());
        if(it == Aliases.end()) { return false; }

        Aliases.erase(it);
        return true;
    }

    bool IsFieldExist(std::unique_ptr<CKeyBase>&& key)
    {
        return GetFieldIterator(static_cast<CKeyBase*>(key.get())) != Fields.end();
    }

    bool IsFieldExist(CKeyBase* key)
    {
        return GetFieldIterator(key) != Fields.end();
    }

    template<typename T>
    bool IsFieldExist(const T& key)
    {
        auto key_ptr = std::make_unique<CKey<T>>(key);
        return GetFieldIterator(static_cast<CKeyBase*>(key_ptr.get())) != Fields.end();
    }

    void AddIndexChecker(const IndexFunc& func)
    {
        IndexCheckers.push_back(func);
    }

    void AddNewIndexChecker(const NewIndexFunc& func)
    {
        NewIndexCheckers.push_back(func);
    }

    static std::string GetDefaultKey() { return "__fields_manager"; }

    static bool HasFieldsManager(sol::table tabl)
    {
        sol::object fieldsMan_obj = tabl[GetDefaultKey()];
        return fieldsMan_obj.valid();
    }

    sol::table CreateMetaTable(sol::table def_table)
    {
        sol::table meta = sol::state_view(def_table.lua_state()).create_table();

        SetMetaFunctions(meta);
        def_table[sol::metatable_key] = meta;

        return meta;
    }

    static std::shared_ptr<CScriptFieldsManager> CreateFieldsManager(sol::table tabl, bool instantMeta = false)
    {
        sol::object fieldsMan = tabl.get<sol::object>(GetDefaultKey());
        if(fieldsMan != sol::lua_nil) { return fieldsMan.as<std::shared_ptr<CScriptFieldsManager>>(); }

        auto fieldsManager = std::make_shared<CScriptFieldsManager>();
        tabl[GetDefaultKey()] = fieldsManager;

        if(instantMeta)
        {
            fieldsManager->CreateMetaTable(tabl);
        }
        return fieldsManager;
    }

    static std::pair<std::shared_ptr<CScriptFieldsManager>, bool> ValidateFieldsManager(sol::table tabl, bool instantMeta = false)
    {
        sol::object fieldsMan_obj = tabl[GetDefaultKey()];
        if(fieldsMan_obj.valid())
        {
            return  { fieldsMan_obj.as<std::shared_ptr<CScriptFieldsManager>>(), true };
        }
        return { CreateFieldsManager(tabl, instantMeta), false };
    }
};

using CScriptFieldsManagerPtr = std::shared_ptr<CScriptFieldsManager>;