ToMarkdown.cs

using SkiaSharp;
using System;
using System.Collections.Generic;
using System.Text;
using Waher.Content.Markdown.Model;
using Waher.Runtime.Collections;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Graphs;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Objects.Matrices;
using Waher.Script.Operators.Logical;
using Waher.Script.Operators.Matrices;
 
namespace Waher.Content.Markdown.Functions
{
    public class ToMarkdown : FunctionOneVariable
    {
        public ToMarkdown(ScriptNode Argument, int Start, int Length, Expression Expression)
            : base(Argument, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(ToMarkdown);
 
        public override IElement Evaluate(IElement Argument, Variables Variables)
        {
            return new StringValue(Evaluate(Argument));
        }
 
        public static string Evaluate(IElement Argument)
        {
            if (Argument.AssociatedObjectValue is string s)
                return s;
 
            if (Argument.AssociatedObjectValue is IToMatrix ToMatrix)
                Argument = ToMatrix.ToMatrix();
 
            if (Argument is IMatrix Matrix)
                return MatrixToMarkdown(Matrix);
            else if (Argument is IVector Vector)
                return VectorToMarkdown(Vector);
            else if (Argument is ISet Set)
                return SetToMarkdown(Set);
            else if (Argument is Graph Graph)
                return GraphToMarkdown(Graph);
            else if (Argument is PixelInformation Pixels)
                return PixelsToMarkdown(Pixels);
            else if (Argument is SKImage Image)
                return ImageToMarkdown(Image);
            else
                return ToString(Argument) ?? string.Empty;
        }
 
        public static string MatrixToMarkdown(IMatrix Matrix)
        {
            StringBuilder Markdown = new StringBuilder();
            MatrixToMarkdown(Matrix, Markdown);
            return Markdown.ToString();
        }
 
        public static void MatrixToMarkdown(IMatrix Matrix, StringBuilder Markdown)
        {
            int Cols = Matrix.Columns;
            int Rows = Matrix.Rows;
            int Col, Row;
            IElement E;
            string s;
 
            if (Matrix is ObjectMatrix OM && OM.HasColumnNames)
            {
                foreach (string Name in OM.ColumnNames)
                {
                    Markdown.Append("| ");
                    Markdown.Append(MarkdownDocument.Encode(Name));
                    Markdown.Append(' ');
                }
            }
            else
            {
                for (Col = 1; Col <= Cols; Col++)
                {
                    Markdown.Append("| ");
                    Markdown.Append(Col.ToString());
                    Markdown.Append(' ');
                }
            }
 
            Markdown.AppendLine("|");
 
            for (Col = 0; Col < Cols; Col++)
            {
                switch (ColumnAlignment(Matrix, Col))
                {
                    case TextAlignment.Left:
                        Markdown.Append("|:--");
                        break;
 
                    case TextAlignment.Center:
                        Markdown.Append("|:-:");
                        break;
 
                    case TextAlignment.Right:
                        Markdown.Append("|--:");
                        break;
 
                    default:
                        Markdown.Append("|---");
                        break;
                }
            }
 
            Markdown.AppendLine("|");
 
            ChunkedList<KeyValuePair<string, string>> Notes = null;
 
            for (Row = 0; Row < Rows; Row++)
            {
                for (Col = 0; Col < Cols; Col++)
                {
                    Markdown.Append("| ");
 
                    E = Matrix.GetElement(Col, Row);
 
                    if (!(E?.AssociatedObjectValue is null))
                    {
                        s = Evaluate(E);
 
                        if (s.IndexOfAny(CommonTypes.CRLF) >= 0)
                        {
                            string NoteId = "n" + Guid.NewGuid().ToString().Replace("-", string.Empty);
 
                            if (Notes is null)
                                Notes = new ChunkedList<KeyValuePair<string, string>>();
 
                            Notes.Add(new KeyValuePair<string, string>(NoteId, s));
 
                            Markdown.Append("[^");
                            Markdown.Append(NoteId);
                            Markdown.Append(']');
                        }
                        else
                            Markdown.Append(s);
 
                        Markdown.Append(' ');
                    }
                }
 
                Markdown.AppendLine("|");
            }
 
            ChunkNode<KeyValuePair<string, string>> Loop = Notes?.FirstChunk;
            int i, c;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    KeyValuePair<string, string> Note = Loop[i];
 
                    Markdown.AppendLine();
                    Markdown.Append("[^");
                    Markdown.Append(Note.Key);
                    Markdown.Append("]:");
 
                    foreach (string Row2 in Note.Value.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n'))
                    {
                        Markdown.Append('\t');
                        Markdown.AppendLine(Row2);
                    }
                }
 
                Loop = Loop.Next;
            }
        }
 
        private static TextAlignment ColumnAlignment(IMatrix Matrix, int Column)
        {
            int Row;
            int Rows = Matrix.Rows;
            TextAlignment? Result = null;
            TextAlignment Cell;
            IElement E;
            object Obj;
 
            for (Row = 0; Row < Rows; Row++)
            {
                E = Matrix.GetElement(Column, Row);
                Obj = E.AssociatedObjectValue;
 
                if (Obj is null)
                    continue;
 
                if (Obj is string)
                    Cell = TextAlignment.Left;
                else if (Obj is double)
                    Cell = TextAlignment.Right;
                else if (Obj is bool)
                    Cell = TextAlignment.Center;
                else
                {
                    switch (Convert.GetTypeCode(Obj))
                    {
                        case TypeCode.Boolean:
                            Cell = TextAlignment.Center;
                            break;
 
                        case TypeCode.Char:
                        case TypeCode.DateTime:
                        case TypeCode.String:
                            Cell = TextAlignment.Left;
                            break;
 
                        case TypeCode.Byte:
                        case TypeCode.Decimal:
                        case TypeCode.Double:
                        case TypeCode.Int16:
                        case TypeCode.Int32:
                        case TypeCode.Int64:
                        case TypeCode.SByte:
                        case TypeCode.Single:
                        case TypeCode.UInt16:
                        case TypeCode.UInt32:
                        case TypeCode.UInt64:
                            Cell = TextAlignment.Right;
                            break;
 
                        case TypeCode.Empty:
                        case TypeCode.Object:
                        default:
                            continue;
                    }
                }
 
                if (!Result.HasValue)
                    Result = Cell;
                else if (Result.Value != Cell)
                    return TextAlignment.Left;
            }
 
            return Result ?? TextAlignment.Left;
        }
 
        public static string VectorToMarkdown(IVector Vector)
        {
            return EnumerableToMarkdown(Vector.ChildElements);
        }
 
        private static string EnumerableToMarkdown(IEnumerable<IElement> Elements)
        {
            StringBuilder Markdown = new StringBuilder();
 
            foreach (IElement E in Elements)
            {
                Markdown.AppendLine(ToString(E) ?? string.Empty);
                Markdown.AppendLine();
            }
 
            return Markdown.ToString();
        }
 
        public static string SetToMarkdown(ISet Set)
        {
            return EnumerableToMarkdown(Set.ChildElements);
        }
 
        public static string GraphToMarkdown(Graph Graph)
        {
            StringBuilder Markdown = new StringBuilder();
            GraphToMarkdown(Graph, Markdown);
            return Markdown.ToString();
        }
 
        public static void GraphToMarkdown(Graph Graph, StringBuilder Markdown)
        {
            Markdown.AppendLine("```graph");
            Graph.ToXml(Markdown);
            Markdown.AppendLine();
            Markdown.AppendLine("```");
            Markdown.AppendLine();
        }
 
        public static string PixelsToMarkdown(PixelInformation Pixels)
        {
            StringBuilder Markdown = new StringBuilder();
            PixelsToMarkdown(Pixels, Markdown);
            return Markdown.ToString();
        }
 
        public static void PixelsToMarkdown(PixelInformation Pixels, StringBuilder Markdown)
        {
            byte[] Bin = Pixels.EncodeAsPng();
 
            Markdown.AppendLine("```image/png");
            Markdown.AppendLine(Convert.ToBase64String(Bin));
            Markdown.AppendLine("```");
            Markdown.AppendLine();
        }
 
        public static string ImageToMarkdown(SKImage Image)
        {
            StringBuilder Markdown = new StringBuilder();
            ImageToMarkdown(Image, Markdown);
            return Markdown.ToString();
        }
 
        public static void ImageToMarkdown(SKImage Image, StringBuilder Markdown)
        {
            using (SKData Data = Image.Encode(SKEncodedImageFormat.Png, 100))
            {
                byte[] Bin = Data.ToArray();
 
                Markdown.AppendLine("```image/png");
                Markdown.AppendLine(Convert.ToBase64String(Bin));
                Markdown.AppendLine("```");
                Markdown.AppendLine();
            }
 
        }
    }
}