Module:Episode/MultiSeries

Documentation module[créer]

-- Module:Episode/MultiSeries
-- Loads series index modules and season modules, merges episodes and aliases
local utils = require("Module:Episode/Shared/Utils")
local Master = {
    episodes = {},   -- id -> episode table
    aliases  = {},   -- normalized alias -> id
    loaded   = {},   -- list of loaded module paths
}

-- Load a season module safely and merge
local function load_and_merge(module_path)
    local ok, mod = pcall(require, module_path)
    if not ok or type(mod) ~= "table" then return false end
    for k,v in pairs(mod) do
        if type(v) == "table" and v.id and utils.validate_episode(v) then
            Master.episodes[v.id] = v
            if type(v.aliases) == "table" then
                for _, a in ipairs(v.aliases) do
                    local norm = utils.normalize_alias(a)
                    if norm then Master.aliases[norm] = v.id end
                end
            end
        elseif type(v) == "string" then
            local norm = utils.normalize_alias(k)
            if norm and v ~= "" then Master.aliases[norm] = v end
        end
    end
    table.insert(Master.loaded, module_path)
    return true
end

-- Public: load a list of series index modules
function Master.load_series(series_index_modules)
    series_index_modules = series_index_modules or {
        "Module:Episode/SG1/Index",
        "Module:Episode/SGA/Index",
        "Module:Episode/SGU/Index",
    }
    for _, idx_path in ipairs(series_index_modules) do
        local ok, idx = pcall(require, idx_path)
        if ok and type(idx) == "table" and idx.list_seasons then
            for _, s in ipairs(idx.list_seasons()) do
                load_and_merge(s.module)
            end
        end
    end
    return {
        episodes_count = (function() local c=0; for _ in pairs(Master.episodes) do c=c+1 end; return c end)(),
        aliases_count = (function() local c=0; for _ in pairs(Master.aliases) do c=c+1 end; return c end)(),
        loaded = Master.loaded,
    }
end

function Master.get_by_id(id) return Master.episodes[id] end
function Master.resolve_alias(alias) return Master.aliases[utils.normalize_alias(alias)] end
function Master.get_by_alias(alias)
    local id = Master.resolve_alias(alias)
    if id then return Master.get_by_id(id) end
    return nil
end

function Master.check_duplicates()
    local report = {
        duplicate_ids = {},
        duplicate_aliases = {},
        conflicting_aliases = {},
    }

    -- Vérification des IDs
    local seen_ids = {}
    for id, ep in pairs(Master.episodes) do
        if seen_ids[id] then
            table.insert(report.duplicate_ids, id)
        else
            seen_ids[id] = true
        end
    end

    -- Vérification des alias
    local alias_targets = {}
    for alias, id in pairs(Master.aliases) do
        if alias_targets[alias] and alias_targets[alias] ~= id then
            -- même alias → deux IDs différents
            table.insert(report.conflicting_aliases, {
                alias = alias,
                id1 = alias_targets[alias],
                id2 = id
            })
        elseif alias_targets[alias] then
            -- même alias → même ID (OK, mais on peut le signaler si tu veux)
            table.insert(report.duplicate_aliases, alias)
        else
            alias_targets[alias] = id
        end
    end

    return report
end

return Master

-- Vérifie les doublons d’ID et d’alias