Module:Disambiguation

local p = {}
local list_of_realities = mw.loadData( 'Module:Disambiguation/Realities' )
local h = require("Module:HF")
local pagetype = require("Module:PageType")
local design = require("Module:Design")
local getArgs = require('Dev:Arguments').getArgs
 
 
-- main function used to create entire disambiguation page
function p.disambiguation(frame)
    local args = getArgs (frame)
    local g_type
    local g_main_name = args['main_name']
    local g_main_character = args['Main Character'] or ''
    local g_main_image_size = args['Main Image Size'] or '250px'
    local g_main_version
    local g_main_title
    local g_main_image
    local g_no_image
    local g_logo = args['logo'] or ''
    local g_description = args['description'] or ''
    local g_alternative_names = {}
    local g_include = {}
    local g_exclude = {}
    local g_includeComic = {}
    local g_includeMovie = {}
    local g_includeTV = {}
    local g_includeGame = {}
    local g_teams = {}
    local g_others = {}
    local g_related = {}
    local g_new_text = { {}, {}, {}, {}, {} }
    local g_page = mw.title.getCurrentTitle()
    local g_pagename = g_page.text
 
    local list = ''
    local all_versions = {}
    local comics = {}
    local movies = {}
    local tv = {}
    local games = {}
    local headers1 = { 'Alternate Reality Versions', 'Movies', 'Television', 'Video Games' }
    local headers2 = { 'Others', g_pagename..' Related', 'Teams' }
    local tables = {}
    local s = ''
    local s1 = ''
    local s2 = ''
    local output = {}
 
    table.insert(output, '__NOTOC__')
    table.insert(output, g_logo)
    -- if 'main_name' parameter is not empty, then use DPL to create a list of alternate versions
    if not h.isempty(g_main_name)
        then
            g_main_version = args['main']
            g_main_title = args['main_title'] or g_main_name
            g_main_image = args['main_image']
            table.insert(output, p.createBox_MainVersion({pagename = g_main_version, 
                                                          image = g_main_image,
                                                          imageSize = g_main_image_size,
                                                          description = g_description
                                                        }) 
                        )
 
            g_type = args['type'] or pagetype.lua_getPageType(g_main_version)
            g_noimage = args['noimage']
            for i = 1,100 do
                if not h.isempty(args['alternative'..i])
                    then table.insert(g_alternative_names, args['alternative'..i])
                end
                if not h.isempty(args['include'..i])
                    then table.insert(g_include, args['include'..i])
                end
                if not h.isempty(args['includeComic'..i])
                    then table.insert(g_includeComic, args['includeComic'..i])
                end
                if not h.isempty(args['includeMovie'..i])
                    then table.insert(g_includeMovie, args['includeMovie'..i])
                end
                if not h.isempty(args['includeTV'..i])
                    then table.insert(g_includeTV, args['includeTV'..i])
                end
                if not h.isempty(args['includeGame'..i])
                    then table.insert(g_includeGame, args['includeGame'..i])
                end
                if not h.isempty(args['exclude'..i])
                    then table.insert(g_exclude, args['exclude'..i])
                end    
            end
            list = frame:preprocess( p.lua_dpl_list(g_main_name, g_main_version, g_type, g_alternative_names, g_exclude, 500)..p.lua_dpl_list(g_main_name, g_main_version, g_type, g_alternative_names, g_exclude, 500, 500) )
            list = string.gsub(list, ' ', '')
            list = h.explode('@', list)
 
            for i = 1, #list do
                s = mw.text.split(list[i], '~') --h.explode('~', list[i])
                s1, s2 = p.lua_get_name_and_reality(s[1])
                table.insert( all_versions, { ['page'] = s[1], ['image'] = s[2], ['title'] = s[3], ['name'] = s1, ['reality'] = s2 } )
            end
            all_versions = h.lua_concatTables(all_versions, p.lua_transform_from_old_format(g_include, true))
 
            for i = 1, #all_versions do
                s = all_versions[i].reality.type
                if s == 'Game'
                    then table.insert(games, all_versions[i])
                    elseif s == "TV" 
                        then table.insert(tv, all_versions[i])
                    elseif s == "Movie" 
                        then table.insert(movies, all_versions[i])
                    else table.insert(comics, all_versions[i])
                end
            end
 
            comics = h.lua_concatTables(comics, p.lua_transform_from_old_format(g_includeComic, false))
            movies = h.lua_concatTables(movies, p.lua_transform_from_old_format(g_includeMovie, false))
            tv =  h.lua_concatTables(tv, p.lua_transform_from_old_format(g_includeTV, false))
            games = h.lua_concatTables(games, p.lua_transform_from_old_format(g_includeGame, false))
 
            tables = { comics, movies, tv, games }
            table.insert( output, p.lua_createTOC(tables, headers1, g_pagename, g_main_title) )
            for i = 1,4 do
                 table.insert(output, p.createSection({
                            s_table = tables[i], 
                            header = headers1[i],
                            main_name = g_main_name,
                            main_title = g_main_title,
                            disambiguation_pagename = g_pagename,
                            noimage = g_noimage,
                            old_format = false
                    }) )
            end
        elseif not h.isempty(g_main_character)
            then
                g_main_character = mw.text.split(h.trim(g_main_character), ';', true)
                table.insert(output, p.createBox_MainVersion({
                    pagename = h.lua_breaklink(g_main_character[1], 1), 
                    image = h.trim(g_main_character[2]) or 'No Image Available.png',
                    imageSize = g_main_image_size,
                    description = g_description
                })
                )
    end
 
    for i = 1,5 do
        table.insert(headers2, args['New Header'..i] or '')
    end
 
    for i = 1,200 do
        table.insert(g_teams, args['Teams'..i])
        table.insert(g_others, args['Others'..i])
        table.insert(g_related, args['Related'..i])
        for j = 1,5 do
            table.insert(g_new_text[j], args['New Header'..j..'_'..i])
        end
    end
    g_teams = p.lua_transform_from_old_format(g_teams, false)
    g_others = p.lua_transform_from_old_format(g_others, false)
    g_related = p.lua_transform_from_old_format(g_related, false)
 
    for j = 1,5 do
        g_new_text[j] = p.lua_transform_from_old_format(g_new_text[j], false)
    end
 
    tables = { g_others, g_related, g_teams, 
               g_new_text[1], g_new_text[2], g_new_text[3], g_new_text[4], g_new_text[5] } 
 
    for i = 1,8 do
        table.insert(output, p.createSection({
                            s_table = tables[i], 
                            header = headers2[i],
                            main_name = g_main_name,
                            main_title = g_main_title,
                            disambiguation_pagename = g_pagename,
                            noimage = g_noimage,
                            old_format = true
            }) )
    end
 
    --return '<div valign="top">'..table.concat(output)..'</div>'
    return table.concat(output)
end
 
 
function p.lua_sort_by_reality(a, b)
    local reality1 = a.reality.number
    local reality2 = b.reality.number
    local output
 
    if h.isempty(reality1) or h.isempty(reality2)
        then output = false
        else
            if tonumber(reality1) ~= nil
                then
                    if tonumber(reality2) ~= nil
                        then output = tonumber(reality1)<tonumber(reality2)
                        else output = true
                    end
                elseif tonumber(reality2) ~= nil
                    then output = false
                    else output = reality1<reality2
            end
    end
 
    return output
end
 
 
function p.lua_dpl_list(main_name, main_version, main_version_type, alternative_names, exclude, count, offset)
    local template = '{Marvel Database:'..main_version_type..' Template}'
    local image = template..':Image, '
    local title = ''
    local s = ''
    local output = {}
 
    if not h.isempty(alternative_names)
        then alternative_names = mw.text.listToText(alternative_names, '%¦', '%¦')..'%'
        else alternative_names = ''
    end
    if not h.isempty(exclude)
        then exclude = mw.text.listToText(exclude, '%¦', '%¦')..'%'
        else exclude = ''
    end
 
    main_version_type = string.lower(main_version_type)
    if  main_version_type == 'character' or main_version_type == 'characters'
        then title = template..':CurrentAlias'
        else title = template..':OfficialName'
    end
 
    table.insert(output, '{{#dpl:')
    table.insert(output, '|category = '..main_version_type..'s')
    table.insert(output, '|namespace = 0')
    table.insert(output, '|titlematch = '..main_name..' (%¦'..alternative_names)
    table.insert(output, '|nottitlematch = '..main_version..'¦'..exclude)
    table.insert(output, '|include = '..image..title)
    table.insert(output, '|mode = userformat')
    table.insert(output, '|secseparators = %PAGE%~,~,,@')
    table.insert(output, '|noresultsheader = &#x20;')
    --table.insert(output, '|eliminate = templates')
    table.insert(output, '|allowcachedresults = true')
    if not h.isempty(count)
        then table.insert(output, '|count ='..count)
    end
    if not h.isempty(offset)
        then table.insert(output, '|offset ='..offset)
    end
    table.insert(output, '}}')
 
    return table.concat(output)
end
 
 
-- transform string in 'page; image' format into table
function p.lua_transform_from_old_format(list, redlinks)
    local i
    local s_page = ''
    local s_title = ''
    local s_image = ''
    local s_reality = ''
    local s_name = ''
    local s = ''
    local output = {}
 
    if not h.isempty(list)
        then
            for i = 1, #list do
                s = list[i]
                if not h.isempty(s)
                    then
                        s = mw.text.split(h.trim(s), ';', true)
                        s_page = h.lua_breaklink(s[1], 1)
                        s_title = h.lua_breaklink(s[1], 2)
                        s_image = h.trim(s[2] or '')
                        s_name, s_reality = p.lua_get_name_and_reality(s_page)
                        if not h.isempty(s_reality) and s_title == s_page
                            then s_title = s_name
                        end
                        if redlinks == true
                            then s_title = ' '..s_title
                        end
 
                        table.insert( output, { 
                                                ['page'] = s_page, 
                                                ['image'] = s_image, 
                                                ['title'] = s_title, 
                                                ['name'] = s_name, 
                                                ['reality'] = s_reality } 
                                    )
                end
            end
    end
 
    return output
end
 
 
-- separate 'pagename' into name and reality. If reality is not empty, then information about it is returned from 'list_of_realities'
function p.lua_get_name_and_reality(pagename)
    local s_reverse
    local s_name = pagename
    local info = {}
    local s_reality = {}
    local i
 
    if not h.isempty(pagename)
        then
            pagename = string.gsub(pagename,'_',' ')
            s_reverse = string.reverse(pagename)
            i = string.find(s_reverse,'( ',1,true)
            j = string.find(s_reverse,')',1,true)
            if not h.isempty(i)
                then
                    s_name = string.reverse( string.sub(s_reverse, i+2, #s_reverse) )
                    s_reality = string.reverse( string.sub(s_reverse, j+1, i-1) )
                    info = p.getRealityInfo({s_reality})
                    if not h.isempty(info)
                        then s_reality = info
                        else s_reality = ''
                    end
            end
    end
 
    return s_name, s_reality
end
 
 
function p.getRealityInfo(frame)
    local args = getArgs (frame)
    local reality = args[1]
    local part = args[2]
    local info
    local s2
    local s3
    local output = ''
 
    if not h.isempty(reality)
        then
            reality = string.gsub(reality, 'Earth%-', '')
            info = list_of_realities[reality]
            if info ~= nil
                then output = { ['name'] = info[2], ['description'] = info[1], ['type'] = info[3], ['number'] = reality }
                elseif tonumber(reality) ~= nil or string.match(reality, '^TRN%d+') ~= nil
                    then output = { ['name'] = "Earth-"..reality, ['description'] = "Earth-"..reality, ['type'] = "Comic", ['number'] = reality }
                    --else output = { ['name'] = reality, ['description'] = reality, ['type'] = "Comic" }
            end
    end
 
    if not h.isempty(part)
        then
            part = tonumber(part)
            if part == 3
                then output = output.type
                elseif part == 2
                    then output = output.description
                else output = output.name
            end
    end
 
    return output
end
 
 
-- creates box with image, link to page (if needed) and link to reality (if stated)
function p.lua_createBox(s_table, main_name, main_title, disambiguation_pagename, noimage, old_format)
    local image = ''
    local name = ''
    local reality = ''
    local output = ''
 
    if not h.isempty(s_table)
        then
            image = p.createBox_image( { 
                            image = s_table.image, 
                            page = s_table.page, 
                            noimage = noimage } )
            name = p.createBox_link( {
                            page = s_table.page, 
                            name = s_table.name, 
                            title = s_table.title, 
                            main_name = main_name, 
                            main_title = main_title,
                            disambiguation_pagename = disambiguation_pagename,
                            old_format = old_format } )
            reality = p.createBox_reality( {s_table.reality} )
 
            output = tostring( mw.html.create( 'div' )
                    :css( 'width', '150px' )
                    :css( 'float', 'left' )
                    :css( 'text-align', 'center' )
                    :css( 'margin-left', '10px' )
                    :wikitext( image..name..reality )
                    :done() )
    end
 
    return output
end
 
 
function p.createBox_image(frame)
    local args = getArgs (frame)
    local image = args['image']
    local imageSize = args['imageSize'] or '150px'
    local page = args['page']
    local noimage = args['noimage'] or 'No Image Available.png'
    local link = ''
    local output
 
    if not h.isempty(page)
        then 
            link = '|link='..page
            if string.find(page, ' Vol ') ~= nil and pagetype.lua_getPageType(page) == 'Volume'
                then imageSize = '100px'
            end
    end
 
    if h.isempty(image) or image == "No Image Available At All.png"
        then image = noimage
    end
 
    output = mw.html.create( 'div' )
             :css( 'height', '150px' )
             :css( 'overflow', 'hidden' )
             :wikitext( '[[File:'..image..'|'..imageSize..link..']]' )
             :done() 
 
    return tostring(output)
end
 
 
function p.createBox_link(frame)
    local function bold_link(text1, text2) 
        return tostring( mw.html.create( 'span' )
                            :css( 'font-weight', 'bold' )
                            :wikitext( h.Link(text1, text2) )
                            :done() 
                        )
    end
    local args = getArgs (frame, {trim = false})
    local old_format = args['old_format']
    local page = args['page']
    local name = args['name']
    local title = args['title']
    local main_name = args['main_name']
    local main_title = args['main_title']
    local disambiguation_pagename = args['disambiguation_pagename']
    local output = ''
    local subname = ''
    local i = ''
 
    if old_format == true -- check for old disambiguation pages
        then output = bold_link(page, title)
        else
            i, subname = string.match(name, '(.+)%((.+)%)')
            if not h.isempty(title)
                then
                    title = h.lua_breaklink (title, 2)
                    if not h.inlist({main_title, main_name, disambiguation_pagename}, title)
                        then 
                            title = mw.text.trim(title)
                            if not h.inlist({main_title, main_name, title, disambiguation_pagename}, name)
                                then 
                                    if not h.isempty(subname)
                                        then name = '<br />('..h.trim(i)..')<br />('..subname..')'
                                        else name = '<br />('..name..')'
                                    end
                                    output = bold_link(page, title..name)
                                else output = bold_link(page, title)
                            end
                        elseif not h.inlist({main_title, main_name}, name)
                            then 
                                if not h.isempty(subname)
                                    then name = h.trim(i)..'<br />('..subname..')'
                                end
                                output = bold_link(page, name)  
                    end
                elseif name ~= main_name and name ~= main_title
                    then 
                        if not h.isempty(subname)
                            then name = h.trim(i)..'<br />('..subname..')'
                        end
                        output = bold_link(page, name)
            end
    end
 
    if not h.isempty(output)
        then output = output..'<br />'
    end
 
    return output
end
 
 
function p.createBox_reality(frame)
    local args = getArgs (frame)
    local reality = args[1]
    local info
    local output = ''
 
    if not h.isempty(reality)
        then
            if type(reality) == 'table'
                then info = reality
                else info = p.getRealityInfo({reality})
            end
            if info.name ~= info.description
                then output = info.description..'<br />([['..info.name..']])'
                else output = '([['..info.name..']])'
            end
    end
 
    return output
end
 
 
function p.createBox_MainVersion(frame)
    local args = getArgs (frame)
    local pagename = args['pagename']
    local image = args['image']
    local imageSize = args['imageSize']
    local description = args['description']
    local s_name
    local s_reality
    local div_box
    local div_clear = tostring(mw.html.create( 'div' ):css( 'clear', 'left' ):done() )
    local output = ''
 
    s_name, s_reality = p.lua_get_name_and_reality(pagename)
    s_reality = p.createBox_reality({s_reality})
    s_name = '<br />'..p.createBox_link({page = pagename, title = s_name, disambiguation_pagename = pagename, old_format = true})
    image = '[[File:'..image..'|'..imageSize..'|link='..pagename..']]'
 
    if not h.isempty(description)
        then
            div_box = tostring(mw.html.create( 'div' )
                        :css( 'font-size', '125%' )
                        :css( 'text-align', 'center' )
                        :css( 'float', 'left' )
                        :css( 'margin-right', '10px')
                        :wikitext(image..s_name..s_reality)
                        :done() 
                      )
            output = div_box..description
        else
            output = tostring(mw.html.create( 'div' )
                        :css( 'font-size', '125%' )
                        :css( 'text-align', 'center' )
                        :attr('align', 'center')
                        :wikitext(image..s_name..s_reality)
                        :done() 
                      )
    end
 
    return output..div_clear
end
 
 
function p.lua_createTOC(versions, headers, pagename, main_title)
    local output = {}
    local bold_middot = tostring( mw.html.create( 'span' ) 
                :css( 'font-weight', 'bold' )
                :wikitext( "&nbsp;&middot; " )
                :done() 
            )
    local div_toc = mw.html.create( 'div' )
                    :attr( 'align', 'center' )
                    :css( 'width', '100%' )
                    :css( 'text-align', 'center' )
                    :css( 'border-top', '1px solid grey' )
                    :css( 'border-bottom', '1px solid grey' )
                    :css( 'margin-top', '1em')
                    :done()
 
    for i = 1, #versions do
        if not h.isempty(versions[i])
            then table.insert(output, h.Link(pagename..'#'..headers[i], headers[i]) )
        end
    end
 
    if h.lua_isexists(pagename..' Comic Books')
        then table.insert(output, h.Link(pagename..' Comic Books', pagename..' Comics') )
        elseif not h.isempty(main_title) and h.lua_isexists(main_title..' Comic Books')
            then table.insert(output, h.Link(main_title..' Comic Books', main_title..' Comics') )
    end
 
    if not h.isempty(output)
        then 
            div_toc = div_toc:wikitext( mw.text.listToText(output, bold_middot, bold_middot) ):done()
            output = tostring(div_toc)
        else output = ''
    end
 
    return output
end
 
 
function p.createSection(frame)
    local args = getArgs (frame)
    local s_table = frame['s_table']
    local header = frame['header']
    local main_name = frame['main_name']
    local main_title = frame['main_title']
    local disambiguation_pagename = frame['disambiguation_pagename']
    local noimage = frame['noimage']
    local old_format = frame['old_format']
    local row4 = {}
    local output = ''
    local function div_row(row)
        local output = mw.html.create( 'div' )
                    :css( 'display', 'table' )
                    :css( 'margin', '0 auto' )
                    :wikitext( row )
                    :done()
        return tostring(output)
    end
    local div_clear = tostring(mw.html.create( 'div' ):css( 'clear', 'left' ):done() )
 
    if not h.isempty(s_table) 
        then
            if not old_format
                then table.sort(s_table, p.lua_sort_by_reality)
            end
 
            output = {}
            if not h.isempty(header)
                then header = design.lua_header(header, 2, 'center')
                else header = ''
            end
            for i = 1, #s_table do
                if #row4 < 4
                    then table.insert(row4, p.lua_createBox(s_table[i], main_name, main_title, disambiguation_pagename, noimage, old_format) )
                end
                if #row4 == 4 or i == #s_table
                    then 
                        table.insert( output, div_row(table.concat(row4)) )
                        table.insert( output, div_clear )
                        row4 = {}
                end
            end
            output = header..table.concat(output)
    end
 
    return output
end
 
 
------------------------------------------------------------------------------------------------
-- used in Template:Disambiguation Text
function p.disambiguation_text(frame)
    local s = frame.args[1]
    local reality = ''
    local link
    local text
    local comment = ''
    local i
    local output = ''
 
    if not h.isempty(s)
        then
            s = h.explode(';', s)
            if tonumber(s[1]) ~= nil or string.match(s[1], '^TRN%d+') ~= nil or list_of_realities[s[1]] ~= nil
                then
                    reality = { p.lua_reality(s[1]) }
                    output = reality[1]..'<br />('..h.Link(reality[2])..')'
                else
                    if h.lua_isLink(s[1])
                        then
                            i = string.find(s[1], ']]', 1, true)
                            link = h.lua_breaklink(s[1],1)
                            text = h.lua_breaklink(s[1],2)
                            if #s[1] > i+2
                                then comment = string.sub(s[1], i+2, #s[1])
                            end
                            if not h.isempty( string.find(link, '(',1,true) )
                                then 
                                    reality = { p.lua_reality(link, true) }
                                    reality = '<br />'..reality[1]..'<br />('..h.Link(reality[2])..')'
                            end 
                        else
                            link = s[1]
                            text = s[1]
                    end
                    output = tostring( mw.html.create( 'span' )
                                :css( 'font-weight', 'bold' )
                                :wikitext( h.Link(link,text)..comment )
                                :done() )..reality
            end
    end
 
    return output
end
 
function p.lua_reality(r, e)
    local j
    local k
    local s
    local s1
    local s2
    local s3
 
    if e == true or e == "true"
        then 
            s1 = string.reverse(r)
            s2 = string.find(s1, "( ",1,true) or string.find(s1, "(_",1,true)
            s3 = string.find(s1, ")",1,true)
            r = string.reverse(string.sub(s1, s3+1, s2-1))
    end
 
    j,k = string.find(string.lower( r ),"earth-",1,true)
    if j ~= nil
        then s = string.sub(r,k+1,string.len(r))
        else s = r
    end
    s2 = list_of_realities[s]
    if s2 ~= nil
        then return s2[1], s2[2], s2[3]
        elseif tonumber(r) ~= nil or string.match(r, '^TRN%d+') ~= nil
            then return "Earth-"..r, "Earth-"..r, "Comic"
            else return r, r, "Comic"   
    end
end
 
function p.reality (frame)
    local r = h.lua_breaklink(frame.args[1], 1)
    local i = tonumber(frame.args[2])
    local e = frame.args[3] or frame.args["extract"]
    local s1
    local s2
    local s3
 
    s1, s2, s3 = p.lua_reality(r, e)
    if i == 3
        then return s3
        elseif i == 2 
            then return s2
            else return s1
    end
end
 
return p