Scriptureparser.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Xml;
using System.Xml.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace UniversalBibleAPI
{

    public class ScriptureEventArgs : EventArgs
    {
        public string UnparsedReference { get; set; }
        public string BookNumber { get; set; }
        public string ChapterNumber { get; set; }
        public string VerseNumber { get; set; }
        public bool IsValid { get; set; }
    }

    public class Scriptureparser
    {
        List<string> ChapterNumbersList = new List<string>();
        List<string> VerseNumbersList = new List<string>();
        private string LastBookNumber;
        private string LastBook;
        private string tmpbook;
        XDocument BibleBookNames;
        public event EventHandler<ScriptureEventArgs> OnSingleScriptureParsed;
        public event EventHandler OnScriptureParsed;

        public Scriptureparser()
        {
            if (File.Exists("bnames.xml"))
            {
                BibleBookNames = XDocument.Load("bnames.xml");
            }
            else {

                BibleBookNames = XDocument.Parse(Properties.Resources.bnames);
            
            }
        }
        public void ParseScripture(string reference)
        {
            char[] delimiters = new char[] { ';' };
            char[] delimiters2 = new char[] { ',', ':' };
            try
            {
                string[] REFS = reference.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);
                foreach (string refer in REFS)
                {

                    if (OnSingleScriptureParsed != null)
                    {
                        string WorkingRef = refer.Trim().Replace(" ", ""); 

                        ScriptureEventArgs SEARGS = new ScriptureEventArgs();
                        SEARGS.IsValid = true;
                        SEARGS.UnparsedReference = WorkingRef;

                        Match RegMatchBook = Regex.Match(WorkingRef, "^[1-9]*[\\s]*[\\.]*[\\p{Lu}]+", RegexOptions.IgnoreCase);
                        if (SEARGS.IsValid = RegMatchBook.Success)
                        {

                            SEARGS.BookNumber = GetBookNumber(RegMatchBook.Value);
                            
                            if (SEARGS.BookNumber == "0") {
                                // Couldn't parse bible book name  
                                SEARGS.IsValid = false;
                            
                            }
                            WorkingRef = WorkingRef.Replace(RegMatchBook.Value, "");
                        }

                        string[] CVP = WorkingRef.Trim().Split(delimiters2, StringSplitOptions.RemoveEmptyEntries);

                        if (CVP.Length == 1)
                        {

                            SEARGS.IsValid = ExpandChapter(CVP[0]);

                            SEARGS.IsValid = ExpandChapterVerse("0");

                        }

                        if (CVP.Length == 0)
                        {

                            SEARGS.IsValid = ExpandChapter("0");

                            SEARGS.IsValid = ExpandChapterVerse("0");

                        }

                        if (CVP.Length == 2)
                        {

                            SEARGS.IsValid = ExpandChapter(CVP[0]);

                            SEARGS.IsValid = ExpandChapterVerse(CVP[1]);

                        }

                        foreach (string ChapterNumber in ChapterNumbersList)
                        {

                            SEARGS.ChapterNumber = ChapterNumber;
                            foreach (string VersNumber in VerseNumbersList)
                            {

                                SEARGS.VerseNumber = VersNumber;

                                OnSingleScriptureParsed(this, SEARGS);
                            }

                        }



                    }
                }

                if (OnScriptureParsed != null) {

                    OnScriptureParsed(this, new EventArgs());

                }

            }
            catch (Exception)
            {

                throw;
            }
        }

        public string GetOsisID(string BookNumber) {
             
            var descr = from n in BibleBookNames.Descendants("ID") where (n.Attribute("descr").Value == "english") select n;
            if (descr.Count() > 0)
            {
                var OsisID = from n in descr.ElementAt(0).Descendants("BOOK") where (n.Attribute("bnumber").Value == BookNumber) select n;
                if (OsisID.Count() > 0)
                {
                    return OsisID.ElementAt(0).Attribute("bshort").Value;
                }
                else
                {

                    return "0";
                }
            }
            else
            {

                return "0";
            }
        
        }
        public CurrentContentKey GetKeyFromLine(string Inputline) {
           
            CurrentContentKey tmp = new CurrentContentKey();
            tmp.Book = "0";
            tmp.Chapter = "0";
            tmp.Verse = "0";
            tmp.ContentText = "Nothing";
            tmp.ContentType = CurrentContentKey.TypeOfContentKey.Nothing;
            try
            {
               
                Match RegMatchBook = Regex.Match(Inputline, "(^[0-9]*[\\s]*[\\.]*[\\p{Lu}]+)[\\s]*([0-9]+)[,:]([0-9]+)[\\s]*(.+)", RegexOptions.IgnoreCase);
               
                if (RegMatchBook.Success)
                {
                   
                    tmp.Book = GetBookNumber(RegMatchBook.Groups[1].Value);                  
                    tmp.Chapter = RegMatchBook.Groups[2].Value;
                    tmp.Verse = RegMatchBook.Groups[3].Value;
                    tmp.ContentText = RegMatchBook.Groups[4].Value;
                    tmp.ContentType = CurrentContentKey.TypeOfContentKey.Verse;
                    return tmp;
                };

                RegMatchBook = Regex.Match(Inputline, "(^[0-9]+)[\\s]+([0-9]+)[\\s]*[,:][\\s]*([0-9]+)[\\s]+(.+)");

                if (RegMatchBook.Success)
                {

                    tmp.Book = GetBookNumber(RegMatchBook.Groups[1].Value);
                    tmp.Chapter = RegMatchBook.Groups[2].Value;
                    tmp.Verse = RegMatchBook.Groups[3].Value;
                    tmp.ContentText = RegMatchBook.Groups[4].Value;
                    tmp.ContentType = CurrentContentKey.TypeOfContentKey.Verse;
                    return tmp;
                };

                RegMatchBook = Regex.Match(Inputline, "^##(.+)");
                if (RegMatchBook.Success)
                {
                    tmp.ContentText = RegMatchBook.Groups[1].Value;
                    tmp.ContentType = CurrentContentKey.TypeOfContentKey.Remark;
                    return tmp;
                };

                RegMatchBook = Regex.Match(Inputline, "^#(.+)");
                if (RegMatchBook.Success)
                {
                    tmp.ContentText = RegMatchBook.Groups[1].Value;
                    tmp.ContentType = CurrentContentKey.TypeOfContentKey.Caption;
                    return tmp;
                };
                return tmp;
            }
            catch (Exception e)
            {

                tmp.ContentText = "Exception: " + e.Message;
                tmp.ContentType = CurrentContentKey.TypeOfContentKey.Nothing;
                return tmp;
            }
        
        }
        public string GetBookNumber(string Book)
        {
            if (Book == "") {

                LastBook = Book;
              
            };
            if (Book == LastBook)
            {
                return LastBookNumber;
            }
            else
            {
                tmpbook = Book.Replace(".", "").Replace(" ", "").ToLower().Trim();

                var BookNumber = from n in BibleBookNames.Descendants("BOOK") where (n.Attribute("bshort").Value.Replace(".", "").Replace(" ", "").ToLower().Trim() == tmpbook) select n.Attribute("bnumber").Value;
                
                if (BookNumber.Count() > 0)
                {
                    LastBook = Book;
                    LastBookNumber = BookNumber.ElementAt(0);
                    return BookNumber.ElementAt(0);
                }
                else
                {
                    BookNumber = from n in BibleBookNames.Descendants("BOOK") where (n.Value.Replace(".", "").Replace(" ", "").ToLower().Trim() == tmpbook) select n.Attribute("bnumber").Value;
                    if (BookNumber.Count() > 0)
                    {
                        LastBook = Book;
                        LastBookNumber = BookNumber.ElementAt(0);
                        return BookNumber.ElementAt(0);
                    }
                    else
                    {
                        return Book;
                    }
                };
            }
        }
        public string GetBookName(string BookNumber, string Descr, bool ShortBookName) {
            try
            {
                var BookName = from n in BibleBookNames.Descendants("BOOK") where (n.Parent.Attribute("descr").Value.ToLower() == Descr & n.Attribute("bnumber").Value == BookNumber) select n;
                if (BookName.Count() > 0)
                {
                    if (ShortBookName)
                    {
                        return BookName.ElementAt(0).Attribute("bshort").Value;
                    }
                    else {

                        return BookName.ElementAt(0).Value;
                    }
                }
                else {

                    return BookNumber;
                }
            }
            catch (Exception e)
            {
                
                throw e;
            }
        
        }
        private bool ExpandChapterVerse(string p)
        {
            char[] delimiters = new char[] { '.' };
            char[] delimiters2 = new char[] { '-' };
            bool IsValid = true;
            try
            {
                VerseNumbersList.Clear();
                string[] VerseParts = p.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);

                foreach (string VP in VerseParts)
                {

                    if (!VP.Trim().Contains("-"))
                    {

                        VerseNumbersList.Add(VP);
                    }
                    else
                    {

                        if (IsValid = Regex.Match(VP.Trim(), "^[1-9][0-9]*[-][1-9][0-9]*$").Success)
                        {

                            string[] RangeParts = VP.Split(delimiters2, StringSplitOptions.RemoveEmptyEntries);
                            int FromV = Convert.ToInt16(RangeParts[0]);
                            int TillV = Convert.ToInt16(RangeParts[1]);
                            if (FromV <= TillV)
                            {
                                for (int i = FromV; i <= TillV; i++)
                                {
                                    VerseNumbersList.Add(i.ToString());
                                }
                            }
                            else
                            {
                                for (int i = FromV; i >= TillV; i--)
                                {

                                    VerseNumbersList.Add(i.ToString());
                                }

                            };

                        }

                    }
                }


                return IsValid;

            }
            catch (Exception)
            {

                throw;
            }
        }
        private bool ExpandChapter(string p)
        {
            char[] delimiters = new char[] { '.' };
            char[] delimiters2 = new char[] { '-' };
            bool IsValid = true;
            try
            {
                ChapterNumbersList.Clear();
                string[] ChapterParts = p.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);

                foreach (string CP in ChapterParts)
                {

                    if (!CP.Trim().Contains("-"))
                    {

                        ChapterNumbersList.Add(CP);
                    }
                    else
                    {

                        if (IsValid = Regex.Match(CP, "^[1-9]+[-][1-9]+$").Success)
                        {

                            string[] RangeParts = CP.Trim().Split(delimiters2, StringSplitOptions.RemoveEmptyEntries);
                            int FromV = Convert.ToInt16(RangeParts[0]);
                            int TillV = Convert.ToInt16(RangeParts[1]);
                            if (FromV <= TillV)
                            {
                                for (int i = FromV; i <= TillV; i++)
                                {
                                    ChapterNumbersList.Add(i.ToString());
                                }
                            }
                            else
                            {
                                for (int i = FromV; i >= TillV; i--)
                                {

                                    ChapterNumbersList.Add(i.ToString());
                                }

                            };

                        }

                    }
                }


                return IsValid;

            }
            catch (Exception)
            {

                throw;
            }
        }
    }
}