„Benutzer:Mps/AnimeListenUpdater.cs“ – Versionsunterschied

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;

namespace AnimeListenUpdater
{
  #region Exceptions
  class BusinessException : Exception
  {
    public BusinessException(string message)
    : base(message)
    { }
  }

  class MediawikiException : BusinessException
  {
    public string Code { get; }

    public MediawikiException(string message)
    : base(message)
    { }

    public MediawikiException(string code, string info)
    : base("Mediawiki error \"" + code + ": " + info + "\"")
    {
      Code = code;
    }
  }

  class MediawikiLagException : MediawikiException
  {
    public int LagTime { get; private set; }

    public MediawikiLagException(string code, string info)
    : base("Mediawiki error \"" + code + ": " + info + "\"")
    {
      LagTime = GetLagTime(info);
    }

    public static int GetLagTime(string info)
    {
      int lagtime = -1;
      Match match = Regex.Match(info, "Waiting for [^ ]*: ([0-9.-]+) seconds lagged");
      if (match.Success) int.TryParse(match.Groups[1].Value, out lagtime);
      return lagtime;
    }
  }
  #endregion

  public class Mediawiki
  {
    #region Netzwerk- und Mediawiki-Funktionen
    static CookieContainer cookieContainer = new CookieContainer();
    static readonly string userAgentString = GetUserAgentString();

    static string GetUserAgentString()
    {
      AssemblyName assemblyName = Assembly.GetExecutingAssembly().GetName();

      // Programmname und -version
      string userAgent = assemblyName.Name + "/" + assemblyName.Version.Major + "." + assemblyName.Version.Minor;
      // Umgebungsinformationen (OS, Laufzeitumgebung)
      userAgent += " (" + Environment.OSVersion.VersionString + "; .NET CLR " + Environment.Version + ")";

      return userAgent;
    }

    private static string EncodeQuery(string[,] query)
    {
      string result = "";
      for (int i = 0; i < query.GetLength(0); i++)
      {
        result += "&" + query[i, 0];
        string value = query[i, 1];
        if (value != null) result += "=" + Uri.EscapeDataString(value);
      }
      return result;
    }

    private static string MultipartQuery(string[,] postData, string boundaryIdentifier)
    {
      StringBuilder sb = new StringBuilder();
      for (int i = 0; i < postData.GetLength(0); i++)
      {
        sb.Append("--");
        sb.Append(boundaryIdentifier);
        sb.Append("\r\nContent-Disposition: form-data; name=\"");
        sb.Append(postData[i, 0]);
        sb.Append("\"\r\nContent-Type: text/plain; charset=UTF-8\r\nContent-Transfer-Encoding: 8bit\r\n\r\n");
        sb.Append(postData[i, 1]);
        sb.Append("\r\n");
      }
      return sb.ToString();
    }

    static HttpWebRequest GenerateHttpWebRequest(string language, string[,] query)
    {
      string url = "https://";
      if (language == "wikidata") url += "www.wikidata.org"; else url += language + ".wikipedia.org";
      url += "/w/api.php?format=xml";
      url += EncodeQuery(query);

      HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

      request.UserAgent = userAgentString;
      request.CookieContainer = cookieContainer;
      request.AutomaticDecompression = DecompressionMethods.GZip;
      request.KeepAlive = true;
      return request;
    }

    public static HttpWebResponse HttpGet(string language, string[,] query)
    {
      HttpWebRequest request = GenerateHttpWebRequest(language, query);
      return (HttpWebResponse)request.GetResponse();
    }

    public static HttpWebResponse HttpPost(string language, string[,] query, string[,] postData)
    {
      HttpWebRequest request = GenerateHttpWebRequest(language, query);
      request.Method = "POST";
      if (postData != null)
      {
        string boundary = Guid.NewGuid().ToString();
        byte[] postContent = new UTF8Encoding(false).GetBytes(MultipartQuery(postData, boundary));
        request.ContentType = "multipart/form-data; boundary=" + boundary;
        using (Stream stream = request.GetRequestStream())
        {
          stream.Write(postContent, 0, postContent.Length);
        }
      }
      return (HttpWebResponse)request.GetResponse();
    }

    public static void TraverseHttpWebResponse(HttpWebResponse response, Action<XmlReader> onXmlNode)
    {
      using (response)
      using (Stream stream = response.GetResponseStream())
      using (XmlReader reader = XmlReader.Create(stream))
      {
        if (!reader.ReadToFollowing("api")) throw new MediawikiException("Malformed response");

        while (reader.Read())
        {
          CheckForError(reader);
          onXmlNode(reader);
        }
      }
    }

    public static string CalcMd5Hash(byte[] data)
    {
      System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
      byte[] md5Hash = md5.ComputeHash(data);
      return BitConverter.ToString(md5Hash).Replace("-", "").ToLowerInvariant();
    }

    public static void CheckForError(XmlReader reader)
    {
      if (reader.NodeType == XmlNodeType.Element)
      {
        if (reader.LocalName == "warnings") Debug.WriteLine("  warning: " + reader.ReadInnerXml());
        else if (reader.LocalName == "error")
        {
          string code = reader.GetAttribute("code");
          string info = reader.GetAttribute("info");
          Debug.WriteLine(" error \"" + code + "\": " + info);
          if (code == "maxlag")
            throw new MediawikiLagException(code, info);
          else
            throw new MediawikiException(code, info);
        }
      }
    }

    public enum TokenType { Csrf, Watch, Patrol, Rollback, UserRights, Login, CreateAccount }

    public static string GetToken(string lang, TokenType tokenType)
    {
      string tokenName = tokenType.ToString().ToLowerInvariant();

      string[,] paramList = new[,] {
                { "action", "query" },
                { "meta", "tokens" },
                { "type", tokenName }
            };

      string token = null;
      TraverseHttpWebResponse(HttpPost(lang, paramList, null), reader =>
      {
        if ((reader.NodeType == XmlNodeType.Element) && (reader.LocalName == "tokens"))
        {
          token = reader.GetAttribute(tokenName + "token");
        }
      });
      return token;
    }

    public static void Login(string lang, NetworkCredential credentials)
    {
      string[,] paramList = new[,]
      {
                { "action", "login" },
                { "lgname", credentials.UserName },
                { "lgpassword", credentials.Password },
                { "lgtoken", GetToken(lang, TokenType.Login) }
            };

      TraverseHttpWebResponse(HttpPost(lang, paramList, null), reader =>
      {
        if ((reader.NodeType == XmlNodeType.Element) && (reader.LocalName == "login"))
        {
          string result = reader.GetAttribute("result");
          if (result != "Success")
          {
            if (result == "Throttled") result += $" (Please wait {reader.GetAttribute("wait")}s)";
            throw new MediawikiException(result);
          }
        }
      });
    }

    public static void Logout(string lang)
    {
      using (HttpWebResponse response = HttpGet(lang, new[,] { { "action", "logout" } })) { }
    }

    #endregion
  }

  public class Program
  {
    static Mediawiki wiki;
    static string editToken = null;

    public class AnimeItem
    {
      public string List;
      public int Level;
      public int Year;
      public string Type;
      public string EpisodeCount;
      public string Title;
      public string Link;
      public string JapaneseTitle;
      public string JapaneseTranscription;
      public List<string> AlternativeTitles;
      public List<string> Studios;

      public static AnimeItem Parse(Dictionary<string, string> parsedTemplate, string list)
      {
        AnimeItem result = new AnimeItem();
        try
        {
          result.List = list;
          result.Level = Int32.Parse(parsedTemplate["1"]);
          result.Year = Int32.Parse(parsedTemplate["2"]);
          result.Type = parsedTemplate["3"].Trim();
          result.EpisodeCount = parsedTemplate["4"].Trim();
          result.Title = parsedTemplate["5"].Trim();
          if (parsedTemplate.TryGetValue("link", out result.Link)) result.Link = result.Link.Trim();
          if (parsedTemplate.ContainsKey("j")) result.JapaneseTitle = parsedTemplate["j"].Trim(); else result.JapaneseTitle = "";
          if (parsedTemplate.ContainsKey("jt")) result.JapaneseTranscription = parsedTemplate["jt"].Trim(); else result.JapaneseTranscription = "";
          result.AlternativeTitles = new List<string>();
          result.Studios = new List<string>();
          for (int i = 1; i <= 10; i++)
          {
            string paramName = "a" + i;
            if (parsedTemplate.ContainsKey(paramName)) result.AlternativeTitles.Add(parsedTemplate[paramName].Trim());
            paramName = "s" + i;
            if (parsedTemplate.ContainsKey(paramName)) result.Studios.Add(parsedTemplate[paramName].Trim());
          }
          return result;
        }
        catch (KeyNotFoundException) { return null; }
        catch (FormatException) { return null; }
      }

      public string GetWikilink()
      {
        string result = "[[";
        if (!string.IsNullOrEmpty(Link)) result += Link + "|";
        result += Title + "]]";
        return result;
      }

      public static string GetWikiArticle(string wikilink)
      {
        if (string.IsNullOrEmpty(wikilink)) return "";
        else
        {
          // entferne Wikilinkklammern und splitte an der ersten Pipe
          string link = wikilink.TrimStart('[').TrimEnd(']').Split(new char[] { '|' }, 2)[0];
          // erstes Element (Zielartikel) mit Großbuchstaben beginnen lassen und zurückgeben
          link = Char.ToUpperInvariant(link[0]) + link.Substring(1);
          return link;
        }
      }

      public string GetYearListEntry()
      {
        StringBuilder sb = new StringBuilder();
        sb.Append("{{Anime-Listeneintrag|");
        sb.Append(0);
        sb.Append("|");
        sb.Append(Year);
        sb.Append("|");
        sb.Append(Type);
        sb.Append("|");
        sb.Append(EpisodeCount);
        sb.Append("|");
        sb.Append(Title);
        if (!string.IsNullOrEmpty(Link))
        {
          sb.Append("|link=");
          sb.Append(Link);
        }
        if (!string.IsNullOrEmpty(JapaneseTitle))
        {
          sb.Append("|j=");
          sb.Append(JapaneseTitle);
        }
        if (!string.IsNullOrEmpty(JapaneseTranscription))
        {
          sb.Append("|jt=");
          sb.Append(JapaneseTranscription);
        }
        for (int aIdx = 0; aIdx < AlternativeTitles.Count; aIdx++)
        {
          sb.Append("|a");
          sb.Append(aIdx + 1);
          sb.Append("=");
          sb.Append(AlternativeTitles[aIdx]);
        }
        for (int sIdx = 0; sIdx < Studios.Count; sIdx++)
        {
          sb.Append("|s");
          sb.Append(sIdx + 1);
          sb.Append("=");
          sb.Append(Studios[sIdx]);
        }
        sb.Append("|mark=year}}");
        return sb.ToString();
      }

      public override string ToString()
      {
        return Title;
      }
    }

    #region Konfiguration
    static UnicodeCategory[] validCharTypes = new UnicodeCategory[] {
            UnicodeCategory.UppercaseLetter, UnicodeCategory.LowercaseLetter, UnicodeCategory.TitlecaseLetter, UnicodeCategory.ModifierLetter, UnicodeCategory.OtherLetter,
            UnicodeCategory.DecimalDigitNumber, UnicodeCategory.LetterNumber, UnicodeCategory.OtherNumber, UnicodeCategory.SpaceSeparator };

    static string[] alphaList = new string[] { "0–9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
    static List<int> yearList = new List<int> { 1900, 1945, 1946, 1962, 1963, 1969, 1970, 1979, 1980, 1984, 1985, 1989, 1990, 1994, 1995, 1997, 1998, 1999 }; // ab 2000 wird automatisch generiert
    static Dictionary<string, string> animeTypes = new Dictionary<string, string> {
            { "F", "Film" },
            { "S", "Fernsehserie" },
            { "W", "Web-Anime" },
            { "O", "OVA" },
            { "SP", "Special" },
            { "K", "Kurzfilm" }
        };
    #endregion

    static Dictionary<string, string> ParseTemplate(string template)
    {
      Dictionary<string, string> result = new Dictionary<string, string>();

      int startPos = template.IndexOf("{{");
      int lastPos = template.LastIndexOf("}}");
      if (startPos >= 0 && lastPos >= 0)
      {
        string[] split = template.Substring(startPos + 2, lastPos - startPos - 2).Split('|');
        List<string> parameters = new List<string>();

        // Wikilinks wieder zusammenführen, d.h. "[[A", "B]]" zu "[[A|B]]".
        int doubleBracketCount = 0;
        for (int i = 0; i < split.Length; i++)
        {
          if (doubleBracketCount == 0) parameters.Add(split[i]); else parameters[parameters.Count - 1] += "|" + split[i];

          int curIdx = 0;
          while (curIdx >= 0)
          {
            curIdx = split[i].IndexOf("[[", curIdx);
            if (curIdx >= 0)
            {
              doubleBracketCount++;
              curIdx += 2;
            }
          }
          curIdx = 0;
          while (curIdx >= 0)
          {
            curIdx = split[i].IndexOf("]]", curIdx);
            if (curIdx >= 0)
            {
              doubleBracketCount--;
              curIdx += 2;
            }
          }
        }

        for (int paramIdx = 0; paramIdx < parameters.Count; paramIdx++)
        {
          string[] keyValue = parameters[paramIdx].Split(new char[] { '=' }, 2);
          try
          {
            if (keyValue.Length == 2) result.Add(keyValue[0], keyValue[1]); else result.Add(paramIdx.ToString(), parameters[paramIdx]);
          }
          catch (ArgumentException)
          {
            Console.Error.WriteLine("Doppelte Parameter: " + template);
          }
        }
      }
      return result;
    }

    // zur Sortierung alle Zeichen außer Buchstaben, Zahlen und Leerzeichen entfernen und Buchstaben in Kleinschreibung umwandeln
    static string RemoveDiacriticsAndSpecialChars(string text)
    {
      if (text.StartsWith("The ") || text.StartsWith("Der ") || text.StartsWith("Die ") || text.StartsWith("Das ")) text = text.Substring(4);

      return string.Concat(text.Normalize(NormalizationForm.FormKD).Where(ch => validCharTypes.Contains(CharUnicodeInfo.GetUnicodeCategory(ch)))).Normalize(NormalizationForm.FormKC).ToLowerInvariant();
    }

    static void WriteContent(string pagetitle, string content, string basetimestamp = null)
    {
      if (editToken == null) editToken = Mediawiki.GetToken("de", Mediawiki.TokenType.Csrf);

      bool badToken;
      do
      {
        badToken = false;
        try
        {
          Console.Write("Schreibe " + pagetitle);
          string md5Hash = Mediawiki.CalcMd5Hash(new UTF8Encoding(false).GetBytes(content));

          var post = new string[3 + (basetimestamp != null ? 1 : 0), 2];
          post[0, 0] = "token";
          post[0, 1] = editToken;
          post[1, 0] = "text";
          post[1, 1] = content;
          post[2, 0] = "md5";
          post[2, 1] = md5Hash;
          if (basetimestamp != null)
          {
            post[3, 0] = "basetimestamp";
            post[3, 1] = basetimestamp;
          }

          using (HttpWebResponse response = Mediawiki.HttpPost("de", new[,] {
            { "assert", "user" },
            { "action", "edit" },
            { "title", pagetitle },
            { "notminor", null },
            { "summary", "Listen-Aktualisierung per [[Benutzer:Mps/AnimeListenUpdater.cs]]" } },
            post))
          using (Stream stream = response.GetResponseStream())
          using (XmlReader reader = XmlReader.Create(stream))
          {
            while (reader.Read()) Mediawiki.CheckForError(reader);
          }
          Console.WriteLine(".");
        }
        catch (MediawikiException mwe)
        {
          Console.Error.WriteLine("\n" + pagetitle + ": " + mwe.Message);
          if (mwe.Code == "badtoken")
          {
            // Die API wirft manchmal "badtoken", daher einfach Edit nochmal probieren.
            Console.Error.WriteLine("  Neuer Versuch.");
            badToken = true;
          }
        }
      } while (badToken);
    }

    static bool BuildAnimeYearList(List<AnimeItem> animeList, int startYear, int endYear, TextWriter writer)
    {
      writer.WriteLine("__ABSCHNITTE_NICHT_BEARBEITEN__ __KEIN_INHALTSVERZEICHNIS__");
      writer.WriteLine("Dies ist eine '''chronologisch sortierte Liste der Anime-Titel''' von " + startYear + " bis " + endYear + ".");
      writer.WriteLine("<!--");
      writer.WriteLine("##########");
      writer.WriteLine("Bitte editiere diese Liste _nicht_, da sie von einem Bot automatisch generiert wird, der durchgeführte Änderungen überschreibt. Stattdessen können und sollten die alphabetisch sortierten Listen der Liste der Anime-Titel http://de.wikipedia.org/wiki/Liste_der_Anime-Titel bearbeitet werden, aus denen diese Liste generiert wird.");
      writer.WriteLine("##########");
      writer.WriteLine("-->");
      writer.WriteLine("{{Navigationsleiste Liste der Anime-Titel}}");
      writer.WriteLine();

      bool hasAtLeastOneYear = false;
      for (int year = startYear; year <= endYear; year++)
      {
        IEnumerable<AnimeItem> animesInYear = from anime in animeList
                                              where anime.Year == year
                                              orderby RemoveDiacriticsAndSpecialChars(anime.Title)
                                              select anime;

        if (animesInYear.Any())
        {
          hasAtLeastOneYear = true;
          writer.WriteLine("== " + year + " ==");
          writer.WriteLine("{{Anime-Listenkopf|");
          foreach (AnimeItem anime in animesInYear)
          {
            writer.WriteLine(anime.GetYearListEntry());
          }
          writer.WriteLine("|mark=year}}");
          writer.WriteLine();
        }
      }
      writer.WriteLine("[[Kategorie:Liste (Anime)|#" + startYear + "]]");

      return hasAtLeastOneYear;
    }

    static bool BuildAnimeStudioList(List<AnimeItem> animeList, TextWriter writer)
    {
      IEnumerable<string> linkedStudios = animeList.SelectMany(anime => anime.Studios)        // Studiolisten zusammenführen
          .Where(studio => studio.StartsWith("[["))                                           // nach verlinkten Studios filtern
          .Select(studio => AnimeItem.GetWikiArticle(studio))                                 // Linkklammern entfernen, nach Pipe separieren und nur erstes Element (Linkziel) zurückgeben
          .Distinct()                                                                         // doppelte Einträge entfernen
          .OrderBy(name => RemoveDiacriticsAndSpecialChars(name));                            // sortieren

      foreach (string curStudio in linkedStudios)
      {
        writer.WriteLine("{{#ifeq: {{{1}}}|" + curStudio + "|");

        Dictionary<string, List<AnimeItem>> animesOfStudio = animeList
            .Where(anime => anime.Studios.Any(studio => AnimeItem.GetWikiArticle(studio) == curStudio))    // nach Anime die vom aktuellen Studio gefertigt wurden filtern
            .OrderBy(anime => anime.Year + RemoveDiacriticsAndSpecialChars(anime.Title))            // nach Jahr und Titel sortieren
            .GroupBy(anime => anime.Type)                                                           // nach Typ gruppieren
            .ToDictionary(group => group.Key, group => group.ToList());                             // in assoziative Liste überführen

        // Generierungsregeln:
        // ab 10 Einträge pro Typ: eigene Gruppe (Reihenfolge: Fernsehserien, Filme, Original Video Animations, Specials, Kurzfilme, Weitere Anime-Produktionen)
        // ab 10 Einträge pro Gruppe: zwei Spalten, wobei bei ungerader Anzahl die erste Spalte länger ist
        bool hasCaptions = false;
        foreach (string animeType in animeTypes.Keys)
        {
          #region wenn ein Studio mehr als 10 Animes eines Typs produziert hat, diese separat aufführen
          if (animesOfStudio.ContainsKey(animeType) && animesOfStudio[animeType].Count >= 10)
          {
            hasCaptions = true;
            switch (animeType)
            {
              case "S":
                writer.WriteLine("=== Fernsehserien ===");
                break;
              case "F":
                writer.WriteLine("=== Filme ===");
                break;
              case "W":
                writer.WriteLine("=== Web-Animes ===");
                break;
              case "O":
                writer.WriteLine("=== Original Video Animations ===");
                break;
              case "SP":
                writer.WriteLine("=== Specials ===");
                break;
              case "K":
                writer.WriteLine("=== Kurzfilme ===");
                break;
            }
            writer.WriteLine("{{(!}} class=\"toptextcells\"");
            writer.WriteLine("{{!}}");

            int newColIdx = (int)Math.Ceiling(animesOfStudio[animeType].Count / 2.0);
            int animeIdx = 0;
            foreach (AnimeItem anime in animesOfStudio[animeType])
            {
              writer.WriteLine("* " + anime.Year + ": ''" + anime.GetWikilink() + "''");
              animeIdx++;
              if (animeIdx == newColIdx) writer.WriteLine("{{!}}");
            }

            writer.WriteLine("{{!)}}");

            animesOfStudio.Remove(animeType);
          }
          #endregion
        }

        IEnumerable<AnimeItem> otherAnimes = animesOfStudio
            .SelectMany(kvp => kvp.Value)
            .OrderBy(anime => anime.Year + RemoveDiacriticsAndSpecialChars(anime.Title));

        if (otherAnimes.Any())
        {
          if (hasCaptions) writer.WriteLine("=== Weitere Anime-Produktionen ===");
          int newColIdx = (int)Math.Ceiling(otherAnimes.Count() / 2.0);
          if (hasCaptions || newColIdx >= 5)
          {
            writer.WriteLine("{{(!}} class=\"toptextcells\"");
            writer.WriteLine("{{!}}");
          }
          else newColIdx = -1;

          int animeIdx = 0;
          foreach (AnimeItem anime in otherAnimes)
          {
            string desc;
            if (animeTypes.ContainsKey(anime.Type)) desc = " (" + animeTypes[anime.Type] + ")"; else desc = "";
            writer.WriteLine("* " + anime.Year + ": ''" + anime.GetWikilink() + "''" + desc);
            animeIdx++;
            if (animeIdx == newColIdx) writer.WriteLine("{{!}}");
          }

          if (hasCaptions || newColIdx >= 5) writer.WriteLine("{{!)}}");
        }
        writer.Write("}}");
      }

      writer.Write("<div class=\"noprint\" style=\"padding-left:1em;\"><small>''Diese Liste wird aus den Einträgen der [[Liste der Anime-Titel]] generiert. Einträge können und sollten dort ergänzt werden.</small></div>");
      writer.Write("<noinclude>[[Kategorie:Vorlage:Film und Fernsehen]]</noinclude>");

      return true;
    }

    static bool BuildMaintainenceInfo(List<AnimeItem> animeList, TextWriter writer)
    {
      var allStudios = animeList.SelectMany(anime => anime.Studios, (anime, studio) => new { Name = studio, List = anime.List });

      var linkedStudios = allStudios
          .Where(studio => studio.Name.StartsWith("[["))
          .Select(studio => new { Name = AnimeItem.GetWikiArticle(studio.Name), List = studio.List })
          .GroupBy(studio => studio.Name)
          .Select(studio => new { Name = studio.Key, Count = studio.Count(), Lists = studio.Select(list => list.List).Distinct().OrderBy(list => list) })
          .OrderBy(studio => studio.Name);

      var unlinkedStudios = allStudios
          .Where(studio => !studio.Name.StartsWith("[["))
          .Select(studio => new { Name = studio.Name, List = studio.List })
          .GroupBy(studio => studio.Name)
          .Select(studio => new { Name = studio.Key, Count = studio.Count(), Lists = studio.Select(list => list.List).Distinct().OrderBy(list => list) });

      writer.WriteLine("== Nur teilweise verlinkte Studios ==");
      writer.WriteLine("{| class=\"wikitable sortable\"");
      writer.WriteLine("! Studio || Auftreten || Listen");
      foreach (var linkedStudio in linkedStudios)
      {
        var match = unlinkedStudios.FirstOrDefault(unlinkedStudio => unlinkedStudio.Name == linkedStudio.Name);

        if (match != null)
        {
          writer.WriteLine("|-\n| {0} || {1} || {2}", linkedStudio.Name, match.Count, string.Join(", ", match.Lists.Select(list => "[[Liste der Anime-Titel/" + list + "|" + list + "]]")));
        }
      }
      writer.WriteLine("|}\n");

      writer.WriteLine("== Potentiell verlinkbare Studios ==");
      writer.WriteLine("{| class=\"wikitable sortable\"");
      writer.WriteLine("! Studio || Anzahl || Listen");
      foreach (var unlinkedStudio in unlinkedStudios)
      {
        if (!string.IsNullOrEmpty(unlinkedStudio.Name) && unlinkedStudio.Count > 5 && linkedStudios.All(linkedStudio => linkedStudio.Name != unlinkedStudio.Name))
        {
          writer.WriteLine("|-\n| {0} || {1} || {2}", unlinkedStudio.Name, unlinkedStudio.Count, string.Join(", ", unlinkedStudio.Lists.Select(list => "[[Liste der Anime-Titel/" + list + "|" + list + "]]")));
        }
      }
      writer.WriteLine("|}\n");

      Dictionary<string, List<string>> combinedStudioList = allStudios
          .Where(studio => !string.IsNullOrEmpty(studio.Name))
          .Select(studio => new { Name = AnimeItem.GetWikiArticle(studio.Name), List = studio.List })
          .GroupBy(studio => studio.Name)
          .OrderBy(studio => studio.Key)
          .ToDictionary(group => group.Key, group => group.Select(studio => studio.List).Distinct().ToList());

      writer.WriteLine("== Ähnliche Studionamen ==");
      writer.WriteLine("{| class=\"wikitable sortable\"");
      writer.WriteLine("! Studio || Ähnliche Namen || Listen");
      string[] allStudiosArray = combinedStudioList.Keys.ToArray();
      for (int i = 0; i < allStudiosArray.Length; i++)
      {
        string targetStudio = allStudiosArray[i];
        Dictionary<string, int> similarStudios = new Dictionary<string, int>();
        for (int j = 0/*i + 1*/; j < allStudiosArray.Length; j++)
        {
          if (i == j) continue;

          string otherStudio = allStudiosArray[j];

          int dist = LevenshteinDistance(RemoveDiacriticsAndSpecialChars(targetStudio), RemoveDiacriticsAndSpecialChars(otherStudio));
          if (dist <= 2)
          {
            similarStudios.Add(otherStudio, dist);
          }
        }
        if (similarStudios.Count > 0)
        {
          writer.Write("|-\n| rowspan=\"{0}\" | {1} |", similarStudios.Count, targetStudio);

          foreach (string similarName in similarStudios.OrderBy(item => item.Value).Select(item => item.Key))
          {
            writer.WriteLine("| {0} || {1}\r\n|-", similarName,
                string.Join(", ", combinedStudioList[similarName].Select(list => "[[Liste der Anime-Titel/" + list + "|" + list + "]]")));
          }
        }
      }
      writer.WriteLine("|}");

      return true;
    }

    static int LevenshteinDistance(string source, string target)
    {
      if (string.IsNullOrEmpty(source) && string.IsNullOrEmpty(target)) return 0;
      if (string.IsNullOrEmpty(source)) return target.Length;
      if (string.IsNullOrEmpty(target)) return source.Length;

      int[,] d = new int[source.Length + 1, target.Length + 1];

      for (int i = 1; i <= source.Length; i++) d[i, 0] = i;
      for (int j = 1; j <= target.Length; j++) d[0, j] = j;

      for (int j = 1; j <= target.Length; j++)
      {
        for (int i = 1; i <= source.Length; i++)
        {
          if (source[i - 1] == target[j - 1])
            d[i, j] = d[i - 1, j - 1];
          else
            d[i, j] = new int[] {
                            d[i - 1, j] + 1,    // Löschung
                            d[i, j - 1] + 1,    // Einfügung
                            d[i - 1, j - 1] + 1 // Ersetzung
                        }.Min();
        }
      }

      return d[source.Length, target.Length];
    }

    struct ContentAndTimestamp
    {
      public string Content;
      public string Timestamp;
    }

    private static NetworkCredential GetCredentials()
    {
      Console.Write("Benutzer: ");
      string user = Console.ReadLine();
      Console.Write("Passwort: ");
      string password = string.Empty;
      // Sternchen zeigen, statt eingetipptem Passwort
      while (true)
      {
        ConsoleKeyInfo keyInfo = Console.ReadKey(true);
        if (keyInfo.Key == ConsoleKey.Enter)
        {
          Console.WriteLine();
          break;
        }
        else if (keyInfo.Key == ConsoleKey.Backspace)
        {
          if (password.Length > 0)
          {
            password = password.Remove(password.Length - 1);
            // bei Backspace: Cursor eine Position zurück, mit Leerzeichen überschreiben, wieder eine Position zurück
            Console.Write(keyInfo.KeyChar + " " + keyInfo.KeyChar);
          }
        }
        else
        {
          password += keyInfo.KeyChar;
          Console.Write("*");
        }
      }
      Console.WriteLine();
      return new NetworkCredential(user, password);
    }

    static void Main(string[] args)
    {
      string matchStudiosFilename = null;
      NetworkCredential credentials = null;
      #region Kommandozeilenparameter auswerten
      string user = null, password = null;
      for (int i = 0; i < args.Length; i++)
      {
        if (args[i] == "-?")
        {
          Console.WriteLine(Assembly.GetExecutingAssembly().GetName() + " [Parameter]");
          Console.WriteLine();
          Console.WriteLine("-user Benutzername      Benutzername angeben");
          Console.WriteLine("-pass Passwort          Passwort angeben");
          Console.WriteLine("-matchstudios Datei     Studionamen in den Jahreslisten angleichen.");
          Console.WriteLine("                        Eingabe ist eine UTF8-kodierte Datei die zeilenweise die Ersetzungen angibt im Format: Ist<TAB>Soll");
          return;
        }
        else
            if (i + 1 < args.Length)
        {
          switch (args[i])
          {
            case "-user":
              user = args[i + 1];
              i++;
              break;
            case "-pass":
              password = args[i + 1];
              i++;
              break;
            case "-matchstudios":
              matchStudiosFilename = args[i + 1];
              if (!File.Exists(matchStudiosFilename))
              {
                Console.WriteLine("Datei nicht gefunden!");
                return;
              }
              break;
          }
        }
      }
      if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(password)) { credentials = new NetworkCredential(user, password); }
      #endregion

      wiki = new Mediawiki();
      try
      {
        if (credentials == null) { credentials = GetCredentials(); }
        Mediawiki.Login("de", credentials);

        #region Eingabelisten lesen
        Console.WriteLine("Alphabetische Listen lesen:");
        Console.Write("  ");
        Dictionary<string, ContentAndTimestamp> alphabeticLists = new Dictionary<string, ContentAndTimestamp>();
        Parallel.ForEach(alphaList, letter =>
        {
          Mediawiki.TraverseHttpWebResponse(Mediawiki.HttpGet("de", new[,] {
                    { "action", "query" },
                    { "prop", "revisions" },
                    { "titles", "Liste der Anime-Titel/" + letter },
                    { "rvprop", "content|timestamp" } }),
                  delegate (XmlReader reader)
                  {
              if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "rev"))
              {
                string curTimestamp = reader.GetAttribute("timestamp");
                string content = reader.ReadString();
                lock (alphabeticLists)
                {
                  alphabeticLists.Add(letter, new ContentAndTimestamp() { Content = content, Timestamp = curTimestamp });
                  Console.Write(letter);
                }
              }
            });
        });
        Console.WriteLine();
        #endregion

        if (matchStudiosFilename != null)
        {
          #region Studionamen ersetzen
          Console.WriteLine("\nErsetzungen:");
          Dictionary<Regex, string> replacers = new Dictionary<Regex, string>();
          foreach (string line in File.ReadAllLines(matchStudiosFilename, Encoding.UTF8))
          {
            string[] items = line.Split('\t');
            if (items.Length >= 2) replacers.Add(new Regex(@"(\|\s*s[0-9]+\s*=\s*\[*)" + Regex.Escape(items[0]) + @"(\s*[\|}\]])", RegexOptions.Singleline | RegexOptions.CultureInvariant), items[1]);
            Console.WriteLine("  " + items[0] + " -> " + items[1]);
          }
          Console.Write("Fortfahren [j/n]: ");
          if (Console.ReadLine().ToLowerInvariant() == "j")
          {
            foreach (string letter in alphabeticLists.Keys.OrderBy(key => key))
            {
              string content = alphabeticLists[letter].Content;
              foreach (Regex replace in replacers.Keys) content = replace.Replace(content, "$1" + replacers[replace] + "$2");
              WriteContent("Liste der Anime-Titel/" + letter, content, alphabeticLists[letter].Timestamp);
            }
          }
          #endregion
        }
        else
        {
          #region Eingabelisten parsen
          List<AnimeItem> animeList = new List<AnimeItem>();
          Regex templateRegex = new Regex(@"\{\{\s*Anime\-Listeneintrag.+?}}", RegexOptions.Singleline);
          Regex commentRegex = new Regex(@"<!--.+?-->", RegexOptions.Singleline);
          foreach (string letter in alphabeticLists.Keys.OrderBy(key => key))
          {
            Console.WriteLine("Liste " + letter);
            string content = commentRegex.Replace(alphabeticLists[letter].Content, "");
            foreach (Match match in templateRegex.Matches(content))
            {
              Dictionary<string, string> entry = ParseTemplate(match.Value);
              AnimeItem anime = AnimeItem.Parse(entry, letter);
              if (anime != null)
              {
                animeList.Add(anime);
                //Console.WriteLine("  " + anime);
              }
              else Console.Error.WriteLine("Nicht auswertbarer Eintrag: " + match.Value);
            }
          }
          #endregion

          // Jahreslisten ergänzen
          int maxYear = animeList.Select(anime => anime.Year).Max();
          if (maxYear > DateTime.Now.Year + 1)
          {
            Console.Write("Das höchste gefundene Jahr ist " + maxYear + ". Jahreslisten bis dahin erstellen [j/n]: ");
            if (Console.ReadLine().ToLowerInvariant() != "j") return;
          }
          for (int year = 2000; year <= maxYear; year = year + 2)
          {
            yearList.Add(year);
            yearList.Add(year + 1);
          }
          for (int yearIdx = 0; yearIdx < yearList.Count / 2; yearIdx++)
          {
            int startYear = yearList[yearIdx * 2];
            int endYear = yearList[yearIdx * 2 + 1];

            TextWriter yearWriter = new StringWriter();
            if (BuildAnimeYearList(animeList, startYear, endYear, yearWriter))
              WriteContent("Liste der Anime-Titel (" + startYear + "–" + endYear + ")", yearWriter.ToString());
          }

          TextWriter studioWriter = new StringWriter();
          if (BuildAnimeStudioList(animeList, studioWriter)) WriteContent("Vorlage:Animestudio Werksliste", studioWriter.ToString());

          TextWriter maintainenceWriter = new StringWriter();
          if (BuildMaintainenceInfo(animeList, maintainenceWriter)) WriteContent("Benutzer:Mps/Test", maintainenceWriter.ToString());
        }
        Console.WriteLine("Fertig.");
      }
      catch (MediawikiException ex)
      {
        Console.Error.WriteLine("Mediawiki-Fehler: " + ex.Message);
      }
      finally
      {
        //wiki.Logout();
      }
#if (DEBUG)
      Console.ReadLine();
#endif
    }
  }
}