namespace Luax
{

	//----------------------------------------------------------------------------------------------------------------
	// 接口

	///
	/// 对不同类型，通过调用GetLuaClassName获得类型名
	///
	template<typename T>
	int LuaxClass<T>::l_GetClassName(lua_State* L)
	{
		LUAX_SETUP(L, "*");

		cc8* type = T::GetLuaxClassName();
		state.Push(type);
		return 1;
	}

	//----------------------------------------------------------------------------------------------------------------

	///
	/// 注册工厂和单例共有的类成员
	/// 
	template<typename T>
	void LuaxClass<T>::RegisterLuaxClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetClassName", l_GetClassName },
			{ NULL,           NULL           }
		};

		state.RegisterMethods(regTable);
	}


	///
	/// 工厂类的成员，注册在class table
	///
	template<typename T>
	void LuaxClass<T>::RegisterLuaxFactoryClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetInterfaceTable", l_GetInterfaceTable },
			{ NULL,                NULL                }
		};

		state.RegisterMethods(regTable);
	}


	///
	/// 工厂实例的成员，注册在interface table
	///
	template<typename T>
	void LuaxClass<T>::RegisterLuaxInterface(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "__gc", l_GC },
			{ NULL,   NULL }
		};

		state.RegisterMethods(regTable);
	}


	///
	/// 单例类的成员，注册在class table
	///
	template<typename T>
	void LuaxClass<T>::RegisterLuaxSingletonClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ NULL, NULL }
		};

		state.RegisterMethods(regTable);
	}

	template<typename T>
	void LuaxClass<T>::PushInterfaceTable(LuaxState& state)
	{
		assert(mInterfaceTable);

		mInterfaceTable.PushRef(state);
	}

	template<typename T>
	void LuaxClass<T>::PushClassTable(LuaxState& state)
	{
		assert(mClassTable);

		mClassTable.PushRef(state);
	}

	template<typename T>
	void LuaxClass<T>::PushRefTable(LuaxState& state)
	{
		assert(mRefTable);

		mRefTable.Push(state);
	}

	template<typename T>
	void LuaxClass<T>::SetInterfaceTableRef(LuaxState& state, int idx)
	{
		mInterfaceTable.SetRef(state, idx);
	}

	template<typename T>
	void LuaxClass<T>::SetClassTableRef(LuaxState& state, int idx)
	{
		mClassTable.SetRef(state, idx);
	}

	template<typename T>
	LuaxClass<T>::LuaxClass()
		: mRC(1) // 构造时默认有一个引用
		, mSafer(false)
	{
	}

	template<typename T>
	LuaxClass<T>::~LuaxClass()
	{
		assert(mSafer);
	}

	template<typename T>
	void LuaxClass<T>::Retain()
	{
		++mRC;
	}

	template<typename T>
	void LuaxClass<T>::Release()
	{
		if (--mRC <= 0)
		{
			mSafer = true; // 打开析构safer
			delete this;
		}
	}

	template<typename T>
	bool LuaxClass<T>::PushLuaUserdata(LuaxState& state)
	{
		if (!mUserdata)
		{
			BindToLua(state);
			return true;
		}
		return mUserdata.PushRef(state);
	}

	template<typename T>
	void LuaxClass<T>::BindToLua(LuaxState& state)
	{
		assert(!mUserdata);

		// 创建userdata并留在栈顶
		state.PushPtrUserData(this);

		// 工厂
		if (!T::IsLuaxClassSingleton())
		{
			lua_newtable(state); // ref table
			lua_newtable(state); // member table
			LuaxClass<T>::PushInterfaceTable(state); // interface table

			// stack:
			// -1: interface table
			// -2: member table
			// -3: ref table
			// -4: userdata

			int top = state.GetTop();
			int memberTable = top - 1;
			int refTable = top - 2;

			// ref table 注册 __gc和__tostring
			lua_pushcfunction(state, LuaxClass<T>::l_GC);
			lua_setfield(state, refTable, "__gc");

			lua_pushcfunction(state, LuaxClass<T>::l_ToString);
			lua_setfield(state, refTable, "__tostring");

			// member table 设为 ref table 的 __index 和 __newindex
			lua_pushvalue(state, memberTable);
			lua_setfield(state, refTable, "__index");

			lua_pushvalue(state, memberTable);
			lua_setfield(state, refTable, "__newindex");

			// 设置元表
			lua_setmetatable(state, -2); // interface is meta of member
			lua_setmetatable(state, -2); // member is meta of ref
			lua_setmetatable(state, -2); // ref is meta of userdata
		}

		// 设置一个userdata的弱引用，方便通过native指针返回lua对象
		mUserdata.SetRef(state, -1);
		assert(mUserdata);

		if (T::IsLuaxClassSingleton())
		{

		}
	}

	//--------------------------------------------------------------------------------------------------------------

	///
	/// 释放工厂创建的实例
	///
	template<typename T>
	int LuaxClass<T>::l_GC(lua_State* L)
	{
		LUAX_SETUP(L, "U");

		return 0;
	}

	template<typename T>
	int LuaxClass<T>::l_ToString(lua_State* L)
	{
		return 0;
	}

	template<typename T>
	int LuaxClass<T>::l_ExtendFactory(lua_State* L)
	{
		return 0;
	}

	template<typename T>
	int LuaxClass<T>::l_GetInterfaceTable(lua_State* L)
	{
		LUAX_STATE(L);
		assert(mInterfaceTable);
		mInterfaceTable.PushRef(state);
		return 0;
	}

	template<typename T> LuaxStrongRef LuaxClass<T>::mInterfaceTable; // interface table 
	template<typename T> LuaxStrongRef LuaxClass<T>::mClassTable;     // class table
	template<typename T> LuaxStrongRef LuaxClass<T>::mRefTable;       // 单例

}