Moduuli:Fr:Format

---

-- Module dédié au formatage de texte

local fun = {}

fun.i18n = {
	["fun-unit-mega"] = "miljoona", -- fr "million"
	["fun-unit-giga"] = "miljardi" -- fr "milliard"
}

-- Mise en forme des nombres
-- Mime le comportement du mot magique formatnum, sans paramètre R
function fun.formatnum(frame)
    return fun.do_formatnum(frame:getParent().args)
end

function fun.do_formatnum(arguments)
    local result = ""
    local number = ""
    -- Vérification du paramètre
    if(type(tonumber(arguments[1])) == "number") then
        number = arguments[1]
    
        -- Extraction des parties du nombre
        local _, _, minus, intPart, point, fracPart = string.find(number,"^([^0-9.]?)0*(%d*)(\.?)(%d*)$")
        
        -- Signe moins
        result = result .. minus
        -- Partie entière
        if(#intPart > 0) then
            local index = #intPart
            for digit in string.gfind(intPart, "%d") do
                result = result .. digit
                -- Espace tous les trois chiffres
                if((index % 3) == 1 and index > 1) then
                    result = result .. " "
                end
                index = index - 1
            end
        else
            -- Ajout d'un zéro si la partie décimale est vide
            result = result .. "0"
        end
        -- Virgule
        if(point ~= "") then
            result = result .. ","
        end
        -- Partie fractionnaire
        result = result .. fracPart
    else
        result = (arguments[1] or "")
    end
    
    return result
end

-- Mise en forme des nombres avec unité
-- Basé sur Modèle:Unité, mais sans limitation de nombre d'arguments
function fun.unite(frame)
    return fun.do_unite(frame:getParent().args)
end

-- Réalisation de la fonction précédente
function fun.do_unite(arguments)
    local result = ""
    
    -- Formatage de la valeur principale
    if(arguments[1] ~= nil) then
        result = fun.do_formatnum{arguments[1]}
    end
    
    -- Formatage de la puissance de 10 éventuelle
    if(arguments.e ~= nil) then
        result = result .. fun.do_x10{arguments.e}
    end
    
    -- Parcours des unités et exposants
    local index = 2
    while(arguments[index] ~= nil) do
        if (index == 2) then
            -- Première unité : espace insécable
            result = result .. " "
        else
            -- Unités suivantes : point médian
            result = result .. "⋅"
        end
        
        -- Affichage de l'unité
        result = result .. arguments[index]
        
        -- Exposant éventuel
        if(arguments[index+1] ~= nil) then
            result = result .. fun.do_expo{arguments[index+1]}
        end
        
        index = index + 2
    end
    
    -- Non-retour à la ligne
    result = "<span class=\"nowrap\">" .. result .. "</span>"
    
    return result
end

-- Mise en forme des exposants
-- Basé sur Modèle:Exp
function fun.expo(frame)
    return fun.do_expo(frame:getParent().args)    
end

-- Réalisation de la fonction précédente
function fun.do_expo(arguments)
    local result = ""
    if(arguments[1] ~= nil) then
        result = result .. arguments[1]
    end
    result = "<sup>" .. result .. "</sup>"
    
    return result
end

-- Mise en forme des puissances de 10
-- Basé sur Modèle:x10
function fun.x10(frame)
    return fun.do_x10(frame:getParent().args)    
end

-- Réalisation de la fonction précédente
function fun.do_x10(arguments)
    local result = "×10" .. fun.do_expo{arguments[1]}
    return result
end

-- Affichage d'une valeur en parsecs
-- Basé sur Modèle:Parsec
function fun.parsec(frame)
    return fun.do_parsec(frame:getParent().args)    
end

-- Réalisation de la fonction précédente
function fun.do_parsec(arguments)
    local result = ""
        
    -- Unités disponibles
   local units = {
        pc = {"[[parsec|pc]]", [false] = {1, ""}, [true] = {1, ""}},
        kpc = {"[[Kiloparsec|kpc]]", [false] = {1000, ""}, [true] = {0.001, fun.i18n["fun-unit-mega"] }},
        mpc = {"[[Mégaparsec|Mpc]]", [false] = {1, fun.i18n["fun-unit-mega"] }, [true] = {0.001, fun.i18n["fun-unit-giga"]}},
        gpc = {"[[Gigaparsec|Gpc]]", [false] = {1, fun.i18n["fun-unit-giga"]}, [true] = {1, fun.i18n["fun-unit-giga"]}}
    }
    
    -- Valeur principale
    local resultVal = fun.do_formatnum{(arguments[1] or "")}
    
    -- Unité utilisée
    local unitData = (units[arguments[2]] or units.pc)
    
    if(arguments.marge ~= nil or arguments.sup ~= nil) then
        -- Marge éventuelle
        if(arguments.marge ~= nil) then
            local resultMarge = "" ;
            if(tonumber(arguments.marge) ~= nil) then
                resultMarge = "<small>&plusmn;" .. arguments.marge .. "</small>"
            else
                resultMarge = arguments.marge
            end
            resultVal = resultVal .. resultMarge
        end
        
        -- Deuxième valeur éventuelle
        if(arguments.sup ~= nil) then
            resultVal = resultVal .. " à&nbsp;" .. arguments.sup
        end
    else
        -- "Environ" si c'est une valeur brute seule
        result = result .. "environ&nbsp;"
    end
    -- Affichage de la valeur
    result = result .. fun.do_unite{resultVal,unitData[1]} .. " "
    
    -- Affichage de la conversion en années-lumière
    local numVal = tonumber(arguments[1])
    if(numVal ~= nil) then
        -- On utilise un autre ordre de grandeur si la valeur est trop grande
        local isBigVal = (numVal*3.2616 >= 1000)
        -- Valeur en années-lumière
        local alVal = numVal*unitData[isBigVal][1]*3.2616
        -- Première valeur
        result = result .. "(&sim;" .. fun.do_formatnum{fun.do_chiffresSignificatifs{alVal,3}} .. "&nbsp;"
        if(arguments.sup ~= nil and tonumber(arguments.sup) ~= nil) then
            -- Deuxième valeur éventuelle
            alVal = tonumber(arguments.sup)*unitData[isBigVal][1]*3.2616
            result = result .. "à&nbsp;" .. fun.do_formatnum{fun.do_chiffresSignificatifs{alVal,3}} .. "&nbsp;" 
        end
        -- La dernière valeur affichée (alVal) entraîne-t-elle un pluriel ?
        local unitFull = ""
        if(unitData[isBigVal][2] ~= "") then -- Il faut avoir un mot à mettre au pluriel
            if(alVal >= 1.995) then
                unitFull = "s"
            end
            unitFull = unitData[isBigVal][2] .. unitFull .. " d'"
        end
        -- Affichage de l'unité
        result = result .. unitFull .. "[[Année-lumière|a.l.]])" ;
    end
    
    return result
end

-- Affichage d'un nombre avec chiffres significatifs
function fun.chiffresSignificatifs(frame)
    return fun.do_chiffresSignificatifs(frame:getParent().args)  
end

-- Réalisation de la fonction précédente
-- Attention, renvoie une chaîne
-- Usage : fun.do_chiffresSignificatifs{valeur, nb de chiffres significatifs}
function fun.do_chiffresSignificatifs(arguments)
    local result = ""
    local value, digits = tonumber(arguments[1]), tonumber(arguments[2])
    if(value ~= nil and digits ~= nil) then
        local logVal = math.ceil(math.log10(value))
        local mult = 10^(digits-logVal)
        local rounded = math.floor(value*mult+0.5)/mult
        result = string.format("%." .. tostring(math.max(digits-logVal,0)) .. "f", rounded)
    end
    return result
end

-- Ajoute des hyperliens aux mots séparés par des virgules, comme ceux des propriétés Wikidata
function fun.ajouterLiens(frame)
    local arguments = frame:getParent().args
    local mots = mw.text.split(arguments[2], ",")
    local liens = table.concat(mots, "]], [[")
    if liens ~= nil and liens ~= "" then
      return "[[" .. liens .. "]]"
    else
      return ""
    end
end

return fun