-- LUA Script - precede every function and global member with lowercase name of script + '_main'
local U = require "scriptbank\\utillib"
local Q = require "scriptbank\\quatlib"

local deg = math.deg
local rad = math.rad

local dynEnts = {}

function dynamic_entity_init_name( e, name )
	Include( "utillib.lua" )
	Include( "quatlib.lua" )
	
	Hide( e )
	dynEnts[ e ] = { entD = e, entB = nil, name = name, used = false, showing = false, list = nil }
end

-- function returns a list of registered entity ids for given name
function DE_GetEnts( entity, name )
	local entList = {}
	
	for k, v in pairs( dynEnts ) do
		if v.name == name and v.used and v.entB == entity then
			entList[ #entList + 1 ] = k
		end
	end
	
	return entList
end

-- creates list entry by calculating offsets between entities
local function build_list( be, de )
	local ent1, ent2 = g_Entity[ be ], g_Entity[ de ]
	
	local q1 = Q.FromEuler( rad( ent1.anglex), rad( ent1.angley ), rad( ent1.anglez ) )
	local q2 = Q.FromEuler( rad( ent2.anglex), rad( ent2.angley ), rad( ent2.anglez ) )

	return { xo = ent2.x - ent1.x, yo = ent2.y - ent1.y, zo = ent2.z - ent1.z, 
	         angQ = Q.Mul( Q.Conjugate( q1 ), q2 ) }
end

-- list contents 'normal'  { xo = <n>, yo = <n>, zo = <n>, (optional) angQ = <quat> }
--               'special' { frames = {[<frame_index]> = <normal_list> } }
-- scale is a list of the following form:
--     { min=<n>, max=<n>, frames=<n> }
-- min/max are scale values, spd is number of 'updates calls' expansion of contraction
-- occurs in
-- id is optional and allows a specific entity to be specified when you have lots
-- with the same name
function DE_Register( entity, name, list, scale, id )
	for k, v in pairs( dynEnts ) do
		if v.name == name and not v.used then
			local de = dynEnts[ k ]
			
			de.used = true
			de.entB = entity
			
			if list ~= nil then 
				de.list = list
			else
				de.list = build_list( entity, k )
			end
			
			if scale ~= nil then
				de.scale = scale
			end
			
			if id ~= nil then de.id = id end
			
			-- only register for one entity at a time
			return
		end
	end
end

-- used to change the list for a particular entity
function DE_ChangeList( entity, name, id, list)
	for k, v in pairs( dynEnts ) do
		if v.entB == entity and v.name == name and
		   v.used and v.id == id then
		   
		   dynEnts[k].list = list
		   return
		end
	end
end	

local function repositionDE( de, nx, ny, nz, nquat, rquat )
	local dl = de.list
	local xa, ya, za = Q.ToEuler( nquat )
	
	local xo, yo, zo = 0, 0, 0
	
	xo, yo, zo = U.Rotate3D( dl.xo, dl.yo, dl.zo, xa, ya, za )
		
	if dl.angQ ~= nil then
		if rquat ~= nil then
			xa, ya, za = Q.ToEuler( Q.Mul( Q.Mul( nquat, dl.angQ ), rquat ) )
		else
			xa, ya, za = Q.ToEuler( Q.Mul( nquat, dl.angQ ) )
		end
	end
	
	CollisionOff( de.entD )
	ResetRotation( de.entD, deg( xa ), deg( ya ), deg( za ) )
	ResetPosition( de.entD, nx + xo, ny + yo, nz + zo )
	CollisionOn( de.entD )
end

function DE_Update( entity, x, y, z, quat1, quat2 )
	for k, v in pairs( dynEnts ) do
		if v.used and v.showing and v.entB == entity then
			if v.scale ~= nil then
				if v.scale.current < v.scale.max then
					local scale = dynEnts[ k ].scale
					
					scale.current = scale.current + 
					               ( scale.max - scale.min) / scale.frames
					Scale( k, scale.current )
				end
			end
			repositionDE( v, x, y, z, quat1, quat2 )
		end
	end
end

function DE_Show( entity, name )
	for k, v in pairs( dynEnts ) do
		if v.used and not v.showing and 
		   v.entB == entity and v.name == name then
		   
			dynEnts[ k ].showing = true
			
			if v.scale ~= nil then
				dynEnts[ k ].scale.current = v.scale.min
			end
			
			Show( v.entD )
			CollisionOn( v.entD )
		end
	end
end

function DE_Hide( entity, name )
	local name = name or 'all'
	for k, v in pairs( dynEnts ) do
		if v.used and v.showing and 
		   v.entB == entity and name == 'all' or 
		   v.name == name then
		   
			dynEnts[ k ].showing = false
			Hide( v.entD)		
			CollisionOff( v.entD )
		end
	end
end

function dynamic_entity_main( e )
end