obs={utils={}};utils={properties_names={}};__settings__=nil
__LIST_SCENE_ITEMS__={};__active_tbs_ctr__={}
-- function print_source_settings(source_name)
-- 	local sor= obslua.obs_get_source_by_name(source_name)
-- 	local source_settings= obslua.obs_source_get_settings(sor)
-- 	local settings_json=obslua.obs_data_get_json_pretty(source_settings)
-- 	print("[SETTINGS]")
-- 	print("SOURCE-ID-TYPE: " .. tostring(obslua.obs_source_get_unversioned_id(sor)))
-- 	print(settings_json)
-- 	print("==============")
-- 	obslua.obs_source_release(sor)
-- 	obslua.obs_data_release(source_settings)
-- end
local __START_HOTKEY_ID= obslua.OBS_INVALID_HOTKEY_ID
local __STOP_HOTKEY_ID= obslua.OBS_INVALID_HOTKEY_ID
function script_load(settings)
	-- print("LOAD")
	-- obslua.obs_source_valid(nil)
	-- print("IS OK!")
	__settings__= PairStack(settings, nil, true);
	--print_source_settings("test_label")
	__START_HOTKEY_ID = obslua.obs_hotkey_register_frontend(script_path() .. "_start_hotkey","[Nxup] START", start)
	__STOP_HOTKEY_ID = obslua.obs_hotkey_register_frontend(script_path() .. "_stop_hotkey","[Nxup] STOP", Eterminate)
	local start_name_id=script_path() .. "_start_hotkey"
	local stop_name_id=script_path() .. "_stop_hotkey"
	local hotkey_start_arr_t= __settings__.get_arr(start_name_id)
	local hotkey_stop_arr_t= __settings__.get_arr(stop_name_id)
	if hotkey_start_arr_t and hotkey_start_arr_t.data then
		obslua.obs_hotkey_load(__START_HOTKEY_ID, hotkey_start_arr_t.data)
		hotkey_start_arr_t.free()
	end
	if hotkey_stop_arr_t and hotkey_stop_arr_t.data then
		obslua.obs_hotkey_load(__STOP_HOTKEY_ID, hotkey_stop_arr_t.data)
		hotkey_stop_arr_t.free()
	end

	obslua.obs_frontend_add_event_callback(ftHandlerWF)
end
function script_save(settings)
	--print("[SCRIPT-SAVE]")
	__settings__= PairStack(settings, nil, true);
	local start_hotkey_id= script_path() .. "_start_hotkey"
	local stop_hotkey_id = script_path() .. "_stop_hotkey"
	local hotkey_start_arr_t= obslua.obs_hotkey_save(__START_HOTKEY_ID)
	local hotkey_stop_arr_t= obslua.obs_hotkey_save(__STOP_HOTKEY_ID)
	if hotkey_start_arr_t then
		__settings__.arr(start_hotkey_id, hotkey_start_arr_t)
		obslua.obs_data_array_release(hotkey_start_arr_t)
	end
	if hotkey_stop_arr_t then
		__settings__.arr(stop_hotkey_id, hotkey_stop_arr_t)
		obslua.obs_data_array_release(hotkey_stop_arr_t)
	end
end
function script_unload()
	Eterminate()
end
function script_defaults(settings)
	--Eterminate()
	__settings__= PairStack(settings, nil, true);
	local scene_name=obs.utils:get_current_scene_name()
	__settings__.int("add_form_exec", 0, true)
	__settings__.str("add_form_id", "", true)
	__settings__.str("add_form_type", "<def>", true)
	__settings__.str("add_form_title", "", true)
	__settings__.str("add_form_dur", "", true)
	__settings__.bul("add_form_auto_init", false)
	__settings__.str("add_form_style_type","<def>")
	__settings__.str("add_form_placement_type","<tl>")
	local coll=__settings__.get_arr("nxup-collection-arr-".. tostring(scene_name))
	if coll == nil or coll.data == nil then
		coll= ArrayStack()
		__settings__.arr("nxup-collection-arr-"..tostring(scene_name), coll.data)
	end
	coll.free()
end

function script_properties()
	local scene_name=obs.utils:get_current_scene_name()
    local p= obs.create();
    local add_new= obs.button(p, "add_new","➕",function(_p,_pp, settings)
		OpenNewForm(p, settings)
		return true
	end)
	-- [[ SCENE SEPEIFIC ]]
	local scene_op= obs.create()
	local scene_op_gp= obs.group(p, "scene_op_group", scene_name, obslua.OBS_GROUP_NORMAL, scene_op)
	-- [[ ADD FORM ]]
	local form_op= obs.create()
	local view_op= obs.create()
	local add_form= obs.group(p, "addform", "ADD EVENT", obslua.OBS_GROUP_NORMAL , form_op)
	local add_form_exec= obs.list(form_op, "add_form_exec","exec:", obslua.OBS_COMBO_TYPE_LIST, obslua.OBS_COMBO_FORMAT_STRING);
	add_form_exec.add_str("<def>", "default")
	local add_form_id= obs.text(form_op, "add_form_id", "unique ID: ", obslua.OBS_TEXT_DEFAULT)
	add_form_id.hint("(<b style='color:orange'>required</b>) Create a unique id that will be used to refer back to this event can be anything from <strong>A-z 0-9_$@#</strong>")
	local add_form_type= obs.list(form_op, "add_form_type","type:", obslua.OBS_COMBO_TYPE_LIST, obslua.OBS_COMBO_FORMAT_STRING );
	add_form_type.add_str("<time>", "Time event")
	--add_form_type.add_str("<prog>", "Progress event")
	local add_form_style_type= obs.list(form_op, "add_form_style_type", "layout:", obslua.OBS_COMBO_TYPE_LIST, obslua.OBS_COMBO_FORMAT_STRING)
	add_form_style_type.add_str("<def>", "vertical").add_str("<hor>", "horizontal")
	add_form_style_type.hint("This is the layout of the event, you can choose between vertical or horizontal layout, default is vertical")
	local add_form_placement_type= obs.list(form_op, "add_form_placement_type", "placement:", obslua.OBS_COMBO_TYPE_LIST, obslua.OBS_COMBO_FORMAT_STRING)
	add_form_placement_type.add_str("<tl>", "top left").add_str("<tr>", "top right").add_str("<bl>", "bottom left").add_str("<br>", "bottom right")

	local add_form_title= obs.text(form_op, "add_form_title", "title:", obslua.OBS_TEXT_DEFAULT)
	local add_form_dur=obs.text(form_op, "add_form_dur", "duration:", obslua.OBS_TEXT_DEFAULT)
	add_form_dur.hint([[(<b style='color:orange'>required</b>) the duration represents hh:mm:ss e.g <strong>(00:10:00)</strong> this is how long the event will begin in.]])
	local add_form_auto_init= obs.bool(form_op, "add_form_auto_init", "Auto initialize")
	add_form_auto_init.hint([[If this is checked the sources will be created instantly]])
	local add_form_error_label= obs.text(form_op, "add_form_error_label", "", obslua.OBS_TEXT_INFO)
	add_form_error_label.hide()
	local add_form_action= obs.button(form_op, "add_form_action", "Submit",function(_p,_pp, s)
		local scene_name= obs.utils:get_current_scene_name()
		add_form_error_label.hide();add_form_error_label.text("")
		local exec_value= __settings__.get_str("add_form_exec")
		local id_value= __settings__.get_str("add_form_id")
		local type_value= __settings__.get_str("add_form_type")
		local title_value= __settings__.get_str("add_form_title")
		local length_value= __settings__.get_str('add_form_dur')
		local layout_value= __settings__.get_str("add_form_style_type")
		local placement_value= __settings__.get_str("add_form_placement_type")
		local auto_init= __settings__.get_bul("add_form_auto_init")
		local coll= __settings__.get_arr("nxup-collection-arr-"..tostring(scene_name))
		if not coll or not coll.data then
			add_form_error_label.show()
			add_form_error_label.error("Error: Something went wrong, please try again later or remove the plugin and re-add it")
			return true
		end
		if not id_value or id_value == "" then
			add_form_error_label.warn("Error: ID is required, please enter a valid ID")
			add_form_error_label.show()
			return true
		end
		-- check if id_value is valid
		if not id_value:match("^[A-Za-z0-9_$@#]+$") then
			add_form_error_label.warn("Error: ID can only contain letters, numbers, and special characters ($, _, @, #)")
			add_form_error_label.show()
			return true
		end
		if not type_value or type_value == "<def>" then
			add_form_error_label.warn("Error: Type is required, please select a valid type")
			add_form_error_label.show()
			return true
		end
		
		if not title_value or title_value == "" then
			add_form_error_label.warn("Error: Title is required, please enter a valid title")
			add_form_error_label.show()
			return true
		end

		-- length_value is a string time format e.g 00:10:00 convert it to seconds using a regex
		if not length_value or length_value == "" then
			add_form_error_label.warn("Error: duration is required, please enter a valid time format (hh:mm:ss)")
			add_form_error_label.show()
			return true
		end
		local time_pattern = "(%d+):(%d+):(%d+)"
		local hours, minutes, seconds = length_value:match(time_pattern)
		if not hours or not minutes or not seconds then
			add_form_error_label.warn("Error: duration is required, please enter a valid time format (hh:mm:ss)")
			add_form_error_label.show()
			return true
		end
		hours = tonumber(hours) or 0
		minutes = tonumber(minutes) or 0
		seconds = tonumber(seconds) or 0
		if hours < 0 or minutes < 0 or seconds < 0 then
			add_form_error_label.warn("Error: duration cannot be negative, please enter a valid time format (hh:mm:ss)")
			add_form_error_label.show()
			return true
		end
		local total_seconds = (hours * 3600) + (minutes * 60) + seconds
		if total_seconds <= 0 then
			add_form_error_label.warn("Error: duration should be at least 1 second, please enter a valid time format (hh:mm:ss)")
			add_form_error_label.show()
			return true
		end




		-- make sure id is valid by checking for valid characters
		-- by checking if it already exists
		for i=0, coll.size()-1 do
			local item= coll.next()
			if item and item.data ~= nil then
				local id= item.get_str("uniqid")
				if id == id_value then
					item.free();coll.free()
					add_form_error_label.warn("Error: ID already exists, please use a different ID")
					add_form_error_label.show()
					return true
				end
				item.free()
			end
		end
		local event= PairStack()
		event.str("uniqid", id_value)
		event.str("title", title_value)
		event.str("type", type_value)
		event.str("time", length_value)
		event.str("exec", exec_value)
		event.bul("active", true)
		event.str("layout", layout_value)
		event.str("placement", placement_value)
		event.int("dura", total_seconds)
		event.bul("auto_init", auto_init)
		coll.insert(event.data)
		if auto_init then
			local obj= RunEvent(event)
			if obj then obj:init(); scheduler(150).after(function() obj.free() end) end
		end
		-- auto run when the hotkey is triggered!
		if isActive and exec_value == "<def>" then
			local obj= RunEvent(event)
			table.insert(__active_tbs_ctr__, obj)
			obj:init()
			obj:start()
		end
		event.free();coll.free()
		add_form.hide();add_new.show()

		AddNewForm(scene_op, id_value, title_value, type_value, length_value, exec_value, layout_value, placement_value)
		scene_op_gp.show()
		-- update the collection output
		__settings__.str("add_form_exec","<def>")
		__settings__.str("add_form_id","")
		__settings__.str("add_form_type","<def>")
		__settings__.str("add_form_title","")
		__settings__.str("add_form_dur","")
		__settings__.str("add_form_style_type","<def>")
		__settings__.str("add_form_placement_type","<tl>")
		__settings__.bul("add_form_auto_init",false)
		return true
	end)
	local add_form_close=obs.button(form_op, "add_form_close", "Close", function(_p,_pp, s)
		add_form.hide();add_new.show();scene_op_gp.show()
		return true;
	end);
	add_form.hide()
	local coll= __settings__.get_arr("nxup-collection-arr-"..tostring(scene_name));
	if coll and coll.data then
		for i=0, coll.size()-1 do
			local item= coll.next()
			if item and item.data ~= nil then
				local id= item.get_str("uniqid")
				local title= item.get_str("title")
				local type= item.get_str("type")
				local time= item.get_str("time")
				local exec= item.get_str("exec")
				local layout= item.get_str("layout")
				local placement= item.get_str("placement")
				if id and id ~= "" then
					local form= AddNewForm(scene_op, id, title, type, time, exec, layout, placement)
					if not form then
						obslua.script_log(obslua.LOG_ERROR, "Failed to add form for " .. id)
					end
				end
				item.free()
			end
		end
		coll.free()
	else
		--obslua.script_log(obslua.LOG_ERROR, "Failed to load collection data")
	end

    obs.text(p, "description_bottom_label", index());
    return p
end
function script_description()
    return [[
        <pre>Add upcoming events for stream</pre>
        <hr>
    ]]
end
function AddNewForm(p, uniqid, title, type, time, exec, layout, placement)
	if not p or not uniqid or not title or not type or not time or not exec or not layout or not placement then
		return false
	end
	local form= obs.utils.get(p, uniqid);
	if form and form.get() ~= nil then
		return false
	end
	local pp= obs.create()
	form= obs.group(p, uniqid, uniqid, obslua.OBS_GROUP_CHECKABLE , pp)
	form.onchange(function(p,pp, settings)
		local is_checked = __settings__.get_bul(uniqid);
		-- update active status
		local scene_name= obs.utils:get_current_scene_name()
		local coll= __settings__.get_arr("nxup-collection-arr-"..tostring(scene_name));
		if not coll or not coll.data then
			obslua.script_log(obslua.LOG_ERROR, "Failed to load collection data")
			return false
		end
		for i=0, coll.size()-1 do
			local item= coll.next()
			if item and item.data ~= nil then
				local id= item.get_str("uniqid")
				if id == uniqid then
					item.bul("active", is_checked)
					-- auto start if active
					if is_checked and isActive and item.get_str("exec") == "<def>" then
						EterminateById(id)
						local obj= RunEvent(item)
						table.insert(__active_tbs_ctr__, obj)
						obj:init()
						obj:start()
						break
					elseif is_checked == false and isActive then
						EterminateById(id)
					end
					item.free()
					break
				end
				item.free()
			end
		end
		coll.free()
	end)
	local title_label= obs.text(pp, uniqid .. "_title", "<h1>" .. title.."</h1>", obslua.OBS_TEXT_INFO)
	local delete_btn= obs.button(pp, uniqid .. "_delete", "Delete", function()
		local scene_name= obs.utils:get_current_scene_name()
		local coll= __settings__.get_arr("nxup-collection-arr-" ..tostring(scene_name));
		if not coll or not coll.data then
			obslua.script_log(obslua.LOG_ERROR, "Failed to load collection data")
			return false
		end
		
		for i=0, coll.size()-1 do
			local item= coll.next()
			if item and item.data ~= nil then
				local id= item.get_str("uniqid")
				if id == uniqid then
					EterminateById(uniqid)
					scheduler(180).after(function()
						local scene= obs.utils:get_scene()
						local sceneitem_label_t= scene.get_label(scene_name .. "_" .. id .. "_interval_label")
						local sceneitem_timer_t= scene.get_label(scene_name .. "_" .. id.. "_label_title")
						if sceneitem_label_t and sceneitem_label_t.data then
							sceneitem_label_t.remove()
						end
						if sceneitem_timer_t and sceneitem_timer_t.data then
							sceneitem_timer_t.remove()
						end
						scene.free()
					end)
					coll.rm(i)
					item.free();coll.free()
					break
				end
				item.free()
			end
		end
		coll.free()
		form.free(p)
		return true
	end)
	return true
end
function OpenNewForm(p, settings)
	__settings__.str("add_form_exec", "<def>")
	__settings__.str("add_form_id", "")
	__settings__.str("add_form_type", "<def>")
	__settings__.str("add_form_title", "")
	__settings__.str("add_form_dur", "")
	local scene_name= obs.utils:get_current_scene_name()
	local grp= obs.utils.get(p, "scene_op_group")
	local form= obs.utils.get(p, "addform")
	local add_new= obs.utils.get(p, "add_new")
	local add_form_exec= obs.utils.get(p, "add_form_exec")
	
	add_new.hide();form.show();grp.hide()
	local cl= __settings__.get_arr("nxup-collection-arr-"..tostring(scene_name));
	add_form_exec.clear().add_str("<def>", "default")
	if not cl or not cl.data then
		add_form_exec.add_str("<none>","(Add more events to see others option)").cursor().disabled()
	else
		for i=0, cl.size()-1 do
			local item= cl.next()
			if item and item.data then
				local id= item.get_str("uniqid")
				local title= item.get_str("title")
				if id and id ~= "" then
					add_form_exec.add_str(id, "after (" .. id .. ") => " .. title)
				end
				item.free()
			end
		end
	end
	cl.free()
	return true
end
function index()
	return [[
        <p><b>Useful Links</b></p>
		<p><pre>Video Tutorial: <a href="https://youtu.be/A2DSBEOfKCA">click here</a></pre></p>
		<p></p>
		<p><b>Dev</b></p>
		<p><pre>Author: <i>@iixisii</i></pre></p>
		<p><pre>updates follow <a href="https://twitter.com/XDeviixisiiX">XDeviixisiiX</a></pre></p>
    ]]
end
isActive=false

-- [[ FRONTEND EVENT CALLBACK ]]
function ftHandlerWF(event_id)
	if event_id == obslua.OBS_FRONTEND_EVENT_SCENE_CHANGED or event_id == 24 or 
	event_id == obslua.OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING or
	event_id == obslua.OBS_FRONTEND_EVENT_PROFILE_CHANGING or
	event_id == obslua.OBS_FRONTEND_EVENT_SCENE_LIST_CHANGED
	then
		Eterminate()
	end
end
-- [[ START FUNCTION ]]
function RunEvent(event)
	-- if not event.get_bul("active") then
	-- 	return nil
	-- end
	local ctr={
		id = event.get_str("uniqid");
		isActive=false;tm=0
	}
	local interval_label=nil
	local title_label= nil
	function ctr:init()
		local scene= obs.utils:get_scene()
		local uniqid= event.get_str("uniqid")
		local title= event.get_str("title")
		local type_value=event.get_str("type")
		local timer_value= event.get_str("time")
		local exec_value= event.get_str("exec")
		local layout_value= event.get_str("layout")
		local placement_value= event.get_str("placement")
		local scene_name= obs.utils:get_current_scene_name()
		-- create group source

		-- local scene_item_group= scene.get_group(uniqid)

		-- if not scene_item_group or scene_item_group.data == nil then
		-- 	scene_item_group= scene.add_group(uniqid)
		-- end
		-- create title source label
		title_label= scene.get_label(scene_name .. "_" .. uniqid.. "_label_title")
		if not title_label or title_label.data == nil then
			title_label=  scene.add_label(scene_name .. "_" .. uniqid .. "_label_title", title)
			-- scene_item_group.add(scene_item_label.data)
		end
		interval_label= scene.get_label(scene_name .. "_" .. uniqid .. "_interval_label")

		-- create timer source label
		if type_value == "<time>" then
			if not interval_label or  interval_label.data == nil then
				
				interval_label= scene.add_label(scene_name .. "_" .. uniqid .. "_interval_label")
				if interval_label and interval_label.data then
					--scene_item_group.add(interval_label.data)
					interval_label.text(timer_value)
					--interval_label.font.size(72)

					scheduler(100).after(function()
						local scene= obs.utils:get_scene()
						local scene_name= obs.utils:get_current_scene_name()
						local interval_label= scene.get_label(scene_name .. "_" .. uniqid .. "_interval_label")
						if not interval_label or not interval_label.data then
							return false
						end
						local title_label= scene.get_label(scene_name .. "_" .. uniqid.. "_label_title")
						if not title_label or not title_label.data then
							return false
						end
						local screen_width= scene.get_width()
						local screen_height= scene.get_height()
						local pos_y=0;local pos_x=0
						if placement_value == "<bl>" or placement_value == "<br>" then
							pos_y=screen_height - (title_label.size.height() + interval_label.size.height())
							if layout_value ~="<hor>" then
								pos_y= pos_y - interval_label.size.height()
							end
						end
						if placement_value == "<br>" or placement_value == "<tr>" then
							pos_x= screen_width - (title_label.size.width() + 10)
							if layout_value == "<hor>" then
								pos_x= pos_x - (interval_label.size.width() + 10)
							end
						end
						title_label.pos.x(pos_x)
						title_label.pos.y(pos_y)
						if layout_value == "<hor>" then
							interval_label.pos.x(title_label.pos.x() + title_label.size.width() + 10)
							interval_label.pos.y(title_label.pos.y())
						else -- default value is always vertical
							local xx = 0
							if placement_value == "<tr>" or placement_value == "<br>" then
								xx= (screen_width - (interval_label.size.width() + 10))
							else
								xx=title_label.pos.x() + 10
							end
							interval_label.pos.x(xx)
							interval_label.pos.y(title_label.pos.y() + title_label.size.height() + 10)
						end
						interval_label.free()
						title_label.free()
						scene.free()
						return true
					end)
				end
			end
		end

		-- if interval_label and interval_label.data then
		-- 	interval_label.free()
		-- end
		-- if title_label and title_label.data then
		-- 	title_label.free()
		-- end
		-- if scene_item_group and scene_item_group.data then
		-- 	scene_item_group.free()
		-- end
		scene.free()
		return true
	end

	local function startTime()
		if not ctr.isActive then
			return
		end
		if not event or event.data == nil then
			ctr:stop()
			return nil
		end
		local unid= event.get_str("uniqid")
		--local interval_label= scene.get_label(unid .. "_interval_label")
		if interval_label and interval_label.data then
			interval_label.text(seconds_tfmt(ctr.tm))
			--interval_label.free()
		else -- handle a callback

		end
		if(ctr.tm <=0) then
			--- [REMOVE ALL THE SOURCES CREATED (?)]
			

			-- [ CALLBACK WHEN THE EVENT IS DONE ]				
			local scene_name=obs.utils:get_current_scene_name()
			local coll= __settings__.get_arr("nxup-collection-arr-".. tostring(scene_name))
			local next_event= coll.find("exec", unid)
			if next_event and next_event.data ~= nil then 
				title_label.hide();interval_label.hide()
				local obj= RunEvent(next_event)
				table.insert(__active_tbs_ctr__, obj)
				coll.free()
				obj:init()
				obj:start()
				ctr:stop()
				EterminateById(ctr.id)
				return
			end
			coll.free()
			ctr:stop()
			EterminateById(ctr.id)
			local account_alive=0
			for i=0, #__active_tbs_ctr__ do
				if __active_tbs_ctr__[0] ~= nil then
					account_alive = account_alive+ 1; break
				end
			end
			if #__active_tbs_ctr__ == 0 or account_alive == 0 then
				isActive=false
			end
			return
		end
		ctr.tm=ctr.tm-1
	end
	function ctr:start()
		if ctr.isActive or event.get_bul("active") == false then
			return false
		end
		title_label.show();interval_label.show()
		ctr.tm=event.get_int("dura")
		ctr.isActive=true;--startTime()
		return obslua.timer_add(startTime, 1000)
	end
	function ctr:stop()
		ctr.isActive=false
		return obslua.timer_remove(startTime)
	end
	function ctr.free()
		if ctr then ctr:stop() end
		---EterminateRemoveById(ctr.id)
		ctr=nil
		if title_label and title_label.data then 
			--title_label.remove() 
			title_label.free()
		end
		if interval_label and interval_label.data then 
			--interval_label.remove() 
			interval_label.free()
		end
		if event and event.data then return event.free() end
		return false
	end
	return ctr
end
function EterminateById(id)
	--print("[EterminateById Before] " .. tostring(id) .. " #" .. tostring(#__active_tbs_ctr__))
	local delete_index=nil
	for i=1, #__active_tbs_ctr__ do
		local item=__active_tbs_ctr__[i]
		if item ~= nil and item.id == id then
			--print("[ID FOUND]")
			item.free();delete_index=i;
			break
		end
	end
	if delete_index ~= nil and __active_tbs_ctr__[delete_index] and __active_tbs_ctr__[delete_index].id == id then table.remove(__active_tbs_ctr__, delete_index) end
	if #__active_tbs_ctr__ == 0 then
		isActive= false
	end
	--print("[EterminateById After] #" .. tostring(#__active_tbs_ctr__))
end
function EterminateRemoveById(id)
	--print("[EterminateRemoveById Before] " .. tostring(id) .. " #" .. tostring(#__active_tbs_ctr__))
	local delete_index=nil
	for i=1, #__active_tbs_ctr__ do
		local item=__active_tbs_ctr__[i]
		if item ~= nil and item.id == id then
			--print("[ID FOUND]")
			delete_index=i;
			break
		end
	end
	if delete_index ~= nil and __active_tbs_ctr__[delete_index] and __active_tbs_ctr__[delete_index].id == id then table.remove(__active_tbs_ctr__, delete_index) end
	if #__active_tbs_ctr__ == 0 then
		isActive= false
	end
	--print("[EterminateRemoveById After] #" .. tostring(#__active_tbs_ctr__))
end
function Eterminate()
	isActive=false
	for i=1, #__active_tbs_ctr__ do
		local item=__active_tbs_ctr__[i]
		if item ~= nil then
			item.free()
		end
	end
	__active_tbs_ctr__={}
end
function start(isPressed)
	if not isPressed or isActive then
		return false
	end
	isActive= true
	-- local source_label= obs.utils:get_source("1234_label_title")
	-- if not source_label or not source_label.data then
	-- 	return false
	-- end
	-- source_label.free()

	-- return false -- debug ONLY USE




	-- testing (MAKE SURE TO REMOVE ONCE DONE!)
	-- local scene_name=obs.utils:get_current_scene_name()
	-- local coll= __settings__.get_arr("nxup-collection-arr-".. tostring(scene_name))
	-- if coll and coll.data ~= nil then
	-- 	--print("create....")
	-- 	local n= coll.next()
	-- 	local ef= create(n)
	-- 	ef:init()
	-- 	n.free()
	-- 	coll.free()
	-- 	--print("done....")
	-- end

	-- [[ ONLY ACTIVATE IF 'exec' IS SET TO <def>]]
	local scene_name=obs.utils:get_current_scene_name()
	local coll= __settings__.get_arr("nxup-collection-arr-".. tostring(scene_name))
	if not coll or coll.data == nil then
		isActive=false
		return false
	end
	for i = 0, coll.size()-1 do
		local item= coll.next()
		local obj= RunEvent(item)
		if item.get_str("exec") == "<def>" and item.get_bul("active") then
			table.insert(__active_tbs_ctr__, obj)
			obj:init()
			obj:start()
		else
			item.free()
		end
	end
	coll.free()
end


-- [[ MY OWN CUSTOM OBS API ]]
function seconds_tfmt(scs)
	local hours= math.floor(scs/3600)
	local minutes= math.floor((scs%3600)/60)
	local seconds= math.floor(scs%60)
	return string.format("%02d:%02d:%02d", hours, minutes, seconds)
end
function obs.utils:get_source(source_name)
	if not source_name or not type(source_name) == "string" then
		return nil
	end
	local source = obslua.obs_get_source_by_name(source_name)
	if not source then
		return nil
	end
	return obs_wrap_source(source, OBS_SRC_TYPE)
end
function obs.utils:get_scene(scene_name)
	local scene;local source_scene;
	if not scene_name or not type(scene_name) == "string" then
		source_scene=obslua.obs_frontend_get_current_scene()
		if not source_scene then
			return nil
		end
		scene= obslua.obs_scene_from_source(source_scene)
	else
		source_scene= obslua.obs_get_source_by_name(scene_name)
		if not source_scene then
			return nil
		end
		scene=obslua.obs_scene_from_source(source_scene)
	end
	local obj_scene_t;obj_scene_t= {
		get_all_groups_names=function()
			local scene_items_list = obs_wrap_source(
				obslua.obs_scene_enum_items(scene),
				OBS_SCENEITEM_LIST_TYPE
			)
			if scene_items_list == nil or scene_items_list.data == nil then
				return nil
			end
			local list={}
			for _, item in ipairs(scene_items_list.data) do
				local source = obslua.obs_sceneitem_get_source(item)
				if source ~= nil then
					local sourceName = obslua.obs_source_get_name(source)
					if obslua.obs_sceneitem_is_group(item) then
						table.insert(list, sourceName)
					end
				end
			end
			scene_items_list.free()
			return list
		end;
		get= function(source_name)
			local source = obs.utils:get_source(source_name)

			if source == nil or source.data == nil then return nil end
			local scene_item = obs_wrap_source(
				obslua.obs_scene_sceneitem_from_source(scene, source.data),
				OBS_SCENEITEM_TYPE
			)
			-- check in groups if the current item doesn't exist;
			if not scene_item or scene_item.data == nil then
				scene_item=nil
				for _, gN in ipairs(obj_scene_t.get_all_groups_names()) do
					local groupSource =	obslua.obs_get_source_by_name(gN)
					if groupSource then
						local groupItem = obslua.obs_scene_sceneitem_from_source(scene, groupSource)
						obslua.obs_source_release(groupSource)
						if groupItem then -- iterate through the items in the group and check for (item_name);
							local hasItem = false
							local __ls = obslua.obs_sceneitem_group_enum_items(groupItem)
							if __ls ~= nil then
								for _, it in ipairs(__ls) do
									local s = obslua.obs_sceneitem_get_source(it)
									if s ~= nil then
										local sN = obslua.obs_source_get_name(s)
										if sN == item_name then
											obslua.obs_sceneitem_addref(it)
											scene_item = it
											hasItem = true; break
										end
									end
								end
								obslua.sceneitem_list_release(__ls)
							end
							obslua.obs_sceneitem_release(groupItem)
							if hasItem then
								break
							end
						end
						
					end
				end
				if scene_item then
					scene_item = obs_wrap_source(scene_item, OBS_SCENEITEM_TYPE)
				else
					source.free()
					return nil
				end
			end
			source.free()
			local obj_source_t;obj_source_t={
				free=scene_item.free;
				item=scene_item.data;
				data=scene_item.data;
				get_source=function()
                    return obslua.obs_sceneitem_get_source(scene_item.data)
                end
				
			}
			return obj_source_t
		end;add=function(source)
			if not source then return false end
			local sceneitem= obslua.obs_scene_add(scene, source)
			if sceneitem == nil then return nil end
			obslua.obs_sceneitem_addref(sceneitem)
			return obs_wrap_source(sceneitem, OBS_SCENEITEM_TYPE)
		end;get_label=function(name, source)
			if (source == nil or source.data == nil) and name ~= nil and type(name) == "string" and name ~= "" then
				source= obj_scene_t.get(name)
			end
			if not source or not source.data then
				return nil 
			end
			local obj_label_t;obj_label_t={
				remove= function()
					if obj_label_t.data == nil then return true end
					obslua.obs_sceneitem_remove(obj_label_t.data)
					source.free(); obj_label_t.data=nil;obj_label_t.item=nil
					return true
				end;
				hide= function()
					return obslua.obs_sceneitem_set_visible(obj_label_t.data, false)
				end;show = function()
					return obslua.obs_sceneitem_set_visible(obj_label_t.data, true)
				end;
				font= {
					size= function(font_size)
						local src= PairStack(
							obslua.obs_source_get_settings(source.get_source()),
							nil,true
						)
						if not src or not src.data then
							src= PairStack()
						end
						local font= src.get_obj("font")
						if not font or not font.data then
							font= PairStack()
							--font.str("face","Arial")
						end
						if font_size == nil or not type(font_size) == "number" or font_size <= 0 then
							font_size=font.get_int("size")
							font.free();src.free();
							return font_size
						else
							font.int("size", font_size)
						end
						font.free();
						obslua.obs_source_update(source.get_source(), src.data)
						src.free()
						return true
					end;face= function(face_name)
					end
				};text=function(txt)
					local src= PairStack(
						obslua.obs_source_get_settings(source.get_source()),
						nil,true
					)
					if not src or not src.data then
						src= PairStack()
					end
					local res=true
					if txt == nil or txt == "" or type(txt) ~= "string" then
						res=src.get_str("text")
						if not res == nil then
							res= ""
						end
					else
						src.str("text", txt)
					end
					obslua.obs_source_update(source.get_source(), src.data)
					src.free()
					return res
				end;free=function()
					source.free()
					obj_label_t=nil
					return true
				end;data=source.data;item=source.data;size={
					width= function(w)

						--local default_transform= obslua.obs_transform_info()
						--local default_source_info=obslua.obs_source_info()
						--obslua.obs_source_get_info(source.get_source(), default_source_info)
						--obslua.obs_sceneitem_get_info(source.data, default_transform)
						local default_width= obslua.obs_source_get_width(source.get_source())
						--local default_scale_x= default_transform.scale.x;

						if w == nil then return default_width end
						return w
					end;
					height= function(h)
						local default_height= obslua.obs_source_get_height(source.get_source())
						if h == nil then return default_height end
						return h
					end;
				};pos = {
					x=function(val)
						local default_transform= obslua.obs_transform_info()
						obslua.obs_sceneitem_get_info(source.data, default_transform)
						if val == nil then return default_transform.pos.x end
						default_transform.pos.x= val
						obslua.obs_sceneitem_set_info(source.data, default_transform)
						return true
					end;
					y=function(val)
						local default_transform= obslua.obs_transform_info()
						obslua.obs_sceneitem_get_info(source.data, default_transform)
						if val == nil then return default_transform.pos.y end
						default_transform.pos.y= val
						obslua.obs_sceneitem_set_info(source.data, default_transform)
						return true
					end;
				}
			}
			return obj_label_t
		end;
		add_label= function(name, text)
			local src= PairStack()
			if not text then
				text= "Text - Label"
			end
			src.str("text", text)
			local source_label=obslua.obs_source_create("text_gdiplus", name, src.data, nil)
			src.free()
			local obj= obj_scene_t.get_label(
				nil, obj_scene_t.add(source_label)
			)
			if not obj or not obj.data then 
				if source_label then obslua.obs_source_release(source_label) end
				return nil
			end
			-- re-write the release function
            -- [[SEEM LIKE THIS LEADS TO CRUSHES?]]
			local free_func= obj.free;
			obj.free= function()
				obslua.obs_source_release(source_label)
				return free_func()
			end
			return obj
		end;add_group= function(name, refresh)
			if refresh == nil then
				refresh=true
			end
			local obj=obj_scene_t.get_group(nil, obslua.obs_scene_add_group2(scene, name, refresh))
			if not obj or obj.data == nil then return nil end
			-- overwrite the free function to prevent crush/bugs
			obj.free=function() end
			return obj
		end;get_group= function(name, gp)
			local obj;if not gp and name ~= nil then
				obj= obs_wrap_source(obslua.obs_scene_get_group(scene, name), OBS_SCENEITEM_TYPE)
			elseif gp ~= nil then
				obj= obs_wrap_source(gp, OBS_SCENEITEM_TYPE)
			else
				return nil
			end
			obj["add"]= function(sceneitem)
				if not sceneitem then
					return false
				end
				obslua.obs_sceneitem_group_add_item(obj.data, sceneitem)
				return true
			end
			obj["release"]= function()
				return obj.free()
			end;obj["item"]= obj.data
			return obj
		end;free= function()
			obslua.obs_source_release(source_scene)
			scene=nil
		end;release= function()
			return obj_scene_t.free()
		end;get_width= function()
			return obslua.obs_source_get_width(source_scene)
		end;get_height = function()
			return obslua.obs_source_get_height(source_scene)
		end
	};
	return obj_scene_t
end
function obs.utils:get_current_scene_name()
	source_scene=obslua.obs_frontend_get_current_scene()
	if not source_scene then
		return nil
	end
	local source_name= obslua.obs_source_get_name(source_scene)
	obslua.obs_source_release(source_scene)
	return source_name
end
function obs.utils:add_to_scene(source)
	if not source then
		return false
	end
	local current_source_scene= obslua.obs_frontend_get_current_scene()
	if not current_source_scene then
		return false
	end
	local current_scene= obslua.obs_scene_from_source(current_source_scene)
	if not current_scene then
		obslua.obs_source_release(current_source_scene)
		return false
	end
	obslua.obs_scene_add(current_scene, source)
	obslua.obs_source_release(current_source_scene)
	return true
end
function obs.create()
    return obslua.obs_properties_create()
end
function obs.list(p, name, label, type, format)
    return obs.utils.obs_api_properties_patch(obslua.obs_properties_add_list(p, name, label, type, format))
end
function obs.button(p, name, label, callback)
    if type(callback)~="function" then callback=function() end end
    return obs.utils.obs_api_properties_patch(obslua.obs_properties_add_button(p, name, label, callback))
end
function obs.text(p, name, label, enum_type)
    if(enum_type == nil) then
        enum_type= obslua.OBS_TEXT_INFO;
    end
    return obs.utils.obs_api_properties_patch(obslua.obs_properties_add_text(p, name, label, enum_type))
end 
function obs.group(p, name, desc, enum_type, op)
	return obs.utils.obs_api_properties_patch(obslua.obs_properties_add_group(p, name, desc, enum_type, op))
end
function obs.bool(p, name, desc)
	return obs.utils.obs_api_properties_patch(obslua.obs_properties_add_bool(p, name, desc))
end
-- [[ UTILS ]]
function utils.get_all_source_names_from_scene(scene_name, ignoreSource)
	local source_name_list = nil
	-- Get the current scene
	local currentScene = obslua.obs_get_scene_by_name(scene_name)
	if not currentScene then
		return {}
	end
	if currentScene ~= nil then
		-- Enumerate the items in the current scene
		local sceneItems = obslua.obs_scene_enum_items(currentScene)
		if sceneItems ~= nil then
			source_name_list = {}
			for _, sceneItem in ipairs(sceneItems) do
				local source = obslua.obs_sceneitem_get_source(sceneItem)
				if source ~= nil then
					
						
					local sourceName = obslua.obs_source_get_name(source)
					if obslua.obs_sceneitem_is_group(sceneItem) then
						local __ls = obslua.obs_sceneitem_group_enum_items(sceneItem)
						if __ls ~= nil then
							-- iterate through all the items in the group;
							for _, it in ipairs(__ls) do
								local s = obslua.obs_sceneitem_get_source(it)
								if s ~= nil then
									local sN = obslua.obs_source_get_name(s)
									if not ignoreSource then
										table.insert(source_name_list, sN)
									elseif ignoreSource ~= sN then
										table.insert(source_name_list, sN)
									end
								end
							end
							obslua.sceneitem_list_release(__ls)
						
						end
					end
					if not ignoreSource then
						table.insert(source_name_list, sourceName)
					elseif ignoreSource ~= sourceName then
						table.insert(source_name_list, sourceName)
					end
				end
			end
		end
		-- Release the scene items list
		obslua.sceneitem_list_release(sceneItems)
	end
	obslua.obs_scene_release(currentScene)
	return source_name_list
end

-- [[ API UTILS ]]
function obs.utils.obs_api_properties_patch(pp, cb)
	local pp_unique_name= obslua.obs_property_name(pp)
	local item=nil;local objText;local objGlobal={
		cb=cb;disabled=function()
			obslua.obs_property_set_disabled(pp, true)
			return nil
		end;enabled=function()
			obslua.obs_property_set_disabled(pp, false)
			return nil
		end;onchange=function(callback)
			obslua.obs_property_set_modified_callback(pp, function(p, pp, settings)
				return callback(p, pp, settings)
			end);
			return nil
		end;hide= function()
			obslua.obs_property_set_visible(pp, false)
		end;show = function()
			obslua.obs_property_set_visible(pp, true)
			return nil
		end;get= function()
			return pp
		end;hint= function(txt)
			item=obslua.obs_property_set_long_description(pp, txt)
			return nil
		end;free= function(p)
			obslua.obs_properties_remove_by_name(p, pp_unique_name)
			return true
		end;
	};objText={
		error=function(txt)
			obslua.obs_property_text_set_info_type(pp, obslua.OBS_TEXT_INFO_ERROR)
			obslua.obs_property_set_description(pp, txt)
			return objText
		end;
		text=function(txt)
			obslua.obs_property_text_set_info_type(pp, obslua.OBS_TEXT_INFO)
			obslua.obs_property_set_description(pp, txt)
			return objText
		end;warn=function(txt)
			obslua.obs_property_text_set_info_type(pp, obslua.OBS_TEXT_INFO_WARNING)
			obslua.obs_property_set_description(pp, txt)
			return objText
		end;
	};local objList;objList={
		item=nil;clear= function()
			objList.item=obslua.obs_property_list_clear(pp)
			return objList
		end;add_str= function(id, title)
			objList.item=obslua.obs_property_list_add_string(pp, title, id)
			return objList
		end;add_int= function(id, title) 
			objList.item=obslua.obs_property_list_add_int(pp, title, id)
			return objList
		end;cursor = function(index)
			
			local nn_obj=nil;nn_obj={
				disabled= function()
					obslua.obs_property_list_item_disable(pp, objList.item, true)
					return nn_obj
				end; enabled= function()
					obslua.obs_property_list_item_disable(pp, objList.item, false)
					return nn_obj
				end;
				ret=function()
					return objList
				end
			}
			return nn_obj;
		end
	};local objButton;objButton={
		item=nil;click= function(callback)
			if type(callback) ~= "function" then
				obslua.script_log(obslua.LOG_ERROR, "[button.click] invalid callback type " .. type(callback))
				return objButton
			end
			objButton.item=obslua.obs_property_button_set_callback(pp, function(p, pp, settings)
				return callback(p, pp, settings)
			end)
			return objButton
		end;
	};local objGroup;objGroup={};
	local property_type= obslua.obs_property_get_type(pp)
	if property_type == obslua.OBS_PROPERTY_GROUP then
		table.append(objGroup, objGlobal)
		return objGroup;
	elseif property_type == obslua.OBS_PROPERTY_LIST then
		table.append(objList, objGlobal)
		return objList;
	elseif property_type == obslua.OBS_PROPERTY_BUTTON then
		table.append(objButton, objGlobal)
		return objButton;
	elseif property_type == obslua.OBS_PROPERTY_TEXT then
		table.append(objText, objGlobal)
		return objText;
	else
		return objGlobal;
	end
end
function obs.utils.get(pp, name)
	return obs.utils.obs_api_properties_patch(obslua.obs_properties_get(pp, name))
end





-- [[ OTHER UTILS ]]
function table.append(tb, vv)
  for k, v in pairs(vv) do
	if type(v) == "function" then
		local old_v = v
		v = function(...)
			local retValue= old_v(...)
			if retValue== nil then
				return tb;
			end
			return retValue;
		end
	end
    if type(k) == "string" then
      tb[k]= v;
    else
      table.insert(tb, k, v)
    end
  end
end
-- schedule an event
scheduled_events = {}
function scheduler(timeout)
    -- if type(timeout) ~= "number" or timeout < 0 then
    --     return obs.script_log(obslua.LOG_ERROR, "[Scheduler] invalid timeout value")
    -- end
    local scheduler_callback = nil
    local function interval()
        obslua.timer_remove(interval)
        if type(scheduler_callback) ~= "function" then
            return
        end
        return scheduler_callback(scheduler_callback)
    end
    
    local self = nil; self = {
        after = function(callback)
            if type(callback) == "function" or type(timeout) ~= "number" or timeout < 0 then
                scheduler_callback = callback
            else
                obslua.script_log(obslua.LOG_ERROR, "[Scheduler] invalid callback/timeout " .. type(callback))
                return false
            end
            obslua.timer_add(interval, timeout)
        end;push = function(callback)
            if callback == nil or type(callback) ~= "function" then
                obslua.script_log(obslua.LOG_WARNING, "[Scheduler] invalid callback at {push} " .. type(callback))
                return false
            end
            obslua.timer_add(callback, timeout)
            table.insert(scheduled_events, callback)
            return {
                clear = function()
                    if callback == nil or type(callback) ~= "function" then
                        return nil
                    end
                    return obslua.timer_remove(callback)
                end;
            }
        end; clear = function()
            if scheduler_callback ~= nil then
                obslua.timer_remove(scheduler_callback)
            end
            for _, clb in pairs(scheduled_events) do
                obslua.timer_remove(clb)
            end
            scheduled_events = {}; scheduler_callback = nil
        end
    }
    return self
end

OBS_SCENEITEM_TYPE = 1;OBS_SRC_TYPE = 2;OBS_OBJ_TYPE = 3
OBS_ARR_TYPE = 4;OBS_SCENE_TYPE = 5;OBS_SCENEITEM_LIST_TYPE = 6
OBS_SRC_LIST_TYPE = 7;OBS_UN_IN_TYPE = -1
obs_wrap_source = {};
function obs_wrap_source(object, object_type)
	local self = nil
	self = {
		type = object_type, data = object;item=object;
        get_source=function()
            if self.type == OBS_SRC_TYPE then
                return self.data
            elseif self.type == OBS_SCENEITEM_TYPE then
                return obslua.obs_sceneitem_get_source(self.data)
            else
                return self.data
            end
        end;
		free = function()
			if self.type == OBS_SCENE_TYPE then
				obslua.obs_scene_release(self.data)
			elseif self.type == OBS_SRC_TYPE then
				obslua.obs_source_release(self.data)
			elseif self.type == OBS_ARR_TYPE then
				obslua.obs_data_array_release(self.data)
			elseif self.type == OBS_OBJ_TYPE then
				obslua.obs_data_release(self.data)
			elseif self.type == OBS_SCENEITEM_TYPE then
				obslua.obs_sceneitem_release(self.data)
			elseif self.type == OBS_SCENEITEM_LIST_TYPE then
				obslua.sceneitem_list_release(self.data)
			elseif self.type == OBS_SRC_LIST_TYPE then
				obslua.source_list_release(self.data)
			elseif self.type == OBS_UN_IN_TYPE then
				self.data = nil;self.item=nil
				return
			else
				self.data = nil
			end
		end
	}
	table.insert(error_wrapper, self)
	return self
end

error_freed = 0
error_wrapper = {};function error_wrapper_handler (callback)
	return function(...)
		local args = {...}
		local data = nil
		local caller = ""
		for i, v in ipairs(args) do
			if caller ~= "" then
				caller = caller .. ","
			end
			caller = caller .. "args[" .. tostring(i) .. "]"
		end
		caller = "return function(callback,args) return callback(" .. caller .. ") end";
		local run = loadstring(caller)
		local success, result = pcall(function()
			data = run()(callback, args)
		end)
		if not success then
			error_freed = 0
			for _, iter in pairs(error_wrapper) do
				if iter and type(iter.free) == "function" then
					local s, r = pcall(function()
						iter.free()
					end)
					if s then
						error_freed = error_freed + 1
					end
				end
			end
			obslua.script_log(obslua.LOG_ERROR, "[ErrorWrapper ERROR] => " .. tostring(result))
		end
		return data
	end
end
-- array handle
function ArrayStack(stack, name, ignoreStack)
	if not ignoreStack then 
		if type(stack) ~= "userdata" then
			stack = nil
		elseif stack and (type(name) ~= "string" or name == "")then
			stack = nil
			obslua.script_log(obslua.LOG_ERROR, "FAILED TO LOAD AN [ArrayStack] INVALID NAME GIVEN")
			return nil
		end
	end
	local self = nil
	self = {
		index = 0;get = function(index)
			if type(index) ~= "number" or index < 0 or index > self.size() then
				return nil
			end
			return PairStack(obslua.obs_data_array_item(self.data, index), nil, true)
		end;next = function()
			if type(self.index) ~= "number" or self.index < 0 or self.index > self.size() then
				return nil
			end
			local temp = self.index;self.index = self.index + 1
			return PairStack(obslua.obs_data_array_item(self.data, temp), nil, true)
		end;find= function(key, value)
			for i=0, self.size() - 1 do
				local itm= self.next()
				if itm.get_str(key) == value or itm.get_int(key) == value 
				or itm.get_bul(key) == value or itm.get_dbl(key) == value then
					return itm
				end
				itm.free()
			end
			return nil
		end;
		
		free = function()
			if self.data == nil then
				return false
			end
			obslua.obs_data_array_release(self.data)
			self.data = nil
			return true
		end;insert = error_wrapper_handler(function(value)
			if value == nil or type(value) ~= "userdata" then
				obslua.script_log("FAILED TO INSERT OBJECT INTO [ArrayStack]")
				return false
			end
			obslua.obs_data_array_push_back(self.data, value)
			return self
		end); size = error_wrapper_handler(function()
			
			if self.data == nil then
				return 0
			end
			return obslua.obs_data_array_count(self.data);
		end); rm= error_wrapper_handler(function(idx)
			if idx < 0 or self.size() <=0 or idx > self.size() then
				obslua.script_log("FAILED TO RM DATA FROM [ArrayStack] (INVALID IDX)")
				return false
			end
			obslua.obs_data_array_erase(self.data, idx)
			return self
		end)
	}
	if not ignoreStack then
		if stack and name then
			self.data = obslua.obs_data_get_array(stack, name)
		else
			self.data = obslua.obs_data_array_create()
		end
	else
		self.data = stack
	end
	table.insert(error_wrapper, self)
	return self
end
-- pair stack used to manage memory stuff :)
function PairStack(stack, name, ignoreStack)
	if not ignoreStack then
		if type(stack) ~= "userdata" then
			stack = nil
		elseif stack and (type(name) ~= "string" or name == "")then
			stack = nil
			obslua.script_log(obslua.LOG_ERROR, "FAILED TO LOAD AN [PairStack] INVALID NAME GIVEN")
			return nil
		end
	end
	local self = nil; self = {
		free = function()
			if self.data == nil then
				return false
			end
			obslua.obs_data_release(self.data)
			self.data = nil
			return true
		end; str = error_wrapper_handler(function(name, value, def)

			if (name == nil or type(name) ~= "string" or name == "") or (self.data == nil or type(self.data) ~= "userdata") or (value == nil or type(value) ~="string") then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO INSERT STR INTO [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return false
			end
            if def then
                obslua.obs_data_set_default_string(self.data, name, value)
            else
                obslua.obs_data_set_string(self.data, name, value)
            end
            return self
		end);int = error_wrapper_handler(function(name, value, def)
			if (name == nil or type(name) ~= "string" or name == "") or (self.data == nil or type(self.data) ~= "userdata") or (value == nil or type(value) ~="number") then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO INSERT INT INTO [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return false
			end
            if def then
                obslua.obs_data_set_default_int(self.data, name, value)
            else
			    obslua.obs_data_set_int(self.data, name, value)
            end
            return self
		end);dbl=error_wrapper_handler(function(name, value, def)
			if (name == nil or type(name) ~= "string" or name == "") or (self.data == nil or type(self.data) ~= "userdata") or (value == nil or type(value) ~="number") then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO INSERT INT INTO [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if def then
                obslua.obs_data_set_default_double(self.data, name, value)
            else
			    obslua.obs_data_set_double(self.data, name, value)
            end
            return self
		end);bul = error_wrapper_handler(function(name, value, def)
			if (name == nil or type(name) ~= "string" or name == "") or (self.data == nil or type(self.data) ~= "userdata") or (type(value) == "nil" or type(value) ~="boolean") then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO INSERT BUL [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if def then
                obslua.obs_data_set_default_bool(self.data, name, value)
            else
			    obslua.obs_data_set_bool(self.data, name, value)
            end
            return self
		end); arr = error_wrapper_handler(function(name, value, def)
			if (name == nil or type(name) ~= "string" or name == "") or (self.data == nil or type(self.data) ~= "userdata") or (type(value) ~="userdata") then
				
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO INSERT ARR INTO [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if def then
                obslua.obs_data_set_default_array(self.data, name, value)
            else
			    obslua.obs_data_set_array(self.data, name, value)
            end
            return self
		end); obj = error_wrapper_handler(function(name, value, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata") or (type(value) ~="userdata") then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO INSERT OBJ INTO [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if def then
                obslua.obs_data_set_default_obj(self.data, name, value)
            else
			    obslua.obs_data_set_obj(self.data, name, value)
            end
            return self
		end);
		-- getter
		get_str = error_wrapper_handler(function(name, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata")then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO GET STR FROM [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if not def then
			    return obslua.obs_data_get_string(self.data, name)
            else
                return obslua.obs_data_get_default_string(self.data, name)
            end
		end);get_int = error_wrapper_handler(function(name, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata")then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO GET INT FROM [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if not def then
			    return obslua.obs_data_get_int(self.data, name)
            else
                return obslua.obs_data_get_default_int(self.data, name)
            end
		end);get_dbl = error_wrapper_handler(function(name, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata")then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO GET DBL FROM [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if not def then
			    return obslua.obs_data_get_double(self.data, name)
            else
                return obslua.obs_data_get_default_double(self.data, name)
            end
		end);get_obj = error_wrapper_handler(function(name, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata")then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO GET OBJ FROM [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if not def then
			    return PairStack(obslua.obs_data_get_obj(self.data, name), nil, true)
            else
                return PairStack(obslua.obs_data_get_default_obj(self.data, name), nil, true)
            end
		end);get_arr =error_wrapper_handler(function(name, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata")then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO GET ARR FROM [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if not def then
			    return ArrayStack(obslua.obs_data_get_array(self.data, name), nil, true)
            else
                return ArrayStack(obslua.obs_data_get_default_array(self.data, name), nil, true)
            end
		end);get_bul = error_wrapper_handler(function(name, def)
			if (name == nil or type(name) ~= "string" or name == "") or (type(self.data) ~= "userdata") then
				obslua.script_log(obslua.LOG_ERROR,"FAILED TO GET BUL FROM [PairStack] " .. "FOR [" .. tostring(name) .. "] " .. " OF VALUE [" .. tostring(value) .. "] TYPE: " .. tostring(type(value)))
				return nil
			end
            if not def then
			    return obslua.obs_data_get_bool(self.data, name)
            else
                return obslua.obs_data_get_default_bool(self.data, name)
            end
		end); del= error_wrapper_handler(function(name) 
			obslua.obs_data_erase(self.data, name)
			return true
		end)
	}
	if not ignoreStack then
		if stack and name then
			self.data = obslua.obs_data_get_obj(stack, name)
		else
			self.data = obslua.obs_data_create()
		end
	else
		self.data = stack
	end
	table.insert(error_wrapper, self)
	return self
end