
--[[
------------------------------------------
Classe DataArray
On inclus un fichier qui contient un tableau "Array" qui contient les valeurs intiales
et un tableau Enum qui contient les valeurs possibles pour les types enumérés
ex :

DataArray["Level01"] = {
    CreatureSituation = "RoomA",
}

EnumDataArrays["Level01"]= 
{
    CreatureSituation={"RoomA","RoomB","RoomC"},
}

]]

.namespace DataArray

g_backup = nil

function OnEnable()
	g_backup = DataArrays[self.Name]
	
	AssertPopup(g_backup ~= nil ,"prob enable")
end

function CheckIfConsistentValue(ObjectName,Value)
    AssertPopup(type(ObjectName) == "string" and Value ~= nil," erreur sur les paramétres")

    if (DataArrays == nil) then
        AssertPopup(false,'ERROR : On appelle Set() avec Key = ' .. ObjectName .. ' and value = ' .. Value)
        return
    end
    local v=DataArrays[self.Name][ObjectName]
   
    if v==nil then
        AssertPopup(false,'Attention ! ' ..ObjectName..' dans '..self.Name.." n'est pas registered")
		--InfoDebugText.Text = GlobalFunctions.Display(DataArrays[self.Name])
        return
    elseif type(Value)~=type(v)  then
        AssertPopup(false,'Les types ne correspondent pas !! pour '..ObjectName..' dans '..self.Name)
        return
    end
    
    --vérif pur énum
    if type(EnumDataArrays[self.Name])=="table"  then
        if EnumDataArrays[self.Name][ObjectName] ~= nil then
            if not IsInWithoutLower(EnumDataArrays[self.Name][ObjectName],Value) then
                AssertPopup(false,"Erreur, valeur non presente dans le type énuméré pour l'objet "..ObjectName.." \n valeur : "..Value.." dans "..self.Name)
            end
        end
    end
end

function IsInWithoutLower(tabin ,x )

    if tabin == nil then
        return false
    end
    
    local comp1, comp2
    i = next(tabin)
    
    if type(x) == "string" then    
        comp1 = x
        while not(i == nil) do
            comp2 = tabin[i]
            if comp1 == comp2  then
                return true
            end
            i = next(tabin, i)
        end   
    else
        comp1 = x
        while not(i == nil) do
            comp2 = tabin[i]
            if comp1 == comp2  then
                return true
            end
            i = next(tabin, i)
        end
    end
    
    return false    
end

function Set(ObjectName, Value,silent)
    if silent ~= true then
        CheckIfConsistentValue(ObjectName,Value)
    end
	
	if ObjectName == "CurrentGamePhase" then
		OPLog.Log("passage de "..DataArrays[self.Name][ObjectName].." à "..Value)
	end
	
    DataArrays[self.Name][ObjectName] = Value
end

function IsEqual(ObjectName , Value)
    CheckIfConsistentValue(ObjectName,Value)
    return DataArrays[self.Name][ObjectName] == Value
end

--cette fonction doit etre appelé, si la variable n'est pas présente dans le dataarray
--mais elle doit etre appelé une seule fois
function RegisterValue(ObjectName,DefaultValue)
    AssertPopup(type(ObjectName) == "string" , "Erreur sur ObjectName ") 
    if DataArrays[self.Name][ObjectName] ~= nil then
        if type(DefaultValue) ~= type(DataArrays[self.Name][ObjectName]) then
            AssertPopup(false,"Valeur déjà enregistrée avec un type différent "..ObjectName)
        else
            OPLog.Log("attention valeur déjà enregistré, on ne la change pas "..ObjectName)
        end
        return
    end
    AssertPopup(DefaultValue ~= nil , "Erreur pas de DefaultValue")    
    DataArrays[self.Name][ObjectName] = DefaultValue    
end

function IsRegistered(ObjectName)
	--OPLog.Log(tostring(ObjectName).." "..tostring(self.Name))

    if DataArrays[self.Name][ObjectName] ~= nil then
        return true
    else
        return false
    end
end

--un simple tostring fait l'affaire aussi
function DisplayAssign(Value,ObjectName)
    if Value==true then 
        s='true'
    elseif Value==false then
        s='false'
    else
        s=Value
    end
    if type(s)~='table' then
        OPLog.Log('assign '..self.Name..' '..ObjectName.." "..s)
    end
end

function Get(ObjectName, dummy)
	AssertPopup(dummy == nil , "ce params n'a rien à faire là")
    if (DataArrays[self.Name] == nil) then
        AssertPopup(false,'Datarray non défini ! ' ..self.Name.." " ..ObjectName)
    end
       
    AssertPopup(type(ObjectName) == "string" , "Erreur sur ObjectName ") 
    AssertPopup(type(DataArrays[self.Name]) == "table" , "Erreur sur sur le datarrays "..self.Name) 
	  
	--OPLog.Log("get "..self.Name.." "..ObjectName.." "..type(DataArrays[self.Name]))
    local v=DataArrays[self.Name][ObjectName]

    if v==nil then
        AssertPopup(false,'Erreur ! ' ..ObjectName..' dans '..self.Name..' nexiste pas ')
    end
    return v
end

function Next(index)
  local i = next(DataArrays[self.Name], index)
  return i
end

function SetDataArray(da)
    DataArrays[self.Name] = da
    --cas spécifique inventaire
    local ut
    if self.Name=='InventoryArray' then
        for u,v in pairs(da) do
            ut=OPUnitFactory.GetUnit(v)
            if (ut~= nil) then
                --ut.Flags_EditorVisible=false
            end
        end
    end
end

function DisplayAll()
    --on trie par ordre alphabétique
    local tabtoprint = {}
    local s
    
    for ind,elem in pairs(DataArrays[self.Name]) do
        s = ind.." : "..GlobalFunctions.Display(elem)
        --OPLog.Log(s)
        table.insert(tabtoprint,s)
    end
    
    table.sort(tabtoprint)
        
    s=""
    
    for ind,elem in pairs(tabtoprint) do
        s=s..GlobalFunctions.Display(elem).."\r"
    end
    
    return s
end

function GetN()
  local n = table.getn(DataArrays[self.Name])
  return n
end

function Reset()
    --DataArrays[self.Name]= g_backup
	OPLua.Include(self.ArrayFile)
end

function Remove(index)
    return table.remove(DataArrays[self.Name], index) 
end

function GetDataArray()
    return DataArrays[self.Name]
end

function GetEnum()
    return EnumDataArrays[self.Name]
end
