// Copyright (c) 2004 Daniel Wallin and Arvid Norberg

// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.

#define LUABIND_BUILDING

#include <luabind/config.hpp>
#include <luabind/weak_ref.hpp>

#include <luabind/lua_include.hpp>

#include <algorithm>
#include <cassert>

namespace luabind {

namespace
{

    int weak_table_tag;
    int impl_table_tag;


    void get_weak_table(lua_State* L)
    {
        lua_rawgetp(L, LUA_REGISTRYINDEX, &weak_table_tag);

        if (lua_isnil(L, -1))
        {
            lua_pop(L, 1);
            lua_newtable(L);
            // metatable
            lua_createtable(L, 0, 1); // One non-sequence entry for __mode.
            lua_pushliteral(L, "__mode");
            lua_pushliteral(L, "v");
            lua_rawset(L, -3);
            // set metatable
            lua_setmetatable(L, -2);

            lua_pushvalue(L, -1);
            lua_rawsetp(L, LUA_REGISTRYINDEX, &weak_table_tag);

        }

    }

    void get_impl_table(lua_State* L)
    {

        lua_pushlightuserdata(L, &impl_table_tag);
        lua_rawget(L, LUA_REGISTRYINDEX);

        if (lua_isnil(L, -1))
        {
            lua_pop(L, 1);

            lua_newtable(L);
            lua_pushvalue(L, -1);
            lua_rawsetp(L, LUA_REGISTRYINDEX, &impl_table_tag);

        }
    }

} // namespace unnamed

    struct weak_ref::impl
    {
        impl(lua_State* main, lua_State* s, int index)
            : state(main)
            , count(0)
            , ref(0)
        {

            get_impl_table(s);
            lua_pushlightuserdata(s, this);
            ref = luaL_ref(s, -2);
            lua_pop(s, 1);

            get_weak_table(s);
            lua_pushvalue(s, index);
            lua_rawseti(s, -2, ref);
            lua_pop(s, 1);

        }

        ~impl()
        {
            get_impl_table(state);
            luaL_unref(state, -1, ref);
            lua_pop(state, 1);
        }

        lua_State* state;
        int count;
        int ref;
    };

    weak_ref::weak_ref()
        : m_impl(0)
    {
    }

    weak_ref::weak_ref(lua_State* main, lua_State* L, int index)
        : m_impl(new impl(main, L, index))
    {
        m_impl->count = 1;
    }

    weak_ref::weak_ref(weak_ref const& other)
        : m_impl(other.m_impl)
    {
        if (m_impl) ++m_impl->count;
    }

    weak_ref::~weak_ref()
    {
        if (m_impl && --m_impl->count == 0)
        {
            delete m_impl;
        }
    }

    weak_ref& weak_ref::operator=(weak_ref const& other)
    {
        weak_ref(other).swap(*this);
        return *this;
    }

    void weak_ref::swap(weak_ref& other)
    {
        std::swap(m_impl, other.m_impl);
    }

    int weak_ref::id() const
    {
        assert(m_impl);
        return m_impl->ref;
    }

    // L may not be the same pointer as
    // was used when creating this reference
    // since it may be a thread that shares
    // the same globals table.
    void weak_ref::get(lua_State* L) const
    {
        assert(m_impl);
        assert(L);
        get_weak_table(L);
        lua_rawgeti(L, -1, m_impl->ref);
        lua_remove(L, -2);
    }

    lua_State* weak_ref::state() const
    {
        assert(m_impl);
        return m_impl->state;
    }

} // namespace luabind
