Modul:Vorlage:Tennisstatistik-Damen

aus Wikipedia, der freien Enzyklopädie
Zur Navigation springen Zur Suche springen

Die Dokumentation für dieses Modul kann unter Modul:Vorlage:Tennisstatistik-Damen/Doku erstellt werden

local p = {}

local function turniereReichenfolge()
    local para = {}
    para = { "AUO", "FRO", "WIM", "USO",
             "WTC", "MUN",
             "DOH", "DUB", "CHI", "BOC", "IND", "MIA", "HHI", "CHA", "ROM", "MAD", "BER",
             "SDI", "CIN", "KAN", "TOK", "WUH", "ZUR", "PHI", "PEK", "MOS", "GUA",
             "OLY", "CUP",
    }

    return para
end

local function turniereTurnier(kuerzel)
    local para = {}
    para["AUO"] = { { "Australian Open" } }
    para["FRO"] = { { "French Open" } }
    para["WIM"] = { { "Wimbledon Championships|Wimbledon" } }
    para["USO"] = { { "US Open" } }

    para["WTC"] = { { "WTA Tour Championships|Tour Championships" } }
    para["MUN"] = { { "WTA München|München" } }

    para["DOH"] = { { "WTA Doha|Doha" } }
    para["DUB"] = { { "WTA Dubai|Dubai" } }
    para["CHI"] = { { "WTA Chicago|Chicago" } }
    para["BOC"] = { { "WTA Boca Raton|Boca Raton" } }
    para["IND"] = { { "WTA Indian Wells|Indian Wells" } }
    para["MIA"] = { { "WTA Miami|Miami" } }
    para["HHI"] = { { "WTA Hilton Head Island|Hilton Head Island" } }
    para["CHA"] = { { "WTA Charleston|Charleston" } }
    para["ROM"] = { { "WTA Rom|Rom" } }
    para["MAD"] = { { "WTA Madrid|Madrid" } }
    para["BER"] = { { "WTA Berlin|Berlin" } }
    para["SDI"] = { { "WTA San Diego|San Diego" } }
    para["CIN"] = { { "WTA Cincinnati|Cincinnati" } }
    para["KAN"] = { { "WTA Kanada|Kanada" } }
    para["TOK"] = { { "WTA Tokio|Tokio" } }
    para["WUH"] = { { "WTA Wuhan|Wuhan" } }
    para["ZUR"] = { { "WTA Zürich|Zürich" } }
    para["PHI"] = { { "WTA Philadelphia|Philadelphia" } }
    para["PEK"] = { { "WTA Peking|Peking" } }
    para["MOS"] = { { "WTA Moskau|Moskau" } }
    para["GUA"] = { { "WTA Guadalajara|Guadalajara" } }

    para["OLY"] = { { "Olympische Spiele" } }

    para["CUP"] = { 
                    { "Billie Jean King Cup|Federation Cup", 1982, 1995 },
                    { "Billie Jean King Cup|Fed Cup", 1996, 2020 },
                    { "Billie Jean King Cup", 2020, letztesJahr }
                  }

    return para[kuerzel]
end

local function turniereAustragungszeitraum()
    local para = {}  
    para["AUO"] = { { 1982, 1986 }, { 1988, letztesJahr } }
    para["FRO"] = { { 1982, letztesJahr } }
    para["WIM"] = { { 1982, 2019 }, { 2021, letztesJahr } }
    para["USO"] = { { 1982, letztesJahr } }

    para["WTC"] = { { 1982, 2019 }, { 2021, letztesJahr } }
    para["MUN"] = { { 1998, 1999 } }

    para["DOH"] = { { 2008, 2008 }, { 2012, 2014 }, { 2016, letztesJahr, "g" } }
    para["DUB"] = { { 2009, 2011 }, { 2015, letztesJahr, "u" } }
    para["CHI"] = { { 1990, 1990 } }
    para["BOC"] = { { 1991, 1992 } }
    para["IND"] = { { 1997, 2019 }, { 2021, letztesJahr } }
    para["MIA"] = { { 1988, 2019 }, { 2021, letztesJahr } }
    para["HHI"] = { { 1990, 2000 } }
    para["CHA"] = { { 2000, 2008 } }
    para["ROM"] = { { 1990, letztesJahr } }
    para["MAD"] = { { 2009, 2019 }, { 2021, letztesJahr } }
    para["BER"] = { { 1988, 2008 } }
    para["SDI"] = { { 2004, 2007 } }
    para["CIN"] = { { 2009, letztesJahr } }
    para["KAN"] = { { 1990, 2019 }, { 2021, letztesJahr } }
    para["TOK"] = { { 1993, 2013 } }
    para["WUH"] = { { 2014, 2019 } }
    para["ZUR"] = { { 1993, 2007 } }
    para["PHI"] = { { 1993, 1995 } }
    para["PEK"] = { { 2009, 2019 } }
    para["MOS"] = { { 1997, 2008 } }
    para["GUA"] = { { 2022, letztesJahr } }

    para["OLY"] = { { 1988, 2019, "s" }, { 2020, 2021, "u" }, { 2022, letztesJahr, "s" } }  

    para["CUP"] = { { 1982, 2019 }, { 2020, 2021, "e" }, { 2022, letztesJahr } }
    
    return para
end

local function turniereNamen(kuerzel, jahr)
    local para = {}

    para["AUO"] = { 
                    { 1982, letztesJahr, "Australian Open "..jahr.."/Damen"..modus.."" },
                  }
    para["FRO"] = { 
                    { 1982, letztesJahr, "French Open "..jahr.."/Damen"..modus.."" },
                  }
    para["WIM"] = { 
                    { 1982, letztesJahr, "Wimbledon Championships "..jahr.."/Damen"..modus.."" },
                  }
    para["USO"] = { 
                    { 1982, letztesJahr, "US Open "..jahr.."/Damen"..modus.."" },
                  }   

    para["WTC"] = {
                    { 1982, letztesJahr, "WTA Championships "..jahr.."" },
                 }     
    para["MUN"] = {
                    { 1998, 1999, "Compaq Grand Slam Cup "..jahr.."" },
                  }
                
    para["DOH"] = { 
                    { 2008, 2020, "Qatar Total Open "..jahr.."" },
                    { 2022, letztesJahr, "Qatar TotalEnergies Open "..jahr.."" }
                  }
    para["DUB"] = {
                    { 2009, 2010, "Barclays Dubai Tennis Championships "..jahr.."/Damen" },
                    { 2011, letztesJahr, "Dubai Duty Free Tennis Championships "..jahr.."/Damen" },
                  }
    para["CHI"] = { 
                    { 1990, 1990, "Virginia Slims of Chicago "..jahr.."" },
                  }
    para["BOC"] = {
                    { 1991, 1992, "Virginia Slims of Florida "..jahr.."" },
                  }
    para["IND"] = { 
                    { 1997, 1998, "State Farm Evert Cup "..jahr.."" },
                    { 1999, 1999, "Evert Cup "..jahr.."" },
                    { 2000, 2001, "Tennis Masters Series Indian Wells "..jahr.."/Damen" },
                    { 2002, 2008, "Pacific Life Open "..jahr.."/Damen" },
                    { 2009, 2019, "BNP Paribas Open "..jahr.."/Damen" },
                    { 2021, letztesJahr, "BNP Paribas Open "..jahr.."/Damen" },
                  } 
    para["MIA"] = {
                    { 1988, 1992, "Lipton International Players Championships "..jahr.."/Damen" },
                    { 1992, 1999, "The Lipton Championships "..jahr.."/Damen" },
                    { 2000, 2001, "Ericsson Open "..jahr.."/Damen" },
                    { 2002, 2006, "NASDAQ-100 Open "..jahr.."/Damen" },
                    { 2007, 2012, "Sony Ericsson Open "..jahr.."/Damen" },
                    { 2013, 2014, "Sony Open Tennis "..jahr.."/Damen" },
                    { 2015, 2019, "Miami Open "..jahr.."/Damen" },
                    { 2021, letztesJahr, "Miami Open "..jahr.."/Damen" },
                  }
    para["HHI"] = {
                    { 1990, 2000, "Family Circle Cup "..jahr.."" },
                  }
    para["CHA"] = {
                    { 2000, 2008, "Family Circle Cup "..jahr.."" },
                  }
    para["ROM"] = { 
                    { 1990, 1990, "Campionati Internazionali d’Italia Peugeot Open Cup "..jahr.."/Damen" },
                    { 1991, 1991, "Peugeot Italian Open "..jahr.."/Damen" },
                    { 1992, 1992, "Campionati Internazionali d’Italia Peugeot Open "..jahr.."/Damen" },
                    { 1993, 1993, "Campionati Internazionali d’Italia "..jahr.."/Damen" },
                    { 1994, 1994, "Mercedes Italian Open "..jahr.."/Damen" },
                    { 1995, 1996, "Italian Open "..jahr.."/Damen" },
                    { 1997, 1998, "Campionati Internazionali d’Italia "..jahr.."/Damen" },
                    { 1999, 2000, "Italian Open "..jahr.."/Damen" },
                    { 2001, 2001, "Tennis Masters Series Rome "..jahr.."/Damen" },
                    { 2002, 2002, "Tennis Masters Roma "..jahr.."/Damen" },
                    { 2003, 2004, "Telecom Italia Masters "..jahr.."/Damen" },
                    { 2005, 2005, "Telecom Italia Masters Roma "..jahr.."/Damen" },
                    { 2006, 2006, "Internazionali d’Italia "..jahr.."/Damen" },
                    { 2007, letztesJahr, "Internazionali BNL d’Italia "..jahr.."/Damen" },
                  }
    para["MAD"] = {
                    { 2009, 2010, "Mutua Madrileña Madrid Open "..jahr.."/Damen" },
                    { 2011, 2019, "Mutua Madrid Open "..jahr.."/Damen" },
                    { 2021, letztesJahr, "Mutua Madrid Open "..jahr.."/Damen" },
                  }
    para["BER"] = {
                    { 1988, 1988, "German Open "..jahr.."/Damen" },
                    { 1989, 1989, "Lufthansa Cup "..jahr.."" },
                    { 1990, 1991, "Lufthansa Cup German Open "..jahr.."" },
                    { 1992, 1992, "Lufthansa Cup "..jahr.."" },
                    { 1993, 1994, "German Open "..jahr.."/Damen" },
                    { 1995, 1997, "German Open "..jahr.." (Tennis)/Damen" },
                    { 1998, 1999, "German Open "..jahr.."/Damen" },
                    { 2000, 2000, "German Open "..jahr.."" },
                    { 2001, 2002, "Eurocard Ladies German Open "..jahr.."" },
                    { 2003, 2003, "MasterCard German Open "..jahr.."" },
                    { 2004, 2004, "Ladies German Open "..jahr.."" },
                    { 2005, 2005, "Qatar Total German Open "..jahr.."" },
                    { 2006, 2008, "Qatar Telecom German Open "..jahr.."" },
                  }
    para["SDI"] = {
                    { 2004, 2007, "Acura Classic "..jahr.."" },
                  }
    para["CIN"] = {
                    { 2009, 2010, "Western & Southern Financial Group Women’s Open "..jahr.."" },
                    { 2011, letztesJahr, "Western & Southern Open "..jahr.."/Damen" },
                  }  
    para["KAN"] = { 
                    { 1990, 1990, "Player’s Ltd. Challenge Canadian Open "..jahr.."" },
                    { 1991, 1991, "Canadian Open "..jahr.."/Damen" },
                    { 1992, 1992, "Matinee Ltd. Canadian Open "..jahr.."/Damen" },
                    { 1993, 1993, "Matinee Ltd. International "..jahr.."/Damen" },
                    { 1994, 1994, "Matinee Ltd. International - Canadian Open "..jahr.."/Damen" },
                    { 1995, 2000, "Du Maurier Open "..jahr.."/Damen" },
                    { 2001, 2019, "Rogers Cup "..jahr.."/Damen" },
                    { 2021, letztesJahr, "National Bank Open "..jahr.."/Damen" },
                  }
    para["TOK"] = {
                    { 1993, 2000, "Toray Pan Pacific Open "..jahr.."" },
                    { 2001, 2001, "Pan Pacific Open "..jahr.."" },
                    { 2002, 2013, "Toray Pan Pacific Open "..jahr.."" },
                  }
    para["WUH"] = {
                    { 2014, 2019, "Dongfeng Motor Wuhan Open "..jahr.."" },
                  }
    para["ZUR"] = {
                    { 1993, 1993, "Barilla Indoors "..jahr.."" },
                    { 1994, 1994, "European Indoors Zurich "..jahr.."" },
                    { 1995, 1996, "European Indoors "..jahr.."" },
                    { 1997, 1997, "European Indoor Championships "..jahr.."" },
                    { 1998, 1998, "European Championships / Swisscom "..jahr.."" },
                    { 1999, 2004, "Swisscom Challenge "..jahr.."" },
                    { 2005, 2007, "Zurich Open "..jahr.."" },
                  }
    para["PHI"] = {
                    { 1993, 1994, "Virginia Slims of Philadelphia "..jahr.."" },
                    { 1995, 1995, "Advanta Championships "..jahr.."" },
                  }
    para["PEK"] = {
                    { 2009, 2019, "China Open "..jahr.." (Tennis)/Damen"},
                  }
    para["MOS"] = {
                    { 1997, 2008, "Kremlin Cup "..jahr.."/Damen" },
                  }
    para["GUA"] = {
                    { 2022, letztesJahr, "Guadalajara Open Akron "..jahr.."" },                  
                  }
                
    para["OLY"] = {
                    { 1982, 2020, "Olympische Sommerspiele "..jahr.."/Tennis/Damen"..modus.."" },
                    { 2021, 2021, "Olympische Sommerspiele 2020/Tennis/Damen"..modus.."" },
                    { 2022, letztesJahr, "Olympische Sommerspiele "..jahr.."/Tennis/Damen"..modus.."" },
                  }
                
    para["CUP"] = {
                    { 1982, 1994, "Federation Cup "..jahr.."" },
                    { 1995, 2019, "Fed Cup "..jahr.."" },
                    { 2020, 2021, "Billie Jean King Cup 2020/21" },
                    { 2022, letztesJahr, "Billie Jean King Cup "..jahr.."" },
                  }

    return para[kuerzel]
end

local function turniereAndereKategorie()
    local para = {}
    para["CHI"] = {
                    { 1982, 1989 },
                    { 1991, 1997 },
                    { 2021, letztesJahr },
                  }
    para["BOC"] = {
                    { 1987, 1990 },
                  }
    para["DOH"] = {
                    { 2001, 2007 },
                    { 2011, 2011 },
                    { 2015, letztesJahr, "u" },
                  }
    para["DUB"] = {
                    { 2001, 2008 },
                    { 2012, 2014 },
                    { 2016, letztesJahr, "g" },
                  }
    para["IND"] = {
                    { 1989, 1996 },
                  }
    para["MIA"] = {
                    { 1994, 1987 },
                  }
    para["HHI"] = {
                    { 1984, 1989 },
                  }
    para["CHA"] = {
                    { 1986, 1987 },
                  }
    para["ROM"] = {
                    { 1987, 1989 },
                  }
    para["MAD"] = {
                    { 1996, 2003 },
                  }
    para["BER"] = {
                    { 1984, 1987 },
                    { 2020, letztesJahr },
                  }
    para["SDI"] = {
                    { 1982, 1982 },
                    { 1984, 2003 },
                  }
    para["CIN"] = {
                    { 1982, 1982 },
                    { 1988, 1988 },
                    { 2004, 2008 },
                  }
    para["KAN"] = {
                    { 1982, 1989 },
                  }
    para["TOK"] = {
                    { 1982, 1992 },
                    { 2014, 2019 },
                    { 2021, letztesJahr },
                  }
    para["ZUR"] = {
                    { 1984, 1992 },
                    { 2008, 2008 },
                  }
    para["PHI"] = {
                    { 1991, 1992 },
                    { 1996, 2000 },
                    { 2003, 2005 },
                  }
    para["MOS"] = {
                    { 1989, 1990 },
                    { 1994, 1996 },
                    { 2009, 2021 },
                  }
    para["GUA"] = {
                    { 2021, 2021 },
                  }
                 
    return para
end

local function statistikReihenfolge()
    local para = {}
    para = { "TTN", "EFI", "GET", "HSN", "SSN", "RSN", "TSN", "GSN", "PSN", "JEP" }
    
    return para  
end

local function statistikNamen(kuerzel)
    local para = {}
    para["TTN"] = { "Turnierteilnahmen" }
    para["EFI"] = { "Erreichte Finals" }
    para["GET"] = { "Gewonnene Titel" }
    para["HSN"] = { "Hartplatz-Siege/-Niederlagen" }
    para["SSN"] = { "Sand-Siege/-Niederlagen" }
    para["RSN"] = { "Rasen-Siege/-Niederlagen" }
    para["TSN"] = { "Teppich-Siege/-Niederlagen" }
    para["GSN"] = { "Gesamt-Siege/-Niederlagen" }
    para["PSN"] = { "Sieg%" }
    para["JEP"] = { "Jahresendposition" }    
    
    return para[kuerzel]
end

local function styles(style)
    local para = {}
    para["hintergrundfarbenTR"] = {
            { "AUO", "background", "#E5D1CB" }, { "FRO", "background", "#E5D1CB" }, { "WIM", "background", "#E5D1CB" },
            { "USO", "background", "#E5D1CB" }, { "WTC", "background", "#FFFFCC" }, { "MUN", "background", "#FFFFCC" },
            { "OLY", "background", "#FFD700" }, { "CUP", "background", "#C2B280" }, 
            { "TTN", "background", "white" }, { "EFI", "background", "white" }, { "HSN", "background", "white" },
            { "SSN", "background", "white" }, { "RSN", "background", "white" },
            { "TSN", "background", "white" }, { "GET", "background", "#EFEFEF" }, 
            { "PSN", "background", "white" }, { "GSN", "background", "#EFEFEF" }, { "JEP", "background", "#EFEFEF" },
        }
    para["schriftfarben"] = {
            { "n. a.", "color", "#696969" }, { "a. K.", "color", "#696969" }, { "nicht ausgetragen", "color", "#696969" },
            { "andere Kategorie", "color", "#696969" }, { "n. a. bzw. a. K.", "color", "#696969" },
            { "n. a. / a. K.", "color", "#696969" },
        }
    para["hintergrundfarbenTD"] = {
            { "HF", "background", "#FFE7BA" }, { "F", "background", "#BFEFFF" }, { "S", "background", "#FFF68F" },
        }
    para["hintergrundfarbenJEP"] = {
            { "3", "background", "#FFE7BA" }, { "2", "background", "#BFEFFF" }, { "1", "background", "#FFF68F" },
        }
    para["hintergrundfarbenTD_OLY"] = {
            { "S", "background", "#FFFF00" }, { "F", "background", "#C0C0C0" }, { "KF", "background", "#FFDAB9" },
            { "B", "background", "#CC9966" }
        }
    para["schrift"] = {
            { "S", "font-weight", "bold" }, { "JEP", "font-weight", "bold" }, { "GSN", "font-weight", "bold" },
            { "GET", "font-weight", "bold" },
        }
    
    return para[style]
end

local function holeStyle(wovon, ...)
    local para = {...}
    local stil = ""
    local style
    
    for s = 1, #para do
        style = para[s]
        local paraStyle = styles(style)
        for i = 1, #paraStyle do
            if(paraStyle[i][1] == wovon) then
                stil = stil..""..paraStyle[i][2]..":"..paraStyle[i][3]..";"                            
            end
        end
    end           
    return stil
end

local function holeErgebnis(turnier, jahrodergesamt)
    return daten:getParent().args[turnier..jahrodergesamt]
end

local function tabelleAnfang()
    local anfang = mw.html.create("table")
             :addClass("wikitable")
             :css("background", "#F7F8FF")
             :css("font-size", "95%")
             :css("border", "gray solid 1px")
             :css("border-collapse", "collapse")
             :css("margin", "0")
             :css("text-align", "center")
             :newline()
    return anfang
end

local function tabelleReihe()
    return mw.html.create("tr")
end

local function holeTurnierNamen(turnier)
    local turnierNamenPara = turniereTurnier(turnier)
    if(turnierNamenPara[1][2]) then
        for i = 1, #turnierNamenPara do
            if(letztesJahr <= turnierNamenPara[i][3]) then
                return turnierNamenPara[i][1]
            end
        end
    else  
        return turnierNamenPara[1][1]
    end
end

local function holeTurnierNamenJahr(turnier, jahr)
    local para = turniereNamen(turnier, jahr)
    for i = 1, #para do
        if(jahr >= para[i][1] and jahr <= para[i][2]) then
            return para[i][3]
        end
    end    
end

local function andereKnichtA(colspan, ak, na)
    local para = {}
    para["ak"] = { "a. K.", "andere Kategorie" }
    para["na"] = { "n. a.", "nicht ausgetragen" }
    para["akna"] = { "n. a. / a. K.", "n. a. bzw. a. K." }
    local i=1
    if(colspan>2) then
        i=2
    end
    if(ak == true and na == true) then
        return para["akna"][i]
    elseif(ak == true and na == false) then
        return para["ak"][i]
    elseif(ak == false and na == true) then
        return para["na"][i]
    end
end

local function unGerade(ug, startJahr, endeJahr)
    local i
    for jahr = startJahr, endeJahr do
        i = jahr % 2
        if(i==0 and ug == "g") then
            return true
        end
        if(i==1 and ug == "u") then
            return true
        end
    end
    return false
end

local function schaltjahr(...)
    local i
    local jahre = {...}
    local startJahr = jahre[1]
    if(jahre[2] ~= nil) then
        endeJahr = jahre[2]
        for jahr = startJahr, endeJahr do
            i = jahr % 4
            if(i==0) then
                return true
            end
        end
        return false
    end    
    
    i = startJahr % 4
    if(i==0) then
        return true
    end
    return false
end

local function einJahr(...)
    local i
    local jahre = {...}
    local startJahr = jahre[1]
    local endeJahr = jahre[2]
    if(startJahr ~= endeJahr) then
        return true
    end        

    local endePeriode = jahre[3]
    if(startJahr == endePeriode or startJahr == letztesJahr) then
        return true
    end
    return "warte"
end

local function trim(kette)
    if(kette == nil) then
        return kette
    end
    
    local startPos = 1
    local endePos = #kette
    while(startPos < endePos and string.byte(kette, startPos) <= 32) do
        startPos = startPos + 1
    end
    while(endePos > 0 and string.byte(kette, endePos) <= 32) do
        endePos = endePos - 1
    end
    return string.sub(kette, startPos, endePos)
end

local function extrahiereZahlen(kette)
    if(kette == nil) then
        return 0, 0
    end
    
    local i = string.find(kette, ":")
    if(i) then
        local s = string.sub(kette, 1, i-1)
        local n = string.sub(kette, i+1, -1)
        return tonumber(s), tonumber(n)
    end
    return 0, 0
end

local function ergebnisSauberUndTeilen(kette)
    if(kette == nil) then
        return kette
    end
    
    local i = string.find(kette, ",")
    if(i) then
        local e = trim(string.sub(kette, 1, i-1))
        local z = trim(string.sub(kette, i+1, -1))
        return e, z
    end
    return trim(kette)
end

local function runden(zahl)
    local zahl = zahl * 100    
    return zahl >= 0 and math.floor(zahl+0.5) or math.ceil(zahl-0.5)
end

local function sucheMuster(kette, stellen, muster)
    if(kette == nil) then
        return false
    end
    if(string.sub(kette, 1, stellen) == muster) then   
        return true
    end
    return false
end

local function pruefeQuali(ergebnisJahr)
    if(sucheMuster(ergebnisJahr, 1, "Q")) then
        return "/Qualifikation"
    end
    return ""
end

local function turierPruefeObTeilDerTabelle(turnier, para, ...)
    local jahre = {...}
    local startJahr = jahre[1]
    local endeJahr = jahre[1]
    if(jahre[2] ~= nil) then
        endeJahr = jahre[2]
    end
    
    if(para[turnier] ~= nil) then
        for i = 1, #para[turnier] do
            turnierPara = para[turnier][i]
            local startPeriode = turnierPara[1]
            local endePeriode = turnierPara[2]
            local zusatz = turnierPara[3]

            local ugse
            if(endeJahr >= startPeriode and startJahr <= endePeriode) then

                if(zusatz == "g" or zusatz == "u") then
                    ugse = unGerade(zusatz, startJahr, endeJahr)
                elseif(zusatz == "s") then
                    ugse = schaltjahr(startJahr, endeJahr)
                elseif(zusatz == "e") then
                    ugse = einJahr(startJahr, endeJahr, endePeriode)
                end            

                if(ugse == false) then
                    return false
                elseif(ugse == "warte") then
                    return "warte"
                else
                    return true
                end            
            end
        end
    end
    
    return false
end

local function tabelleJahre()
    local jahre = tabelleReihe()
    jahre:node(mw.html.create("th"):wikitext("Turnier"):newline())
    
    local paraTurniere = turniereReichenfolge()
    tabelleTurnierePlus = false
    for jahr = erstesJahr, letztesJahr do
        jahre:node(mw.html.create("th"):wikitext("[[WTA Tour "..jahr.."|"..jahr.."]]"):newline())
        
        if(tabelleTurnierePlus == false) then
            for t = 1, #paraTurniere do
                ergebnisJahr = trim(holeErgebnis(paraTurniere[t], jahr))
                if(ergebnisJahr ~= nil) then
                    if(string.find(ergebnisJahr, ",")) then
                        tabelleTurnierePlus = true
                    end
                end
            end
        end
    end
    
    if(tabelleTurnierePlus == false) then
        jahre:node(mw.html.create("th"):attr("colspan", 2):wikitext("Titel&nbsp;/&nbsp;Teiln."):newline())
    else
        jahre:node(mw.html.create("th"):node(mw.html.create("abbr"):wikitext("T&nbsp;/&nbsp;T"):attr("title", "Titel / Teilnahmen"):css("border-bottom", "0px dotted #ffffff"):newline()))
        jahre:node(mw.html.create("th"):node(mw.html.create("abbr"):wikitext("S/N"):attr("title", "Siege/Niederlagen"):css("border-bottom", "0px dotted #ffffff"):newline()))
        jahre:node(mw.html.create("th"):wikitext("Sieg%"):newline())
    end
    return jahre
end

local function tabelleTurnierTurnier(turnier)
    local turnierReihe = tabelleReihe()
                         :css("text-align", "left")
                         :cssText(holeStyle(turnier, "hintergrundfarbenTR"))
    
    local namenTurnier = holeTurnierNamen(turnier)
    local colspan = 0
    local ak = false
    local na = false
    local akna
    local warte = false
    local warteAttr = {}
    local style
    local ergebnisJahr
    local ergebnisJahrSN
    local s = 0
    local n = 0
    local summeS = 0
    local summeN = 0
    local teilnahme
    local turnierSiege = 0
    local turnierTeilnahmen = 0
    local turnierNamenJahr
    if(namenTurnier~=nil) then
        turnierReihe:node(mw.html.create("td"):wikitext("[["..namenTurnier.."]]"):newline())
       
        for jahr = erstesJahr, letztesJahr do

            teilnahme = turierPruefeObTeilDerTabelle(turnier, turniereAustragungszeitraum(), jahr)
            if(teilnahme == true) then
            
                if(colspan>0 and warte == false) then
                    if(naak == true) then
                        akna = andereKnichtA(colspan, ak, na)                    
                        turnierReihe:node(mw.html.create("td"):wikitext(akna)
                              :attr("colspan", colspan):cssText(holeStyle(akna, "schriftfarben"))
                              :css("text-align", "center")
                              :newline())
                    else
                        turnierReihe:node(mw.html.create("td"):attr("colspan", colspan)
                              :css("background", "#e8e9ea"):css("text-align", "center")
                              :newline())
                    end
                    colspan = 0
                    ak = false
                    na = false
                end
            
                turnierNamenJahr = holeTurnierNamenJahr(turnier, jahr)
                if(turnierNamenJahr ~= nil) then
                    ergebnisJahr = holeErgebnis(turnier, jahr)
                    ergebnisJahr, ergebnisJahrSN = ergebnisSauberUndTeilen(ergebnisJahr)
                    if(sucheMuster(ergebnisJahr, 1, "S")) then 
                        turnierSiege = turnierSiege +1
                    end
                    
                    if(tabelleTurnierePlus == true) then
                        s, n = extrahiereZahlen(ergebnisJahrSN)
                        summeS = summeS + s
                        summeN = summeN + n
                    end

                    if(warte == true) then
                        colspan = colspan+1                                                    
                        warteAttr = {["colspan"]=colspan}
                    end

                    if(ergebnisJahr ~= "&nbsp;" and ergebnisJahr ~= "" and ergebnisJahr ~= nil and ergebnisJahr ~= "—") then
                        if(turnier == "OLY") then
                            style = holeStyle(ergebnisJahr, "hintergrundfarbenTD_OLY", "schrift")
                        else
                            style = holeStyle(ergebnisJahr, "hintergrundfarbenTD", "schrift")
                        end
                              
                        turnierReihe:node(mw.html.create("td"):wikitext("[["..turnierNamenJahr..""..pruefeQuali(ergebnisJahr).."|"..ergebnisJahr.."]]")
                        :css("text-align", "center"):cssText(style):attr(warteAttr):newline())
                        
                        if(sucheMuster(ergebnisJahr, 1, "Q") == false) then
                            turnierTeilnahmen = turnierTeilnahmen + 1
                        end

                    elseif(ergebnisJahr == "" or ergebnisJahr == nil or ergebnisJahr == "—") then
                        turnierReihe:node(mw.html.create("td"):wikitext("–"):css("text-align", "center")
                        :attr(warteAttr):newline())
                    elseif(ergebnisJahr == "&nbsp;") then
                        turnierReihe:node(mw.html.create("td"):wikitext("&nbsp;")
                        :attr(warteAttr):newline())
                    end
                    
                    if(warte == true) then
                        warteAttr = {}
                        warte = false
                        colspan = 0
                    end
                end                         
            elseif(teilnahme == "warte") then
                warte = true
                colspan = colspan+1
            else   
                local andereKat = turierPruefeObTeilDerTabelle(turnier, turniereAndereKategorie(), jahr)
                colspan = colspan+1
                if(andereKat == true) then
                    ak = true
                else
                    na = true
                end           
            end            
        end
        
        if(colspan>0 and warte == false) then
            if(naak == true) then
                akna = andereKnichtA(colspan, ak, na)                    
                turnierReihe:node(mw.html.create("td"):wikitext(akna)
                      :attr("colspan", colspan):cssText(holeStyle(akna, "schriftfarben"))
                      :css("text-align", "center")
                      :newline())
            else
                turnierReihe:node(mw.html.create("td"):attr("colspan", colspan)
                      :css("background", "#e8e9ea"):css("text-align", "center")
                      :newline())
            end
        end
        
        if(tabelleTurnierePlus == true) then            
            turnierReihe:node(mw.html.create("td"):css("text-align", "center"):wikitext(turnierSiege.." / "..turnierTeilnahmen):newline())
            
            turnierReihe:node(mw.html.create("td"):css("text-align", "center"):wikitext(summeS..":"..summeN):newline())
            
            local siegeProzent = summeS/(summeS+summeN)
            if(summeS+summeN==0) then
                siegeProzent = "–"
            else
                siegeProzent = runden(siegeProzent).."%"
            end
            turnierReihe:node(mw.html.create("td"):css("text-align", "center"):wikitext(siegeProzent)
            :css("text-align", "center"):newline())
        else
            turnierReihe:node(mw.html.create("td"):attr("colspan", 2):wikitext(turnierSiege.." / "..turnierTeilnahmen)
            :css("text-align", "center"):newline())
        end
    end
   
    return turnierReihe
end

local function statistikAnfang()
    local tabelleStatistik = tabelleReihe()
          :css("background", "#efefef"):css("font-weight", "bold")
    
    local turnierStatistikPlusColspan
    if(tabelleTurnierePlus == true) then
        turnierStatistikPlusColspan=2
    else
        turnierStatistikPlusColspan=1
    end
    local colspan = letztesJahr - erstesJahr
    tabelleStatistik:node(mw.html.create("td")
          :attr("colspan", colspan+2):wikitext("Statistik"):css("text-align", "left"):newline())
                    
    tabelleStatistik:node(mw.html.create("td"):attr("colspan", turnierStatistikPlusColspan)
          :node(mw.html.create("abbr"):wikitext("S/N"):attr("title", "Siege/Niederlagen"):css("border-bottom", "0px dotted #ffffff"):css("text-align", "center"):newline()))
          
    tabelleStatistik:node(mw.html.create("td")
          :wikitext("Sieg%"):css("text-align", "center"):newline())
          
    return tabelleStatistik
end

local function holeStatistikNamen(kuerzel)
    local statistikNamenPara = statistikNamen(kuerzel)
    return statistikNamenPara[1] 
end

local gsnSpeicher = {}
local function erstelleGSNspeicher()
    for jahr = erstesJahr, letztesJahr do
        gsnSpeicher[""..jahr..""] = { "0:0" }
    end
end

local function addiereSummeGSN(jahr, s1, n1)
    local s, n
    s2, n2 = extrahiereZahlen(gsnSpeicher[""..jahr..""][1])
    s2 = s2 + s1
    n2 = n2 + n1
    gsnSpeicher[""..jahr..""][1] = s2..":"..n2
end

function tabelleStatistik(kuerzel)
    local statistikZahlen = tabelleReihe()
            :css("text-align", "left")
            :cssText(holeStyle(kuerzel, "hintergrundfarbenTR", "schrift"))
 
    local namenStatistik = holeStatistikNamen(kuerzel)
    local ergebnisJahr
    local summeTFT = 0
    local summeS = 0
    local S
    local summeN = 0
    local N
    local style
    local colspan = 1
    local siegeProzent
    
    if(namenStatistik~=nil) then
        statistikZahlen:node(mw.html.create("td"):wikitext(namenStatistik):newline())
        for jahr = erstesJahr, letztesJahr do
            
            if((kuerzel == "GSN" and parameterGSNerrechnen == true) or (kuerzel == "PSN")) then
                ergebnisJahr = gsnSpeicher[""..jahr..""][1]
            else
                ergebnisJahr = holeErgebnis(kuerzel, jahr)
            end
            
            if(kuerzel == "JEP" and (ergebnisJahr == "" or ergebnisJahr == nil)) then
                ergebnisJahr = "–"
            elseif((kuerzel == "TTN" or kuerzel == "EFI" or kuerzel == "GET") and (ergebnisJahr == nil or ergebnisJahr == "")) then
                ergebnisJahr = "0"
            elseif(ergebnisJahr == "" or ergebnisJahr == nil) then
                ergebnisJahr = "0:0"
            end
            
            if(kuerzel == "TTN" or kuerzel == "EFI" or kuerzel == "GET") then
                summeTFT = summeTFT + tonumber(ergebnisJahr)
            elseif(kuerzel == "PSN") then
                S, N = extrahiereZahlen(ergebnisJahr)
                siegeProzent = S/(S+N)
                if(S+N == 0) then
                    ergebnisJahr = "–"
                else
                    ergebnisJahr = runden(siegeProzent).."%"
                end
            elseif(kuerzel ~= "JEP") then
                S, N = extrahiereZahlen(ergebnisJahr)
                if(kuerzel ~= "GSN" and parameterGSNerrechnen == true) then
                    addiereSummeGSN(jahr, S, N)
                end           
                summeS = summeS + S
                summeN = summeN + N
            end
            
            if(kuerzel == "JEP") then
                style = holeStyle(ergebnisJahr, "hintergrundfarbenJEP")
            end
            
            if(kuerzel == "PSN") then
                statistikZahlen:node(mw.html.create("td"):wikitext(ergebnisJahr):css("text-align", "center"):cssText(style):newline())
            else
                statistikZahlen:node(mw.html.create("td"):wikitext(ergebnisJahr):css("text-align", "center"):cssText(style):newline())
            end
        end
    end
    
    local ergebnisGesamt
    if(kuerzel == "JEP") then
        colspan=2
        if(tabelleTurnierePlus) then
            colspan=3
        end
        statistikZahlen:node(mw.html.create("td"):attr("colspan", colspan):wikitext("N/A"):css("text-align", "center"):css("color", "#696969"):newline())
    elseif(kuerzel == "PSN") then
        colspan=1
        if(tabelleTurnierePlus) then
            colspan=2
        end
        statistikZahlen:node(mw.html.create("td"):attr("colspan", colspan):wikitext("Gesamt:"):css("text-align", "center"):newline())
    else
        if(kuerzel == "TTN" or kuerzel == "EFI" or kuerzel == "GET") then
            ergebnisGesamt = "Gesamt: "..summeTFT
            colspan=2
            if(tabelleTurnierePlus) then
                colspan=3
            end
        else
            ergebnisGesamt = summeS..":"..summeN
            if(tabelleTurnierePlus) then
                colspan=2
            end
        end
        statistikZahlen:node(mw.html.create("td"):attr("colspan", colspan):wikitext(ergebnisGesamt):css("text-align", "center"):newline())
    end
    
    if(kuerzel == "HSN" or kuerzel == "SSN" or kuerzel == "RSN" or kuerzel == "TSN" or kuerzel == "GSN") then
        siegeProzent = summeS/(summeS+summeN)
        if(summeS+summeN==0) then
            siegeProzent = "–"
        else
            siegeProzent = runden(siegeProzent).."%"
        end
        local rowspan=1
        if(kuerzel == "GSN" and parameterGSNerrechnen == true) then
            rowspan = 2
        end
        statistikZahlen:node(mw.html.create("td"):attr("rowspan", rowspan):wikitext(siegeProzent):css("text-align", "center"):newline())
    end
        
    return statistikZahlen
end

local function wirdParameterBenutzt(kuerzel)
    for jahr = erstesJahr, letztesJahr do
        if(holeErgebnis(kuerzel, jahr) ~= nil) then
            return true
        end
    end
    return false
end

function p.main(frame)
    daten = frame
    erstesJahr = tonumber(daten:getParent().args["ErstesJahr"])
    letztesJahr = tonumber(daten:getParent().args["LetztesJahr"])

    modus = "einzel"
    if(daten:getParent().args["Modus"] == "Doppel") then
        modus = "doppel"
    end
    
    naak = true
    if(daten:getParent().args["naak"] == "n") then
        naak = false
    end
    
    local tabelle = tabelleAnfang()
    
    tabelle:node(tabelleJahre())
    local paraTurniere = turniereReichenfolge()  
    local TeilnahmeImZeitraum 
    local parameterBenutzt 
    for t = 1, #paraTurniere do
        teilnahmeImZeitraum = turierPruefeObTeilDerTabelle(paraTurniere[t], turniereAustragungszeitraum(), erstesJahr, letztesJahr)
        parameterBenutzt = wirdParameterBenutzt(paraTurniere[t])
        if(teilnahmeImZeitraum and parameterBenutzt) then
            tabelle:node(tabelleTurnierTurnier(paraTurniere[t]):newline())
        end
    end
    

    local anfangStatistik = false
    parameterGSNerrechnen = false
    local paraStatistik = statistikReihenfolge()
    for s = 1, #paraStatistik do    
        parameterBenutzt = wirdParameterBenutzt(paraStatistik[s])
        
        if(parameterBenutzt or parameterGSNerrechnen) then
            if(anfangStatistik == false) then
                tabelle:node(statistikAnfang())
                anfangStatistik = true
            end
            
            if(parameterGSNerrechnen == false) then
                if(paraStatistik[s] == "HSN" or paraStatistik[s] == "SSN" or paraStatistik[s] == "RSN" or paraStatistik[s] == "TSN") then
                    erstelleGSNspeicher()
                    parameterGSNerrechnen = true
                end
            end            
            
            tabelle:node(tabelleStatistik(paraStatistik[s]):newline())            
        end
    end

    return tabelle
end

return p