MarkdownCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Json;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
 
namespace Waher.Content.Markdown
{
    public class MarkdownCodec : IContentDecoder, IContentEncoder, IJsonEncoder
    {
        private static bool allowEncoding = true;
        private static bool locked = false;
 
        public static void AllowRawEncoding(bool Allow, bool Lock)
        {
            if (locked)
                throw new InvalidOperationException("Setting has been locked.");
 
            allowEncoding = Allow;
            locked = Lock;
        }
 
        public static bool IsRawEncodingAllowed => allowEncoding;
 
        public static bool IsRawEncodingAllowedLocked => locked;
 
        public MarkdownCodec()
        {
        }
 
        public const string ContentType = "text/markdown";
 
        public string[] ContentTypes => contentTypes;
 
        private static readonly string[] contentTypes = new string[] { ContentType };
 
        public string[] FileExtensions
        {
            get
            {
                return new string[]
                {
                    "md",
                    "markdown"
                };
            }
        }
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(this.ContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public async Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding,
            KeyValuePair<string, string>[] Fields, Uri BaseUri, ICodecProgress Progress)
        {
            string s = Strings.GetString(Data, Encoding ?? Encoding.UTF8);
            MarkdownSettings Settings = new MarkdownSettings()
            {
                Progress = Progress
            };
            MarkdownDocument Doc;
 
            if (BaseUri is null)
                Doc = await MarkdownDocument.CreateAsync(s, Settings);
            else
            {
                Doc = await MarkdownDocument.CreateAsync(s, Settings,
                    string.Empty, string.Empty, BaseUri.ToString());
            }
 
            return new ContentResponse(ContentType, Doc, Data);
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is MarkdownContent && InternetContent.IsAccepted(contentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (allowEncoding && Object is MarkdownDocument &&
                InternetContent.IsAccepted(contentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Excellent;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public async Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding, ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            string Markdown;
 
            if (Object is MarkdownContent Content)
                Markdown = Content.Markdown;
            else if (allowEncoding && Object is MarkdownDocument MarkdownDocument)
                Markdown = await MarkdownDocument.GenerateMarkdown(true);
            else
                return new ContentResponse(new ArgumentException("Object not a markdown document.", nameof(Object)));
 
            string ContentType;
            byte[] Bin;
 
            if (Encoding is null)
            {
                ContentType = "text/markdown; charset=utf-8";
                Bin = Encoding.UTF8.GetBytes(Markdown);
            }
            else
            {
                ContentType = "text/markdown; charset=" + Encoding.WebName;
                Bin = Encoding.GetBytes(Markdown);
            }
 
            return new ContentResponse(ContentType, Object, Bin);
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            switch (FileExtension.ToLower())
            {
                case "md":
                case "markdown":
                    ContentType = MarkdownCodec.ContentType;
                    return true;
 
                default:
                    ContentType = string.Empty;
                    return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case MarkdownCodec.ContentType:
                    FileExtension = "md";
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public Grade Supports(Type ObjectType)
        {
            return ObjectType == typeof(MarkdownDocument) || ObjectType == typeof(MarkdownContent) 
                ? Grade.Excellent : Grade.NotAtAll;
        }
 
        public void Encode(object Object, int? Indent, StringBuilder Json)
        {
            string s;
 
            if (Object is MarkdownDocument MarkdownDocument)
                s = MarkdownDocument.GenerateMarkdown(false).Result;
            else if (Object is MarkdownContent MarkdownContent)
                s = MarkdownContent.Markdown;
            else
                s = string.Empty;
 
            Json.Append('"');
            Json.Append(JSON.Encode(s));
            Json.Append('"');
        }
 
    }
}