/**
 * This module focuses on methods for writing articles to disk.
 *
 * Article storage is broken into two parts, meta data and markdown content.
 * A folder location may be specified but markdown content will always be stored
 * in a sub folder `articleContentFolder`.
 */
module articlewriter;

import vibe.core.log;
import vibe.data.json;

import std;

import devto.api;

/**
 * This is the structure used to store article meta data as Json to disk.
 *
 * This content is pimarily defined from the devto API, where `content_file`
 * is a separate field used to define the relative filesystem location of
 * the markdown file to the meta file.
 */
struct ArticleMeta {
    @optional string title;
    @optional bool published;
    @optional int id;
    @optional int organization_id;
    @optional string canonical_url;
    @optional string description;
    @optional string main_image; // Cover image
    @optional string series;
    @optional string type_of;
    @optional string[] tags;
    @optional string content_file;
    @optional string slug;

    /**
     * Construct a Meta article from `ArticleMe`.
     *
     * Useful when processing existing articles from the devto API.
     */
    @safe pure nothrow @nogc
    this(ArticleMe me) {
        canonical_url = me.canonical_url;
        description = me.description;
        id = me.id;
        main_image = me.cover_image;
        published = me.published;
        series = "";
        tags = me.tag_list;
        title = me.title;
        type_of = me.type_of;
        slug = me.slug;
    }

    /**
     * Convert Meta data into `ArticleCreate`.
     *
     * Useful to call devto api to create an article.
     *
     * This does not retrieve the `content_file` from disk, it will be require
     * to add the `body_markdown` after making this conversion.
     */
    @safe pure nothrow @nogc
    T opCast(T : ArticleCreate)() {
        ArticleCreate ac;
        ac.title = title;
        ac.published = published;
        ac.series = series;
        ac.main_image = main_image;
        ac.canonical_url = canonical_url;
        ac.description = description;
        ac.tags = tags;
        ac.organization_id = organization_id;
        ac.slug = slug;
        return ac;
    }
}

/// This defines the sub folder for storing articles.
enum articleContentFolder = "Articles";

/**
 * Separate the Meta data and Content for easier disk writing and retrieval.
 */
alias Article = Tuple!(ArticleMeta, "meta", string, "content");

/**
 * Given a range of `ArticleMe` separate the data into meta data and content.
 *
 * Returns: Range of `Article`
 */
@safe pure nothrow
auto structureArticles(Range)(Range articles) if (isInputRange!Range
                                            && is(ElementType!Range == ArticleMe)) {
    return articles.map!(x => Article(ArticleMeta(x), x.body_markdown));
} unittest {
    auto exampleResponse = `[
  {
    "published_at":null,
    "canonical_url":"http://example.com/",
    "comments_count":0,
    "page_views_count":0,
    "id":12345,
    "published":false,
    "body_markdown":"Content Body",
    "title":"Article Title",
    "description":"",
    "tag_list":[
      "testing"
    ],
    "type_of":"article",
    "slug":"slugger"
  }]`.parseJsonString.meArticles;

    ArticleMeta ans;
    ans.type_of = "article";
    ans.id = 12345;
    ans.title = "Article Title";
    ans.description = "";
    ans.main_image = "";
    ans.published = false;
    ans.tags = ["testing"];
    ans.canonical_url = "http://example.com/";
    ans.series = "";
    ans.slug = "slugger";

    import std.algorithm;
    import std.conv;

    assert(structureArticles(exampleResponse).equal([Article(ans, "Content Body")]));
}

/*
 * Creates an iopipe output range for characters to the filename specified.
 */
@trusted
private auto fileWriter(string filename) {
    import iopipe.valve;
    import iopipe.textpipe;
    import iopipe.bufpipe;
    import std.io;

    return bufd!char
        .push!(p => p
            .encodeText
            .outputPipe(std.io.File(filename, mode!"w").refCounted))
        .textOutput;
}

/**
 * Meta information about pathing for article content and meta data.
 */
private struct Paths {
    /// Location article content/markdown is stored.
    string articleSaveLocation;
    /// Location meta data is stored.
    string metaSaveLocation;
    /// Article content location relative to metaSaveLocation,
    /// stored in meta data.
    string articleMetaPath;
}

/*
 * Creates a path relationship for an article.
 */
@safe pure nothrow
private Paths articlePaths(string folder, ArticleMeta am)
out(path) {
    assert(path.articleSaveLocation != path.metaSaveLocation, "Can't save to same file");
    assert(path.articleSaveLocation.endsWith(path.articleMetaPath), "Meta Reference to Article File must match.");
    assert(!path.articleSaveLocation.find(folder).empty, "Save Locations should utilized specified folder");
    assert(!path.metaSaveLocation.find(folder).empty, "Save Locations should utilized specified folder");
} do {
    Paths ret;

    auto filename = am.slug;
    assert(isValidFilename(filename), "Article Name Conflicts with valid file name.");

    ret.articleMetaPath = buildPath(articleContentFolder, filename.setExtension("md"));
    ret.articleSaveLocation = folder.buildPath(ret.articleMetaPath);
    ret.metaSaveLocation = folder.buildPath(filename.setExtension("devto"));

    return ret;
} unittest {
    ArticleMeta meta;
    meta.title = "Article Title";
    meta.slug = "article_title_oul3o";
    articlePaths("someLocation", meta);
}

/**
 * Writes articles to specified folder.
 *
 * Article content will be stored in `articleContentFolder` as a sub folder.
 *
 * Params:
 *     articles = Build from call to `structureArticles()`
 *     folder   = Filesystem folder location to place articles
 *
 * See Also:
 *     structureArticles, Article, articleContentFolder
 */
@safe
void saveArticles(Range)(Range articles, string folder) if(is(ElementType!Range == Article))
in(buildPath(folder,articleContentFolder).exists, format("Create direcorty `buildPath(\"%s\",articleContentFolder)` before calling to save articles.", folder))
{
    @trusted
    void saveArticle(Article article) {
        import std.algorithm : copy;
        auto paths = articlePaths(folder, article.meta);

        article.meta.content_file = paths.articleMetaPath;
        article.content.copy(fileWriter(paths.articleSaveLocation));
        article.meta.serializeToPrettyJson.copy(fileWriter(paths.metaSaveLocation));
    }

    articles.each!saveArticle;

}