XmlFileLedger.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Persistence.Serialization;
using Waher.Runtime.IO;
using Waher.Runtime.Profiling;
 
namespace Waher.Persistence.XmlLedger
{
    public class XmlFileLedger : ILedgerProvider, ILedgerExport
    {
        public const string Namespace = "http://waher.se/Schema/Export.xsd";
 
        private readonly XmlWriterSettings settings;
        private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1);
        private StreamWriter file;
        private DateTime lastEvent = DateTime.MinValue;
        private XmlWriter output;
        private TextWriter textOutput;
        private ILedgerExternalEvents externalEvents;
        private readonly FileNameTimeSequence fileSequence;
        private readonly string transform = null;
        private readonly int deleteAfterDays;
        private bool running;
 
        #region Construction
 
        public XmlFileLedger(string FileName)
            : this(FileName, string.Empty, 7)
        {
        }
 
        public XmlFileLedger(string FileName, int DeleteAfterDays)
            : this(FileName, string.Empty, DeleteAfterDays)
        {
        }
 
        public XmlFileLedger(string FileName, string Transform)
            : this(FileName, Transform, 7)
        {
        }
 
        public XmlFileLedger(string FileName, string Transform, int DeleteAfterDays)
        {
            this.file = null;
            this.output = null;
            this.fileSequence = new FileNameTimeSequence(FileName, true);
            this.transform = Transform;
            this.deleteAfterDays = DeleteAfterDays;
 
            this.settings = new XmlWriterSettings()
            {
                CloseOutput = true,
                ConformanceLevel = ConformanceLevel.Document,
                Encoding = Encoding.UTF8,
                Indent = true,
                IndentChars = "\t",
                NewLineChars = "\r\n",
                NewLineHandling = NewLineHandling.Replace,
                NewLineOnAttributes = false,
                OmitXmlDeclaration = false,
                WriteEndDocumentOnClose = true,
                Async = true
            };
 
            string FolderName = Path.GetDirectoryName(FileName);
 
            if (!string.IsNullOrEmpty(FolderName) && !Directory.Exists(FolderName))
            {
                Log.Informational("Creating folder.", FolderName);
                Directory.CreateDirectory(FolderName);
            }
        }
 
        public XmlFileLedger(TextWriter Output)
        {
            this.textOutput = Output;
            this.file = null;
            this.fileSequence = null;
            this.transform = null;
            this.deleteAfterDays = 0;
 
            this.settings = new XmlWriterSettings()
            {
                CloseOutput = true,
                ConformanceLevel = ConformanceLevel.Document,
                Encoding = Encoding.UTF8,
                Indent = true,
                IndentChars = "\t",
                NewLineChars = "\r\n",
                NewLineHandling = NewLineHandling.Replace,
                NewLineOnAttributes = false,
                OmitXmlDeclaration = false,
                WriteEndDocumentOnClose = true,
                Async = true
            };
 
            this.output = XmlWriter.Create(this.textOutput, this.settings);
            this.output.WriteStartDocument();
            this.output.WriteStartElement("LedgerExport", Namespace);
            this.output.Flush();
        }
 
        #endregion
 
        #region Persistance
 
        public string FileName => this.fileSequence.FileNamePattern;
 
        public string Transform => this.transform;
 
        public DateTime LastEvent => this.lastEvent;
 
        private async Task BeforeWrite()
        {
            if (this.fileSequence is null)
                return;
 
            if (!this.fileSequence.TryGetNewFileName(out string s))
                return;
 
            try
            {
                if (!(this.output is null))
                {
                    await this.output.WriteEndElementAsync();
                    await this.output.WriteEndDocumentAsync();
                    await this.output.FlushAsync();
                }
 
                this.file?.Dispose();
            }
            catch (Exception)
            {
                try
                {
                    await this.DisposeOutput();
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            this.file = null;
            this.output = null;
 
            try
            {
                this.file = File.CreateText(s);
                this.output = XmlWriter.Create(this.file, this.settings);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                this.output = null;
                return;
            }
 
            await this.output.WriteStartDocumentAsync();
 
            if (!string.IsNullOrEmpty(this.transform))
            {
                if (File.Exists(this.transform))
                {
                    try
                    {
                        byte[] XsltBin = await Runtime.IO.Files.ReadAllBytesAsync(this.transform);
 
                        await this.output.WriteProcessingInstructionAsync("xml-stylesheet", "type=\"text/xsl\" href=\"data:text/xsl;base64," +
                            Convert.ToBase64String(XsltBin) + "\"");
                    }
                    catch (Exception)
                    {
                        await this.output.WriteProcessingInstructionAsync("xml-stylesheet", "type=\"text/xsl\" href=\"" + this.transform + "\"");
                    }
                }
                else
                    await this.output.WriteProcessingInstructionAsync("xml-stylesheet", "type=\"text/xsl\" href=\"" + this.transform + "\"");
            }
 
            await this.output.WriteStartElementAsync(string.Empty, "LedgerExport", Namespace);
            await this.output.FlushAsync();
 
            if (this.deleteAfterDays > 0 && this.deleteAfterDays < int.MaxValue)
            {
                string FolderName = Path.GetDirectoryName(s);
 
                if (!string.IsNullOrEmpty(FolderName))
                    Files.DeleteOldFiles(FolderName, TimeSpan.FromDays(this.deleteAfterDays), SearchOption.AllDirectories, true);
            }
        }
 
        private async Task DisposeOutput()
        {
            if (!(this.output is null))
            {
                await this.output.FlushAsync();
                this.output.Dispose();
                this.output = null;
            }
 
            this.file?.Dispose();
            this.file = null;
 
            this.textOutput?.Flush();
            this.textOutput = null;
        }
 
        #endregion
 
        #region ILedgerProvider
 
        public Task Start()
        {
            this.running = true;
            return Task.CompletedTask;
        }
 
        public async Task Stop()
        {
            if (this.running)
            {
                this.running = false;
 
                if (!(this.output is null))
                {
                    await this.output.WriteEndElementAsync();
                    await this.output.WriteEndDocumentAsync();
                }
            }
 
            await this.Flush();
 
            this.output?.Dispose();
            this.output = null;
        }
 
        public async Task Flush()
        {
            if (!(this.output is null))
                await this.output.FlushAsync();
 
            if (!(this.file is null))
                await this.file.FlushAsync();
 
            if (!(this.textOutput is null))
                await this.textOutput.FlushAsync();
        }
 
        public Task NewEntry(object Object)
        {
            return this.OutputEntry("New", Object);
        }
 
        public Task UpdatedEntry(object Object)
        {
            return this.OutputEntry("Update", Object);
        }
 
        public Task DeletedEntry(object Object)
        {
            return this.OutputEntry("Delete", Object);
        }
 
        private async Task OutputEntry(string Method, object Object)
        {
            if (!this.running)
                return;
 
            GenericObject Obj = await Database.Generalize(Object);
            DateTime Timestamp = DateTime.UtcNow;
            this.lastEvent = Timestamp;
 
            await this.semaphore.WaitAsync();
            try
            {
                try
                {
                    await this.BeforeWrite();
 
                    if (!(this.output is null))
                    {
                        await this.output.WriteStartElementAsync(string.Empty, Method, Namespace);
                        await this.output.WriteAttributeStringAsync(string.Empty, "timestamp", string.Empty, XML.Encode(Timestamp));
                        await this.output.WriteAttributeStringAsync(string.Empty, "collection", string.Empty, Obj.CollectionName);
                        await this.output.WriteAttributeStringAsync(string.Empty, "type", string.Empty, Obj.TypeName);
                        await this.output.WriteAttributeStringAsync(string.Empty, "id", string.Empty, Obj.ObjectId.ToString());
 
                        foreach (KeyValuePair<string, object> P in Obj.Properties)
                            await ReportProperty(this.output, P.Key, P.Value, Namespace);
 
                        await this.output.WriteEndElementAsync();
                        await this.output.FlushAsync();
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        await this.DisposeOutput();
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
            finally
            {
                this.semaphore.Release();
            }
        }
 
        public static async Task ReportProperty(XmlWriter Output, string PropertyName, object PropertyValue, string Namespace)
        {
            if (PropertyValue is null)
            {
                await Output.WriteStartElementAsync(string.Empty, "Null", Namespace);
                if (!(PropertyName is null))
                    await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                await Output.WriteEndElementAsync();
            }
            else if (PropertyValue is Enum)
            {
                await Output.WriteStartElementAsync(string.Empty, "En", Namespace);
                if (!(PropertyName is null))
                    await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                await Output.WriteEndElementAsync();
            }
            else
            {
                switch (Type.GetTypeCode(PropertyValue.GetType()))
                {
                    case TypeCode.Boolean:
                        await Output.WriteStartElementAsync(string.Empty, "Bl", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, CommonTypes.Encode((bool)PropertyValue));
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Byte:
                        await Output.WriteStartElementAsync(string.Empty, "B", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Char:
                        await Output.WriteStartElementAsync(string.Empty, "Ch", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.DateTime:
                        await Output.WriteStartElementAsync(string.Empty, "DT", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, XML.Encode((DateTime)PropertyValue));
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Decimal:
                        await Output.WriteStartElementAsync(string.Empty, "Dc", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, CommonTypes.Encode((decimal)PropertyValue));
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Double:
                        await Output.WriteStartElementAsync(string.Empty, "Db", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, CommonTypes.Encode((double)PropertyValue));
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Int16:
                        await Output.WriteStartElementAsync(string.Empty, "I2", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Int32:
                        await Output.WriteStartElementAsync(string.Empty, "I4", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Int64:
                        await Output.WriteStartElementAsync(string.Empty, "I8", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.SByte:
                        await Output.WriteStartElementAsync(string.Empty, "I1", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Single:
                        await Output.WriteStartElementAsync(string.Empty, "Fl", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, CommonTypes.Encode((float)PropertyValue));
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.String:
                        string s = PropertyValue.ToString();
                        try
                        {
                            XmlConvert.VerifyXmlChars(s);
                            await Output.WriteStartElementAsync(string.Empty, "S", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, s);
                            await Output.WriteEndElementAsync();
                        }
                        catch (XmlException)
                        {
                            byte[] Bin = System.Text.Encoding.UTF8.GetBytes(s);
                            s = Convert.ToBase64String(Bin);
                            await Output.WriteStartElementAsync(string.Empty, "S64", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, s);
                            await Output.WriteEndElementAsync();
                        }
                        break;
 
                    case TypeCode.UInt16:
                        await Output.WriteStartElementAsync(string.Empty, "U2", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.UInt32:
                        await Output.WriteStartElementAsync(string.Empty, "U4", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.UInt64:
                        await Output.WriteStartElementAsync(string.Empty, "U8", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                        await Output.WriteEndElementAsync();
                        break;
 
                    case (TypeCode)2:   // DBNull:
                    case TypeCode.Empty:
                        await Output.WriteStartElementAsync(string.Empty, "Null", Namespace);
                        if (!(PropertyName is null))
                            await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                        await Output.WriteEndElementAsync();
                        break;
 
                    case TypeCode.Object:
                        if (PropertyValue is TimeSpan)
                        {
                            await Output.WriteStartElementAsync(string.Empty, "TS", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                            await Output.WriteEndElementAsync();
                        }
                        else if (PropertyValue is DateTimeOffset DTO)
                        {
                            await Output.WriteStartElementAsync(string.Empty, "DTO", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, XML.Encode(DTO));
                            await Output.WriteEndElementAsync();
                        }
                        else if (PropertyValue is CaseInsensitiveString Cis)
                        {
                            s = Cis.Value;
                            try
                            {
                                XmlConvert.VerifyXmlChars(s);
                                await Output.WriteStartElementAsync(string.Empty, "CIS", Namespace);
                                if (!(PropertyName is null))
                                    await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                                await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, s);
                                await Output.WriteEndElementAsync();
                            }
                            catch (XmlException)
                            {
                                byte[] Bin = System.Text.Encoding.UTF8.GetBytes(s);
                                s = Convert.ToBase64String(Bin);
                                await Output.WriteStartElementAsync(string.Empty, "CIS64", Namespace);
                                if (!(PropertyName is null))
                                    await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                                await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, s);
                                await Output.WriteEndElementAsync();
                            }
                        }
                        else if (PropertyValue is byte[] Bin)
                        {
                            await Output.WriteStartElementAsync(string.Empty, "Bin", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
 
                            byte[] Buf = null;
                            int c = Bin.Length;
                            int i = 0;
                            int d;
                            int j;
 
                            while (i < c)
                            {
                                d = c - i;
                                if (d > 49152)
                                    j = 49152;
                                else
                                    j = (int)d;
 
                                if (Buf is null)
                                {
                                    if (i == 0 && j == c)
                                        Buf = Bin;
                                    else
                                        Buf = new byte[j];
                                }
 
                                if (Buf != Bin)
                                    Buffer.BlockCopy(Bin, i, Buf, 0, j);
 
                                await Output.WriteElementStringAsync(string.Empty, "Chunk", Namespace, Convert.ToBase64String(Buf, 0, j));
                                i += j;
                            }
 
                            await Output.WriteEndElementAsync();
                        }
                        else if (PropertyValue is Guid)
                        {
                            await Output.WriteStartElementAsync(string.Empty, "ID", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "v", string.Empty, PropertyValue.ToString());
                            await Output.WriteEndElementAsync();
                        }
                        else if (PropertyValue is Array A)
                        {
                            await Output.WriteStartElementAsync(string.Empty, "Array", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "elementType", string.Empty, PropertyValue.GetType().GetElementType().FullName);
 
                            foreach (object Obj in A)
                                await ReportProperty(Output, null, Obj, Namespace);
 
                            await Output.WriteEndElementAsync();
                        }
                        else if (PropertyValue is GenericObject Obj)
                        {
                            await Output.WriteStartElementAsync(string.Empty, "Obj", Namespace);
                            if (!(PropertyName is null))
                                await Output.WriteAttributeStringAsync(string.Empty, "n", string.Empty, PropertyName);
                            await Output.WriteAttributeStringAsync(string.Empty, "type", string.Empty, Obj.TypeName);
 
                            foreach (KeyValuePair<string, object> P in Obj)
                                await ReportProperty(Output, P.Key, P.Value, Namespace);
 
                            await Output.WriteEndElementAsync();
                        }
                        else
                            throw new Exception("Unhandled property value type: " + PropertyValue.GetType().FullName);
                        break;
 
                    default:
                        throw new Exception("Unhandled property value type: " + PropertyValue.GetType().FullName);
                }
            }
        }
 
        public async Task ClearedCollection(string Collection)
        {
            if (!this.running)
                return;
 
            DateTime Timestamp = DateTime.UtcNow;
 
            await this.semaphore.WaitAsync();
            try
            {
                try
                {
                    await this.BeforeWrite();
 
                    if (!(this.output is null))
                    {
                        await this.output.WriteStartElementAsync(string.Empty, "Clear", Namespace);
                        await this.output.WriteAttributeStringAsync(string.Empty, "timestamp", string.Empty, XML.Encode(Timestamp));
                        await this.output.WriteAttributeStringAsync(string.Empty, "collection", string.Empty, Collection);
                        await this.output.WriteEndElementAsync();
                        await this.output.FlushAsync();
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        await this.DisposeOutput();
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
            finally
            {
                this.semaphore.Release();
            }
        }
 
        public void Register(ILedgerExternalEvents ExternalEvents)
        {
            if (!(this.externalEvents is null) && this.externalEvents != ExternalEvents)
                throw new Exception("An interface for external events has already been registered.");
 
            this.externalEvents = ExternalEvents;
        }
 
        public void Unregister(ILedgerExternalEvents ExternalEvents)
        {
            if (!(this.externalEvents is null) && this.externalEvents != ExternalEvents)
                throw new Exception("The registered interface for external events differs from the one presented.");
 
            this.externalEvents = null;
        }
 
        public Task<ILedgerEnumerator<T>> GetEnumerator<T>()
        {
            return Task.FromResult<ILedgerEnumerator<T>>(new NoEntries<T>());
        }
 
        public Task<ILedgerEnumerator<object>> GetEnumerator(string CollectionName)
        {
            return Task.FromResult<ILedgerEnumerator<object>>(new NoEntries<object>());
        }
 
        private class NoEntries<T> : ILedgerEnumerator<T>
        {
            public ILedgerEntry<T> Current => null;
            object IEnumerator.Current => null;
            public void Dispose() { }
            public bool MoveNext() => false;
            public Task<bool> MoveNextAsync() => Task.FromResult(false);
            public void Reset() { }
        }
 
        public Task<string[]> GetCollections()
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<bool> Export(ILedgerExport Output, LedgerExportRestriction Restriction)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> Export(ILedgerExport Output, LedgerExportRestriction Restriction, ProfilerThread Thread)
        {
            return Task.FromResult(true);
        }
 
        #endregion
 
        #region ILedgerExport
 
        private readonly LinkedList<KeyValuePair<string, object>> blockMetaData = new LinkedList<KeyValuePair<string, object>>();
        private string writtenCollection = null;
        private string writtenBlockId = null;
        private string currentCollection = null;
        private string currentBlockId = null;
        private string currentEntryObjectId = null;
        private string currentEntryObjectType = null;
        private EntryType currentEntryType = EntryType.New;
        private DateTimeOffset currentEntryTimestamp = DateTimeOffset.MinValue;
        private Dictionary<string, object> currentEntryProperties = null;
 
        public async Task<bool> StartLedger(ILedgerProvider Provider)
        {
            this.currentCollection = null;
            await this.Start();
            return true;
        }
 
        public async Task<bool> EndLedger()
        {
            await this.Stop();
            return true;
        }
 
        public Task<bool> StartCollection(string CollectionName)
        {
            this.currentCollection = CollectionName;
            return Task.FromResult(true);
        }
 
        public async Task<bool> EndCollection()
        {
            if (!(this.writtenCollection is null))
            {
                await this.output.WriteEndElementAsync();
                this.writtenCollection = null;
            }
 
            this.currentCollection = null;
            return true;
        }
 
        public Task<bool> StartBlock(string BlockID)
        {
            this.currentBlockId = BlockID;
            return Task.FromResult(true);
        }
 
        public Task<bool> BlockMetaData(string Key, object Value)
        {
            this.blockMetaData.AddLast(new KeyValuePair<string, object>(Key, Value));
            return Task.FromResult(true);
        }
 
        public async Task<bool> EndBlock()
        {
            if (!(this.writtenBlockId is null))
            {
                await this.output.WriteEndElementAsync();
                this.writtenBlockId = null;
                this.blockMetaData.Clear();
            }
 
            this.currentBlockId = null;
            return true;
        }
 
        public Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            this.currentEntryObjectId = ObjectId;
            this.currentEntryObjectType = TypeName;
            this.currentEntryType = EntryType;
            this.currentEntryTimestamp = EntryTimestamp;
 
            if (this.currentEntryProperties is null)
                this.currentEntryProperties = new Dictionary<string, object>();
            else
                this.currentEntryProperties.Clear();
 
            return Task.FromResult(true);
        }
 
        public async Task<bool> EndEntry()
        {
            if (!this.running)
                return false;
 
            await this.semaphore.WaitAsync();
            try
            {
                try
                {
                    await this.BeforeWrite();
 
                    if (!(this.output is null))
                    {
                        await this.WritePendingInfoLocked();
 
                        await this.output.WriteStartElementAsync(string.Empty, this.currentEntryType.ToString(), Namespace);
                        await this.output.WriteAttributeStringAsync(string.Empty, "timestamp", string.Empty, XML.Encode(this.currentEntryTimestamp));
                        await this.output.WriteAttributeStringAsync(string.Empty, "type", string.Empty, this.currentEntryObjectType);
                        await this.output.WriteAttributeStringAsync(string.Empty, "id", string.Empty, this.currentEntryObjectId);
 
                        foreach (KeyValuePair<string, object> P in this.currentEntryProperties)
                            await ReportProperty(this.output, P.Key, P.Value, Namespace);
 
                        await this.output.WriteEndElementAsync();
                        await this.output.FlushAsync();
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        await this.DisposeOutput();
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
            finally
            {
                this.semaphore.Release();
            }
 
            return true;
        }
 
        private async Task WritePendingInfoLocked()
        {
            if (!(this.currentBlockId is null) &&
                !(this.writtenBlockId is null) &&
                this.currentBlockId != this.writtenBlockId)
            {
                await this.output.WriteEndElementAsync();
                this.writtenBlockId = null;
                this.blockMetaData.Clear();
            }
 
            if (!(this.currentCollection is null) &&
                !(this.writtenCollection is null) &&
                this.currentCollection != this.writtenCollection)
            {
                await this.output.WriteEndElementAsync();
                this.writtenCollection = null;
            }
 
            if (this.writtenCollection is null)
            {
                await this.output.WriteStartElementAsync(string.Empty, "Collection", Namespace);
                await this.output.WriteAttributeStringAsync(string.Empty, "name", string.Empty, this.currentCollection);
                this.writtenCollection = this.currentCollection;
            }
 
            if (this.writtenBlockId is null)
            {
                await this.output.WriteStartElementAsync(string.Empty, "Block", Namespace);
                await this.output.WriteAttributeStringAsync(string.Empty, "id", string.Empty, this.currentBlockId);
                this.writtenBlockId = this.currentBlockId;
 
                if (!(this.blockMetaData.First is null))
                {
                    foreach (KeyValuePair<string, object> P in this.blockMetaData)
                        await ReportProperty(this.output, P.Key, P.Value, Namespace);
                }
            }
        }
 
        public async Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            if (!this.running)
                return false;
 
            await this.semaphore.WaitAsync();
            try
            {
                try
                {
                    await this.BeforeWrite();
 
                    if (!(this.output is null))
                    {
                        await this.WritePendingInfoLocked();
 
                        await this.output.WriteStartElementAsync(string.Empty, "Clear", Namespace);
                        await this.output.WriteAttributeStringAsync(string.Empty, "timestamp", string.Empty, XML.Encode(EntryTimestamp));
                        await this.output.WriteEndElementAsync();
                        await this.output.FlushAsync();
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        await this.DisposeOutput();
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
            finally
            {
                this.semaphore.Release();
            }
 
            return true;
        }
 
        public Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            this.currentEntryProperties[PropertyName] = PropertyValue;
            return Task.FromResult(true);
        }
 
        public async Task<bool> ReportError(string Message)
        {
            if (!this.running)
                return false;
 
            await this.semaphore.WaitAsync();
            try
            {
                try
                {
                    await this.BeforeWrite();
 
                    if (!(this.output is null))
                    {
                        await this.WritePendingInfoLocked();
 
                        await this.output.WriteCommentAsync(Message);
                        await this.output.FlushAsync();
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        await this.DisposeOutput();
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
            finally
            {
                this.semaphore.Release();
            }
 
            return true;
        }
 
        public Task<bool> ReportException(Exception Exception)
        {
            return this.ReportError(Exception.Message);
        }
 
        #endregion
 
    }
}