config.wyam

#n Wyam.Markdown
#n Wyam.Razor
#n Wyam.Yaml
#n Wyam.Html
#n Wyam.Feeds

using System.IO;
using System.Xml;
using System.Threading.Tasks;

// Normalize the culture for the examples so they produce the same output regardless of system culture
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = System.Globalization.CultureInfo.CreateSpecificCulture("ru-RU");
//System.Text.Encodings.Web.HtmlEncoder.Default = new System.Text.Encodings.Web.HtmlEncoder(UnicodeRanges.All);

Settings[Keys.Host] = "DotNet.Ru";
Settings[Keys.LinksUseHttps] = true;

//////////////////////////////////////////////////////////////////////
// Pipelines
//////////////////////////////////////////////////////////////////////

Pipelines.Add("News",
    ReadFiles("News/*.md"),
    FrontMatter(Yaml()),
    Markdown(),
    Execute((inputs, ctx, _) => EnrichByPersonInfo(inputs, ctx))
);

Pipelines.Add("Pages",
    ReadFiles("{!_,}*.cshtml"),
    FrontMatter(Yaml()),
    Meta("Id", (doc, ctx) => doc.Source.FileNameWithoutExtension.FullPath.ToLower()),
    Meta(Keys.RelativeFilePath, (doc, ctx) => doc.String("Id") + ".html"),
    Razor()
        .WithLayout("/_Layout.cshtml"),
    WriteFiles((doc, ctx) => "Www/" + doc.String(Keys.RelativeFilePath))
);

Pipelines.Add("Resources",
    CopyFiles("Resources/**")
        .To((source, dest) => dest.Path.FullPath.Replace("/Resources/", "/Www/"))
);

//////////////////////////////////////////////////////////////////////
// Seeds
//////////////////////////////////////////////////////////////////////

Pipelines.Add("Communities",
    ReadFiles(ctx => ResolveAuditPath(ctx) + "/db/communities/*.xml"),
    Xml(),
    Execute((inputs, ctx, _) => EnrichCommunity(inputs, ctx)),
    Meta("RedirectUrl", (doc, ctx) => doc.String("VkUrl"))
);

Pipelines.Add("CustomRedirects",
    ReadFiles("Redirects/*.yml"),
    Yaml(),
    Meta("SubDomain", (doc, ctx) => doc.Source.FileNameWithoutExtension.FullPath)
);

// Pipelines.Add("Dump",
//     ReadFiles("Diagnostics/Dump.cshtml"),
//     Meta(Keys.RelativeFilePath, (doc, ctx) => "dump.html"),
//     Razor(),
//     WriteFiles()
// );

Pipelines.Add("SubDomains",
    Documents("Communities"),
    Concat(
        Documents("CustomRedirects")
    ),
    Meta("Url", (doc, ctx) => BuildSubHostUrl(doc.String("SubDomain"))),
    Meta("SiteImage", (doc, ctx) => TryFindSiteImage(doc))
);

Pipelines.Add("SubDomainName",
    Documents("SubDomains"),
    Content((doc, ctx) => new Uri(doc.String("Url")).Host.ToLower()),
    WriteFiles((doc, ctx) => doc.String("SubDomain") + "/CNAME")
);

Pipelines.Add("SubDomainRedirect",
    Documents("SubDomains"),
    Razor()
        .WithLayout("/_Redirect.cshtml"),
    WriteFiles((doc, ctx) => doc.String("SubDomain") + "/index.html")
);

Pipelines.Add("SubDomainImage",
    Documents("SubDomains"),
    Where((doc, ctx) => doc.String("SiteImage") != null),
    CopyFiles((doc, ctx) => doc.String("SiteImage"))
        .To((source, dest) => ResolveSiteImageDestinationPathBecauseWyamSucks(source, dest))
);

/*
Pipelines.Add("News",
    ReadFiles("News/*.cshtml"),
    FrontMatter(Yaml()),
    //Content(String.Empty),
    Meta("Id", (doc, ctx) => doc.Source.Directory.Name.ToLower()),
    Meta(Keys.RelativeFilePath, (doc, ctx) => doc.String("id") + ".html"),
    Razor()
        .WithLayout("/_Layout.cshtml"),
    WriteFiles(),
    Branch(
        // Put the GenerateFeeds module inside a Branch module so that the feed
        // documents don't get added to the set of output documents for this pipeline
        GenerateFeeds(),
        WriteFiles()
    )
);

Pipelines.Add("BuildSitemap",
    Documents(@ctx.Documents),
    Sitemap(),
    WriteFiles((d, c) => "sitemap.xml")
);
*/

//////////////////////////////////////////////////////////////////////
// Helpers
//////////////////////////////////////////////////////////////////////

public string ResolveAuditPath(IExecutionContext context)
{
    var auditDirPath = context.FileSystem.RootPath.Parent.Combine("Audit").FullPath;
    if (!Directory.Exists(auditDirPath))
    {
        throw new ArgumentException("Can't find Audit at " + auditDirPath);
    }

    Info($"Audit directory not found at {auditDirPath}");

    return auditDirPath;
}

public string TryFindSiteImage(IDocument input)
{
    var imageDir = input.Source?.Directory?.FullPath;
    if (imageDir == null)
    {
        return null;
    }

    var id = input.String("Id");
    var imageName = String.Format("{0}-1280x640.png", id);
    var imageFullName = Path.Combine(imageDir, imageName);
    return File.Exists(imageFullName) ? imageFullName : null;
}

public FilePath ResolveSiteImageDestinationPathBecauseWyamSucks(IFile source, IFile destination)
{
    // Dirty hacks, tested only for redirect images
    var imageName = source.Path.FileName.FullPath;
    var idParts = imageName.Split('-');
    if (idParts.Length == 0 || String.IsNullOrWhiteSpace(idParts[0]))
    {
        throw new ArgumentException("Can't extract ID for " + imageName);
    }

    var id = idParts[0];
    var searchPattern = "Id: " + id;

    var yamlFile = source
        .Directory
        .GetFiles()
        .Where(file => file.Path.Extension == ".yml")
        .Where(file => file.ReadAllText().Contains(searchPattern))
        .Single();

    var shortName = yamlFile.Path.FileNameWithoutExtension.FullPath;
    var destinationDirectory = destination.Directory.Parent.GetDirectory(shortName);
    var destinationFile = destinationDirectory.GetFile(destination.Path.FileName.FullPath.ToLowerInvariant());

    return destinationFile.Path.FullPath;
}

public IReadOnlyList<IDocument> EnrichCommunity(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
    var outputs = new List<IDocument>(inputs.Count);
    var shortNameParser = new System.Text.RegularExpressions.Regex(@"(?<Prefix>\w{3})DotNet");

    foreach(var input in inputs)
    {
        var output = input;

        var name = input.String("Name");
        string subDomain = null;
        var match = shortNameParser.Match(name);
        if (match.Success)
        {
            subDomain = match.Groups["Prefix"].Value;
        }
        else
        {
            throw new ArgumentException("Can't resolve short name for " + name);
        }

        var metadata = new MetadataItems
        {
            { "SubDomain", subDomain },
            { "Title",  "Сообщество " + name },
            { "Description",  input.String("City") }
        };

        output = context.GetDocument(input, metadata);
        outputs.Add(output);
    }

    return outputs;
}

public string BuildSubHostUrl(string subDomain)
{
    var host = subDomain + "." + Settings[Keys.Host];
    var proto = (bool)Settings[Keys.LinksUseHttps] ? "https" : "http";
    return $"{proto}://{host}/";
}

public IReadOnlyList<IDocument> EnrichByPersonInfo(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
    var aliases = ResolvePersonAliases(context.FileSystem);
    var outputs = new List<IDocument>(inputs.Count);

    foreach(var input in inputs)
    {
        var output = input;

        var authorName = input.String("Author");
        if (!String.IsNullOrWhiteSpace(authorName) && aliases.TryGetValue(authorName, out var author))
        {
            var metadata = new MetadataItems
            {
                { "Author", author.Name },
                { "AuthorImage", author.Image },
                // TODO: MarkDown
                { "AuthorDescription", author.Description },
            };

            // TODO: Resolve Publisher name from Aliases map

            output = context.GetDocument(input, metadata);
        }

        outputs.Add(output);
    }

    return outputs;
}

public IReadOnlyDictionary<string, Person> ResolvePersonAliases(IReadOnlyFileSystem fileSystem)
{
    var auditDirPath = fileSystem.RootPath.Parent.Combine("Audit");
    var auditDir = fileSystem.GetDirectory(auditDirPath);

    if (!auditDir.Exists)
    {
        Info($"Audit directory not found at {auditDir.Path}");
        return new Dictionary<string, Person>();
    }

    Info($"Audit directory found at {auditDir.Path}");

    var people = auditDir
        .GetDirectory("./db/speakers")
        .GetFiles(SearchOption.AllDirectories)
        .Where(file => file.Path.FileName.FullPath == "index.xml")
        .Select(ReadPerson)
        .ToList();

    Info($"Found {people.Count} people");

    var aliases = people
        .SelectMany(person => person.Aliases.Concat(new[] { person.Name }), (person, alias) => new { Alias = alias, Person = person })
        // Skip duplicates
        .Where(aliased => aliased.Alias != "Александр Иванов" && aliased.Alias != "Евгений Пешков")
        .ToDictionary(aliased => aliased.Alias, aliased => aliased.Person);

    /*
    // Find duplicates
    var people2 = people
        .SelectMany(person => person.Aliases.Concat(new[] { person.Name }), (person, alias) => new { Alias = alias, Person = person })
        // Skip duplicates
        .Where(aliased => aliased.Alias != "Александр Иванов" && aliased.Alias != "Евгений Пешков");

    var aliases = new Dictionary<string, Person>();
    foreach (var person2 in people2)
    {
        if (aliases.ContainsKey(person2.Alias))
        {
            Info($"!!! Found duplicate alias: {person2.Alias}, {person2.Person.Image} !!!");
        }
        else
        {
            aliases.Add(person2.Alias, person2.Person);
        }
    }
    */

    return aliases;
}

public Person ReadPerson(IFile personFile)
{
    using (var personStream = personFile.OpenRead())
    {
        var xmlPerson = new XmlDocument();
        xmlPerson.Load(personStream);
        var xmlRoot = xmlPerson.DocumentElement;

        var name = xmlRoot.SelectSingleNode("/Speaker/Name").InnerText;
        var description = xmlRoot.SelectSingleNode("/Speaker/Description").InnerText;

        var aliases = new List<string>();
        var id = xmlRoot.SelectSingleNode("/Speaker/Id").InnerText;
        var latinName = id.Replace("-", " ");
        if (latinName != name)
        {
            aliases.Add(latinName);
        }

        var imageUrl = new Uri($"https://raw.githubusercontent.com/DotNetRu/Audit/master/db/speakers/{id}/avatar.jpg");

        return new Person(name, aliases, imageUrl, description);
    }
}

public void Info(string message)
{
    Wyam.Common.Tracing.Trace.Information(message);
}

public sealed class Person
{
    public Person(string name, IReadOnlyList<string> aliases, Uri image, string description)
    {
        Name = name;
        Aliases = aliases.ToList();
        Image = image;
        Description = description;
    }

    public string Name { get; }
    public IReadOnlyList<string> Aliases { get; }
    public Uri Image { get; }
    public string Description { get; }
}