SourceState.cs

using System.Threading.Tasks;
using Waher.Runtime.Collections;
 
namespace Waher.Content.Markdown.Consolidation
{
    public class SourceState
    {
        private readonly ChunkedList<DocumentInformation> documents = new ChunkedList<DocumentInformation>();
        private readonly string source;
        private DocumentType type = DocumentType.Empty;
        private string firstText = null;
        private int nrDocuments = 0;
        private readonly bool isDefault;
 
        public SourceState(string Source, bool IsDefault)
        {
            this.source = Source;
            this.isDefault = IsDefault;
        }
 
        public string Source => this.source;
 
        public bool IsDefault => this.isDefault;
 
        public async Task<string> GetFirstText()
        {
            if (!(this.firstText is null))
                return this.firstText;
 
            MarkdownDocument Doc = this.FirstDocument?.Markdown;
            if (Doc is null)
                return string.Empty;
 
            this.firstText = await Doc.GenerateMarkdown(false);
 
            return this.firstText;
        }
 
        public DocumentInformation FirstDocument
        {
            get
            {
                lock (this.documents)
                {
                    if (this.documents.Count == 0)
                        return null;
                    else
                        return this.documents[0];
                }
            }
        }
 
        public DocumentInformation[] Documents
        {
            get
            {
                lock (this.documents)
                {
                    return this.documents.ToArray();
                }
            }
        }
 
        public async Task<DocumentType> Add(MarkdownDocument Markdown, string Id)
        {
            DocumentInformation Info = await DocumentInformation.CreateAsync(Markdown, Id);
 
            lock (this.documents)
            {
                this.documents.Add(Info);
                this.nrDocuments++;
 
                if (this.nrDocuments == 1)
                    this.type = Info.Type;
                else
                    this.type = DocumentType.Complex;
 
                return this.type;
            }
        }
 
        public async Task<DocumentType> Update(MarkdownDocument Markdown, string Id)
        {
            if (string.IsNullOrEmpty(Id))
                return await this.Add(Markdown, Id);
 
            DocumentInformation Info = await DocumentInformation.CreateAsync(Markdown, Id);
            DocumentInformation Info2;
            int i, c;
 
            lock (this.documents)
            {
                c = this.documents.Count;
                for (i = 0; i < c; i++)
                {
                    Info2 = this.documents[i];
                    if (Info2.Id == Id)
                    {
                        this.documents[i] = Info;
 
                        if (this.nrDocuments == 1)
                            this.type = Info.Type;
 
                        return this.type;
                    }
                }
 
                this.documents.Add(Info);
                this.nrDocuments++;
 
                if (this.nrDocuments == 1)
                    this.type = Info.Type;
                else
                    this.type = DocumentType.Complex;
 
                return this.type;
            }
        }
    }
}