/*
 * This work is licensed under the Creative Commons Attribution 2.5 License. 
 * To view a copy of this license, visit http://creativecommons.org/licenses/by/2.5/
 * or send a letter to Creative Commons, 543 Howard Street, 5th Floor, 
 * San Francisco, California, 94105, USA.
 * 
 * Original developer: David Betz <dfb@davidbetz.net>
 * 
*/

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.ServiceModel.Syndication;
using System.Text;
using Minima.Addon;
using Minima.Data.Context;
using Minima.Data.Entities;
using Minima.Helpers;

namespace Minima
{
    /// <summary>
    /// Class to simplify and centralize interaction with the database.
    /// </summary>
    public class MinimaFacade
    {
        #region Add-ons
        /// <summary>
        /// Pings Technorati - see www.technorati.com
        /// </summary>
        /// <param name="blogId">ID of the blog to ping</param>
        public void PingTechnorati(Int32 blogId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                Blog blog = null;

                try
                {
                    blog = db.Blogs.Single(p => p.BlogId == blogId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("That blog ID does not exist.", ex);
                    }
                }

                TechnoratiNotifier.Ping(blog.BlogTitle, new Uri(blog.BlogPrimaryUrl));
            }
        }
        #endregion

        #region Blogs

        /// <summary>
        /// Returns only the details of a blog
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <returns>A filled blog object; it does not contain entries</returns>
        public Blog GetBlogDetails(Int32 blogId, MinimaLINQDataContext db)
        {
            var all = db.Blogs.Single(p => p.BlogId == blogId);
            var shell = new Blog();

            foreach (var a in all.BlogEntries)
            {
                shell.BlogCreateDate = all.BlogCreateDate;
                shell.BlogDescription = all.BlogDescription;
                shell.BlogFeedTitle = all.BlogFeedTitle;
                shell.BlogFeedUrl = all.BlogFeedUrl;
                shell.BlogId = all.BlogId;
                shell.BlogPrimaryUrl = all.BlogPrimaryUrl;
                shell.BlogTitle = all.BlogTitle;
                shell.Labels = all.Labels;
            }

            return shell;
        }

        /// <summary>
        /// Returns the title of a blog
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <returns>Title of the blog</returns>
        public String GetBlogTitle(Int32 blogId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                return db.Blogs.Single(p => p.BlogId == blogId).BlogTitle;
            }
        }

        /// <summary>
        /// Returns a blog.
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="count">Number of most recent entries to retrieve</param>
        /// <param name="returnBlogEntryContent">If true, the content of the blog entries are returned.  Otherwise, it is not.  You should only return the content if you absolutely need it.</param>
        /// <returns>A filled blog object</returns>
        public Blog GetBlog(Int32 blogId, Int32 count, MinimaLINQDataContext db)
        {
            return db.Blogs.Single(p => p.BlogId == blogId);
        }

        /// <summary>
        /// Returns a blog entry by url mapping.  Mainly only used by the website.
        /// </summary>
        /// <param name="urlMapping">Url mapping as would be seen in the URL address.</param>
        /// <returns>A blog object filled with a single blog entry</returns>
        public BlogEntry GetBlogEntryByUrlMapping(Int32 blogId, String urlMapping, MinimaLINQDataContext db)
        {
            var blogEntry = (from be in db.BlogEntries
                             join beum in db.BlogEntryUrlMappings on be.BlogEntryId equals beum.BlogEntryId
                             where beum.BlogEntryUrlMappingName == urlMapping.ToLower() && be.BlogId == blogId
                             select be).First();

            return blogEntry;
        }

        #endregion

        #region Blog Entry

        /// <summary>
        /// Creates a blog entry
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="authorSet">Set of authors</param>
        /// <param name="title">Title of the blog entry</param>
        /// <param name="dateTime">Date and time of the blog entry, for "now" use a date before 1950</param>
        /// <param name="text">Content of the blog entry</param>
        /// <param name="labelSet">Set of labels, these will be created if they do not exist</param>
        /// <returns></returns>
        public Int32 CreateNewBlogEntry(Int32 blogId, Author[] authorSet, String title, String content, DateTime dateTime, Label[] labelSet, Boolean publish)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                if (authorSet == null || authorSet.Length < 1)
                {
                    throw new ArgumentNullException("Author may not be null");
                }
                else
                {
                    foreach (Author author in authorSet)
                    {
                        if (String.IsNullOrEmpty(author.AuthorEmail))
                        {
                            throw new ArgumentNullException("Author e-mail may not be null");
                        }
                    }
                }

                BlogEntry be = new BlogEntry();
                be.BlogId = blogId;
                be.BlogEntryTitle = title;
                be.BlogEntryText = content;
                be.BlogEntryStatusId = publish ? 1 : 3;

                if (dateTime.Year >= 1950)
                {
                    be.BlogEntryPostDateTime = dateTime;
                }

                be.BlogEntryModifyDateTime = DateTime.Now;

                db.BlogEntries.InsertOnSubmit(be);

                try
                {
                    db.SubmitChanges();
                }
                catch
                {
                }

                BlogEntryUrlMapping beum = new BlogEntryUrlMapping();
                beum.BlogEntryId = be.BlogEntryId;
                beum.BlogEntryUrlMappingName = CreateBlogEntryPostUrlMapping(title);
                db.BlogEntryUrlMappings.InsertOnSubmit(beum);
                db.SubmitChanges();

                if (labelSet != null && labelSet.Length > 0)
                {
                    foreach (Label label in labelSet)
                    {
                        var c = from p in db.Labels
                                select p;

                        Int32 labelId = 0;

                        String lower = label.LabelTitle.ToLower();
                        foreach (Label l in c)
                        {
                            if (l.LabelTitle.ToLower() == lower)
                            {
                                labelId = l.LabelId;
                                break;
                            }
                        }

                        if (labelId == 0)
                        {
                            Label l = new Label();
                            l.BlogId = blogId;
                            l.LabelTitle = label.LabelTitle;
                            db.Labels.InsertOnSubmit(l);
                            db.SubmitChanges();
                            labelId = l.LabelId;
                        }

                        LabelBlogEntry lbe = new LabelBlogEntry();
                        lbe.BlogEntryId = be.BlogEntryId;
                        lbe.LabelId = labelId;
                        db.LabelBlogEntries.InsertOnSubmit(lbe);
                        db.SubmitChanges();
                    }
                }

                if (authorSet != null && authorSet.Length > 0)
                {
                    foreach (Author author in authorSet)
                    {
                        var c = from p in db.Authors
                                select p;

                        Int32 authorId = 0;

                        String lower = author.AuthorEmail.ToLower();
                        foreach (Author l in c)
                        {
                            if (l.AuthorEmail.ToLower() == lower)
                            {
                                authorId = l.AuthorId;
                                break;
                            }
                        }

                        if (authorId == 0)
                        {
                            if (String.IsNullOrEmpty(author.AuthorEmail))
                            {
                                throw new ArgumentNullException("Author does not exist.  Therefore, the author name is required.");
                            }
                            Author l = new Author();
                            l.AuthorName = author.AuthorName;
                            l.AuthorEmail = author.AuthorEmail;
                            db.Authors.InsertOnSubmit(l);
                            db.SubmitChanges();

                            authorId = l.AuthorId;
                        }

                        BlogEntryAuthor lbe = new BlogEntryAuthor();
                        lbe.BlogEntryId = be.BlogEntryId;
                        lbe.AuthorId = authorId;
                        db.BlogEntryAuthors.InsertOnSubmit(lbe);
                        db.SubmitChanges();
                    }
                }
                else
                {
                    throw new ArgumentNullException("There must be at least one author for a blog entry");
                }

                return be.BlogEntryId;
            }
        }

        /// <summary>
        /// Deletes a blog entry.  For debug purposes only.
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry to delete</param>
        public void DeleteBlogEntry(Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var authorLinks = from p in db.BlogEntryAuthors where p.BlogEntryId == blogEntryId select p;
                var urlLinks = from p in db.BlogEntryUrlMappings where p.BlogEntryId == blogEntryId select p;
                var labelLinks = from p in db.LabelBlogEntries where p.BlogEntryId == blogEntryId select p;

                if (authorLinks.Count() > 0)
                {
                    foreach (BlogEntryAuthor t1 in authorLinks)
                    {
                        db.BlogEntryAuthors.DeleteOnSubmit(t1);
                    }
                }

                db.SubmitChanges();

                if (urlLinks.Count() > 0)
                {
                    foreach (BlogEntryUrlMapping t2 in urlLinks)
                    {
                        db.BlogEntryUrlMappings.DeleteOnSubmit(t2);
                    }
                }

                db.SubmitChanges();

                if (labelLinks.Count() > 0)
                {
                    foreach (LabelBlogEntry t3 in labelLinks)
                    {
                        db.LabelBlogEntries.DeleteOnSubmit(t3);
                    }
                }

                db.SubmitChanges();

                var b = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
                db.BlogEntries.DeleteOnSubmit(b);
                db.SubmitChanges();
            }
        }

        /// <summary>
        /// Updates various properties of a blog entry
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry to update</param>
        /// <param name="title">Title of the blog entry</param>
        /// <param name="content">Content of the blog entry, blank if no change</param>
        /// <param name="dateTime">Date and time of the blog entry, for "now" use a date before 1950</param>
        /// <param name="publish">Published on true, Draft on false</param>
        public void UpdateBlogEntry(Int32 blogEntryId, String title, String content, DateTime dateTime, Boolean publish)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                BlogEntry be = null;

                try
                {
                    be = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("Invalid blog entry ID.", ex);
                    }
                }

                if (dateTime.Year >= 1950)
                {
                    be.BlogEntryPostDateTime = dateTime;
                }

                be.BlogEntryStatusId = publish ? 1 : 3;

                if (!String.IsNullOrEmpty(content))
                {
                    be.BlogEntryText = content;
                }

                if (!String.IsNullOrEmpty(title))
                {
                    // Has this title's mapping  been used by a different blog entry?
                    String mapping = CreateBlogEntryPostUrlMapping(title);

                    var beumc = from p in db.BlogEntryUrlMappings
                                where p.BlogEntryUrlMappingName == mapping && p.BlogEntryId != blogEntryId
                                select p;

                    // Probably something I'll be fixing in the future...
                    if (beumc.Count() > 1)
                    {
                        throw new ArgumentException("This title's mapping has already been used, please change the title");
                    }

                    beumc = from p in db.BlogEntryUrlMappings
                            where p.BlogEntryUrlMappingName == mapping && p.BlogEntryId == blogEntryId
                            select p;

                    // If this is a new title completely, create a new mapping to allow access by
                    // the old and the new links
                    if (beumc.Count() < 1)
                    {
                        BlogEntryUrlMapping beum = new BlogEntryUrlMapping();
                        beum.BlogEntryId = blogEntryId;
                        beum.BlogEntryUrlMappingName = CreateBlogEntryPostUrlMapping(title);
                        db.BlogEntryUrlMappings.InsertOnSubmit(beum);
                        db.SubmitChanges();
                    }
                }

                be.BlogEntryTitle = title;

                db.SubmitChanges();
            }
        }

        /// <summary>
        /// Returns the ID of the blog that a blog entry to which a blog entry corresponds
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry</param>
        /// <returns>ID of the blog</returns>
        public Int32 GetBlogIdByBlogEntryId(Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                return db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId).BlogId;
            }
        }

        /// <summary>
        /// Returns the title of a blog entry by blog entry ID
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry</param>
        /// <returns>Title of the blog entry</returns>
        public String GetBlogEntryTitle(Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                return db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId).BlogEntryTitle;
            }
        }

        /// <summary>
        /// Returns a complete blog entry
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry</param>
        /// <returns>The blog entry object</returns>
        public BlogEntry GetBlogEntry(Int32 blogEntryId, MinimaLINQDataContext db)
        {
            return db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
        }

        public void DisableBlogEntry(Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var be = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
                be.BlogEntryStatusId = 2;

                db.SubmitChanges();
            }
        }

        public List<BlogEntryAccessSummary> GetCompleteBlogEntryLinkList(Int32 blogId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var blogEntries = from p in db.BlogEntries
                                  where p.BlogEntryStatusId == 1 && p.BlogId == blogId
                                  select p;

                List<BlogEntryAccessSummary> set = new List<BlogEntryAccessSummary>();

                foreach (var e in blogEntries)
                {
                    set.Add(new BlogEntryAccessSummary(new Uri(BlogEntrySupport.GetBlogEntryUrl(e)), e.BlogEntryPostDateTime));
                }

                return set;
            }
        }

        #endregion

        #region Feed

        /// <summary>
        /// Returns the feed URL of the blog
        /// </summary>
        /// <param name="blogId"></param>
        /// <returns>A feed object</returns>
        public Feed GetFeedUrl(Int32 blogId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var blog = db.Blogs.Single(p => p.BlogId == blogId);
                return new Feed(blog.BlogFeedTitle, blog.BlogFeedUrl);
            }
        }

        /// <summary>
        /// Publish RSS feed to specified location
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="maxNumberOfEntries">Maximum number of blog entries to return</param>
        /// <returns>XML of RSS Feed</returns>
        public SyndicationFeed GetRssFeed(Int32 blogId, Int32 maxNumberOfEntries)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var collection = from p in db.BlogEntries
                                 where p.BlogId == blogId && p.BlogEntryStatusId == 1
                                 orderby p.BlogEntryPostDateTime descending
                                 select p;

                SyndicationFeed feed = new SyndicationFeed();

                if (collection.Count() < 1)
                {
                    throw new ArgumentException("There are no blog entries");
                }

                var blog = db.Blogs.Single(p => p.BlogId == blogId);

                feed.Title = new TextSyndicationContent(blog.BlogTitle);
                feed.Description = new TextSyndicationContent(blog.BlogDescription);
                feed.Links.Add(new SyndicationLink(new Uri(MinimaConfiguration.Domain)));
                Collection<SyndicationItem> items = new Collection<SyndicationItem>();
                foreach (BlogEntry entity in collection)
                {
                    SyndicationItem item = new SyndicationItem();
                    StringBuilder authors = new StringBuilder();
                    foreach (BlogEntryAuthor a in entity.BlogEntryAuthors)
                    {
                        item.Authors.Add(new SyndicationPerson(a.Author.AuthorEmail, a.Author.AuthorName, MinimaConfiguration.Domain));
                    }

                    item.Title = new TextSyndicationContent(entity.BlogEntryTitle);

                    if (entity.BlogEntryUrlMappings.Count < 1)
                    {
                        throw new ArgumentNullException("Missing url mapping.  Every blog entry must have at least one associated url mapping.");
                    }

                    item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/{1}/{2}/{3}.aspx", UrlHelper.FixWebPath(MinimaConfiguration.Domain), entity.BlogEntryPostYear, (entity.BlogEntryPostMonth > 9 ? entity.BlogEntryPostMonth.ToString() : "0" + entity.BlogEntryPostMonth.ToString()), entity.BlogEntryUrlMappings.ElementAt(0).BlogEntryUrlMappingName))));

                    item.Summary = new TextSyndicationContent(entity.BlogEntryText);

                    item.PublishDate = new DateTimeOffset(entity.BlogEntryPostDateTime);

                    items.Add(item);
                    if (items.Count == maxNumberOfEntries)
                    {
                        break;
                    }
                }

                feed.Items = items;

                return feed;

                //+ Use this if you would like to obtain the XML output
                //StringBuilder b = new StringBuilder( );
                //StringWriter writer = new StringWriter(b);
                //XmlTextWriter xmlWriter = new XmlTextWriter(writer);
                //feed.SaveAsRss20(xmlWriter);
            }
        }
        #endregion

        #region Special

        /// <summary>
        /// Returns a blog.
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="count">Number of most recent entries to retrieve</param>
        /// <param name="returnBlogEntryContent">If true, the content of the blog entries are returned.  Otherwise, it is not.  You should only return the content if you absolutely need it.</param>
        /// <returns>A filled blog object</returns>
        public List<BlogEntry> GetBlogEntries(Int32 blogId, Int32 count, Boolean activeOnly, MinimaLINQDataContext db)
        {
            List<BlogEntry> blogEntries = null;
            if (activeOnly)
            {
                blogEntries = (from be in db.BlogEntries
                               where be.BlogId == blogId && be.BlogEntryStatusId == 1
                               orderby be.BlogEntryPostDateTime descending
                               select be).Take(count).ToList();
            }
            else
            {
                blogEntries = (from be in db.BlogEntries
                               where be.BlogId == blogId
                               orderby be.BlogEntryPostDateTime descending
                               select be).Take(count).ToList();
            }
            return blogEntries;
        }

        /// <summary>
        /// Returns the blog entries associated with a particular label.  This method is primarily for use by the website.
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="label">Friendly title of the label</param>
        /// <returns>A blog object</returns>
        public List<BlogEntry> GetBlogEntriesByLabel(Int32 blogId, String label, MinimaLINQDataContext db)
        {
            var results = (from be in db.BlogEntries
                           join lbe in db.LabelBlogEntries on be.BlogEntryId equals lbe.BlogEntryId
                           join l in db.Labels on lbe.LabelId equals l.LabelId
                           where be.BlogId == blogId && l.LabelFriendlyTitle.ToLower() == label.ToLower() && be.BlogEntryStatusId == 1
                           orderby be.BlogEntryPostDateTime descending
                           select be);

            return (List<BlogEntry>)results.ToList();
        }

        /// <summary>
        /// Returns the blog entries from a particular month, wrapped in a blog object.  This method is primarily for use by the website.
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="year">Year the blog entries were posted</param>
        /// <param name="month">Month the blog entries were posted</param>
        /// <returns></returns>
        public List<BlogEntry> GetBlogEntriesByMonth(Int32 blogId, Int32 year, Int32 month, MinimaLINQDataContext db)
        {
            Int32 daysInMonth = DateTime.DaysInMonth(year, month);

            DateTime start = new DateTime(year, month, 1);
            DateTime end = new DateTime(year, month, daysInMonth);

            var collection = (from be in db.BlogEntries
                              where be.BlogId == blogId && be.BlogEntryPostDateTime >= start && be.BlogEntryPostDateTime <= end && be.BlogEntryStatusId == 1
                              orderby be.BlogEntryPostDateTime descending
                              select be).ToList();
            return collection;
        }

        /// <summary>
        /// Returns information regarding archived entries.
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <returns>DataTable with a summary of archived information</returns>
        public List<GetArchivedEntryListResult> GetArchivedEntries(Int32 blogId, MinimaLINQDataContext db)
        {
            return db.GetArchivedEntryList(blogId).ToList();
        }

        #endregion

        #region Author

        /// <summary>
        /// Creates an author
        /// </summary>
        /// <param name="authorEmail">E-mail address of the author</param>
        /// <param name="authorName">Name of the author</param>
        /// <returns>ID of the created author.  The ID is for internal use, use the e-mail address as an identifier</returns>
        public Int32 CreateAuthor(String authorEmail, String authorName)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var collection = from p in db.Authors
                                 where p.AuthorEmail == authorEmail
                                 select p;

                if (collection.Count() > 0)
                {
                    return collection.First().AuthorId;
                }
                else
                {
                    Author author = new Author();
                    author.AuthorName = authorName;
                    author.AuthorEmail = authorEmail;
                    author.AuthorCreateDate = DateTime.Now;
                    db.Authors.InsertOnSubmit(author);
                    db.SubmitChanges();
                    return author.AuthorId;
                }
            }
        }

        /// <summary>
        /// Updates an author
        /// </summary>
        /// <param name="authorEmail">E-mail address of the author, this is the identifier</param>
        /// <param name="authorName">Name of the author</param>
        public void UpdateAuthor(String authorEmail, String authorName)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                Author author = null;

                try
                {
                    author = db.Authors.Single(p => p.AuthorEmail == authorEmail);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("Invalid author e-mail address.", ex);
                    }
                }

                author.AuthorName = authorName;
                author.AuthorEmail = authorEmail;
                db.SubmitChanges();
            }
        }

        /// <summary>
        /// Connects a author with a blog entry
        /// </summary>
        /// <param name="authorEmail">E-mail address of the author</param>
        /// <param name="blogEntryId">ID of the blog entry</param>
        public void ApplyAuthor(String authorEmail, Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var authors = from p in db.Authors
                              where p.AuthorEmail == authorEmail
                              select p;

                BlogEntry blogEntry = null;

                try
                {
                    blogEntry = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("Invalid blog entry ID.", ex);
                    }
                }

                if (authors.Count() > 0)
                {
                    var beac = from p in db.BlogEntryAuthors
                               where p.AuthorId == authors.First().AuthorId && p.BlogEntryId == blogEntryId
                               select p;

                    if (beac.Count() < 1)
                    {
                        BlogEntryAuthor bea = new BlogEntryAuthor();
                        bea.AuthorId = authors.First().AuthorId;
                        bea.BlogEntryId = blogEntryId;

                        db.BlogEntryAuthors.InsertOnSubmit(bea);
                        db.SubmitChanges();
                    }
                }
                else
                {
                    throw new ArgumentOutOfRangeException("That author does not exist.");
                }
            }
        }

        /// <summary>
        /// Disassociates an author from a blog entry, this does NOT delete the author
        /// </summary>
        /// <param name="authorEmail">E-mail address of the author</param>
        /// <param name="blogEntryId">ID of the blog entry</param>
        public void RemoveAuthor(String authorEmail, Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var authors = from p in db.Authors
                              where p.AuthorEmail == authorEmail
                              select p;

                BlogEntry blogEntry = null;

                try
                {
                    blogEntry = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("Invalid blog entry ID.", ex);
                    }
                }

                if (authors.Count() > 0)
                {
                    BlogEntryAuthor bea = null;

                    try
                    {
                        bea = db.BlogEntryAuthors.Single(p => p.BlogEntryId == blogEntryId && p.AuthorId == authors.First().AuthorId);
                    }
                    catch (InvalidOperationException ex)
                    {
                        if (ex.Message == "Sequence contains no elements")
                        {
                            throw new ArgumentOutOfRangeException("That author is not assigned to that blog entry.", ex);
                        }
                    }

                    db.BlogEntryAuthors.DeleteOnSubmit(bea);
                    db.SubmitChanges();
                }
                else
                {
                    throw new ArgumentOutOfRangeException("That author does not exist.");
                }
            }
        }

        /// <summary>
        /// Gets an author object by author e-mail address
        /// </summary>
        /// <param name="authorEmail">E-mail address of the author</param>
        /// <returns>Author object</returns>
        public Author GetAuthorByEmailAddress(String authorEmail, MinimaLINQDataContext db)
        {
            Author author = null;

            try
            {
                author = db.Authors.Single(p => p.AuthorEmail == authorEmail);
            }
            catch (InvalidOperationException ex)
            {
                if (ex.Message == "Sequence contains no elements")
                {
                    return null;
                }
            }

            return author;
        }

        #endregion

        #region Label

        /// <summary>
        /// Creates a label.  It does not create labels that already exist in a particular blog.
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="title">Title of the label</param>
        /// <returns>ID of the created label</returns>
        public Int32 CreateLabel(Int32 blogId, String title)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var labels = from p in db.Labels
                             where p.BlogId == blogId && p.LabelTitle == title
                             select p;

                if (labels.Count() > 0)
                {
                    return labels.First().LabelId;
                }

                labels = from p in db.Labels
                         where p.BlogId == blogId && p.LabelFriendlyTitle == CreateFriendlyLabelTitle(title)
                         select p;

                if (labels.Count() > 0)
                {
                    throw new ArgumentException("The friendly name of that label is already taken, it is recommended that you completely change the label title");
                }

                Label label = new Label();
                label.BlogId = blogId;
                label.LabelTitle = title;
                label.LabelFriendlyTitle = CreateFriendlyLabelTitle(title);
                db.Labels.InsertOnSubmit(label);
                db.SubmitChanges();

                return label.LabelId;
            }
        }

        /// <summary>
        /// Updates a label
        /// </summary>
        /// <param name="labelId">ID of the label to update</param>
        /// <param name="title">New title of the label</param>
        public void UpdateLabel(Int32 labelId, String title)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                Label label = null;

                try
                {
                    label = db.Labels.Single(p => p.LabelId == labelId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("Invalid label.", ex);
                    }
                }

                if (label.LabelTitle == title)
                {
                    return;
                }

                Label label2 = null;

                try
                {
                    label2 = db.Labels.Single(p => p.BlogId == label.BlogId && p.LabelFriendlyTitle == CreateFriendlyLabelTitle(title));
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        label.LabelTitle = title;
                        label.LabelFriendlyTitle = CreateFriendlyLabelTitle(title);

                        db.SubmitChanges();
                        return;
                    }
                }

                throw new ArgumentOutOfRangeException("The friendly name of that label is already taken, it is recommended that you completely change the label title");
            }
        }

        /// <summary>
        /// Associates a label with a blog entry
        /// </summary>
        /// <param name="labelId">ID of the label</param>
        /// <param name="blogEntryId">ID of the blog entry</param>
        public void ApplyLabel(Int32 labelId, Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                BlogEntry blogEntry = null;

                try
                {
                    blogEntry = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("Invalid blog entry ID.", ex);
                    }
                }

                var labels = from p in db.Labels
                             where p.BlogId == blogEntry.BlogId && p.LabelId == labelId
                             select p;

                if (labels.Count() < 1)
                {
                    throw new ArgumentException("The given label ID and blog entry ID are not in the same blog.");
                }

                var lbec = from p in db.LabelBlogEntries
                           where p.BlogEntryId == blogEntryId && p.LabelId == labelId
                           select p;

                if (lbec.Count() < 1)
                {
                    LabelBlogEntry lbe = new LabelBlogEntry();
                    lbe.BlogEntryId = blogEntryId;
                    lbe.LabelId = labelId;
                    db.LabelBlogEntries.InsertOnSubmit(lbe);
                    db.SubmitChanges();
                }
            }
        }

        /// <summary>
        /// Disassociates a label from a blog entry, it does NOT delete the label
        /// </summary>
        /// <param name="labelId">ID of the label</param>
        /// <param name="blogEntryId">ID of the blog entry</param>
        public void RemoveLabel(Int32 labelId, Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                LabelBlogEntry lbe = null;

                try
                {
                    lbe = db.LabelBlogEntries.Single(p => p.LabelId == labelId && p.BlogEntryId == blogEntryId);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        throw new ArgumentOutOfRangeException("That blog entry is not assigned that label.", ex);
                    }
                }

                var lb = from p in db.LabelBlogEntries
                         where p.LabelId == labelId && p.BlogEntryId == blogEntryId
                         select p;

                if (lb.Count() > 0)
                {
                    db.LabelBlogEntries.DeleteAllOnSubmit<LabelBlogEntry>(lb);
                    db.SubmitChanges();
                }
            }
        }

        /// <summary>
        /// Deletes a label
        /// </summary>
        /// <param name="labelId">ID of the label</param>
        /// <param name="blogEntryId">ID of the blog entry</param>
        public void DeleteLabel(Int32 labelId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var lb = from p in db.LabelBlogEntries
                         where p.LabelId == labelId
                         select p;

                foreach (LabelBlogEntry lbe in lb)
                {
                    db.LabelBlogEntries.DeleteOnSubmit(lbe);
                    db.SubmitChanges();
                }

                var l = db.Labels.Single(p => p.LabelId == labelId);
                db.Labels.DeleteOnSubmit(l);
                db.SubmitChanges();
            }
        }



        public Int32 GetBlogEntryLabelCount(Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                return GetBlogEntryLabels(blogEntryId, db).Count<Label>();
            }
        }

        public List<Label> GetBlogEntryLabels(Int32 blogEntryId, MinimaLINQDataContext db)
        {
            var labels = (from be in db.BlogEntries
                          join lbe in db.LabelBlogEntries on be.BlogEntryId equals lbe.BlogEntryId
                          join l in db.Labels on lbe.LabelId equals l.LabelId
                          where be.BlogEntryId == blogEntryId
                          orderby l.LabelTitle ascending
                          select l).ToList();

            return labels;
        }

        /// <summary>
        /// <remarks>This is to be used when Label[] doesn't have enough
        /// information.  NOT for services.</remarks>
        /// </summary>
        public List<Label> GetBlogLabels(Int32 blogId, MinimaLINQDataContext db)
        {
            var labels = (from l in db.Labels
                          where l.BlogId == blogId
                          orderby l.LabelTitle ascending
                          select l).ToList();

            return labels;
        }


        public void ApplyLabelByLabelName(String labelTitle, Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var l = db.Labels.Single(p => p.LabelTitle == labelTitle);
                ApplyLabel(l.LabelId, blogEntryId);
            }
        }

        internal void RemoveAllLabelsFromBlogEntry(Int32 blogEntryId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var be = db.BlogEntries.Single(p => p.BlogEntryId == blogEntryId);

                foreach (LabelBlogEntry lbe in be.LabelBlogEntries)
                {
                    db.LabelBlogEntries.DeleteOnSubmit(lbe);
                }
                db.SubmitChanges();
            }
        }

        #endregion

        #region Comment

        /// <summary>
        /// Post a new comment to a blog entry
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry</param>
        /// <param name="text">Text of the comment</param>
        /// <param name="author">Author name</param>
        /// <param name="email">E-mail address of the author</param>
        /// <param name="dateTime">Date and time the comment was posted</param>
        /// <returns>ID of the comment created</returns>
        public Guid PostNewComment(Int32 blogEntryId, String text, String author, String email, String website, DateTime dateTime)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                if (db.BlogEntries.Count(p => p.BlogEntryId == blogEntryId) > 0)
                {
                    Comment c = new Comment();
                    c.CommentEmail = email;
                    c.CommentAuthor = author;
                    c.CommentText = text;
                    c.CommentWebsite = website;
                    c.CommentPostDate = dateTime;
                    c.CommentModerated = true;
                    c.BlogEntryId = blogEntryId;

                    db.Comments.InsertOnSubmit(c);
                    db.SubmitChanges();

                    return new Guid(c.CommentGuid);
                }
                else
                {
                    throw new ArgumentOutOfRangeException("Invalid blog entry ID.");
                }
            }
        }

        /// <summary>
        /// Returns all comments associated with a specific blog entry
        /// </summary>
        /// <param name="blogEntryId">ID of the blog entry</param>
        /// <param name="showAllComments">If true, moderated and unmoderated comments are returned.  Otherwise, only non-moderated comments are returned.</param>
        /// <returns></returns>
        public List<Comment> GetComments(Int32 blogEntryId, Boolean showAllComments, MinimaLINQDataContext db)
        {
            List<Comment> comments = null;
            if (showAllComments)
            {
                comments = (from p in db.Comments
                            where p.BlogEntryId == blogEntryId
                            select p).ToList();
            }
            else
            {
                comments = (from p in db.Comments
                            where p.BlogEntryId == blogEntryId && p.CommentModerated == false
                            select p).ToList();
            }

            return comments;
        }

        /// <summary>
        /// Deletes a comment from a blog entry
        /// </summary>
        /// <param name="commentId">ID of the comment to delete</param>
        public void DeleteComment(Int32 commentId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                var label = db.Comments.Single(p => p.CommentId == commentId);
                db.Comments.DeleteOnSubmit(label);
                db.SubmitChanges();
            }
        }

        /// <summary>
        /// Unmoderates a comment by GUID
        /// </summary>
        /// <param name="commentId">true is successful, false is not successful</param>
        public Boolean AuthorizeComment(String commentGuid)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                Comment comment = null;

                try
                {
                    comment = db.Comments.Single(p => p.CommentGuid == commentGuid);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message == "Sequence contains no elements")
                    {
                        return false;
                    }
                }

                comment.CommentModerated = false;
                db.SubmitChanges();
                return true;
            }
        }

        #endregion

        #region Private

        private String CreateFriendlyLabelTitle(String title)
        {
            return CreateBlogEntryPostUrlMapping(title);
        }

        private String CreateBlogEntryPostUrlMapping(String title)
        {
            return title.Replace(" - ", "-").Replace("/", "").Replace("{", "").Replace("}", "").Replace(".", "").Replace("'", "").Replace("\"", "").Replace("(", "").Replace(")", "").Replace("#", "").Replace("!", "").Replace(":", "").Replace(" ", "-").Replace("?", "").Replace(",", "");
        }

        #endregion

        #region Security

        /// <summary>
        /// Check rights against UserRights table
        /// </summary>
        /// <param name="blogId">ID of the blog, 0 if it's a system-level right</param>
        /// <param name="emailAddress">E-Mail address of the user</param>
        /// <param name="password">Password for the user</param>
        /// <param name="accessRequired">Access to be checked; options are C, R, U, or D.</param>
        /// <returns></returns>
        internal Boolean CheckBlogRights(Int32 blogId, String emailAddress, String password, Char accessRequired)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                Author author = GetAuthorByEmailAddress(emailAddress, db);

                if (author == null || author.AuthorPassword != password)
                {
                    return false;
                }

                // 0 means system-level, non-0 means blog-level
                if (blogId == 0)
                {
                    var a = from ur in author.UserRights
                            where ur.UserRightLevel == 'S' && ur.UserRightType == accessRequired
                            select ur;
                    return a.Count() > 0;
                }
                else
                {
                    return (from ur in author.UserRights
                            where ur.UserRightLevel == 'B' && ur.BlogId == blogId && ur.UserRightType == accessRequired
                            select ur).Count() > 0;
                }
            }
        }

        /// <summary>
        /// Get all rights for a blog 
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <returns>List of UserRight objects</returns>
        /// <remarks>This is not meant to secure the blog from direct acces, but to assist in external API access.</remarks>
        internal List<UserRight> GetRights(Int32 blogId)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                return (from o in db.UserRights
                        select o).ToList();
            }
        }

        /// <summary>
        /// Create a right in the UserRight table
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="emailAddress">E-Mail address of the user</param>
        /// <param name="level">'S' for system</param>
        /// <param name="type">Access type; options are C, R, U, or D.</param>
        /// <returns>True is successful, false is unsuccessful</returns>
        /// <remarks>This is not meant to secure the blog from direct acces, but to assist in external API access.</remarks>
        internal Boolean CreateRight(Int32 blogId, String emailAddress, Char level, Char type)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                UserRight ur = new UserRight();
                ur.AuthorId = db.Authors.Single(p => p.AuthorEmail == emailAddress).AuthorId;
                ur.BlogId = blogId;
                ur.UserRightLevel = level;
                ur.UserRightType = type;

                db.UserRights.InsertOnSubmit(ur);
                db.SubmitChanges();
                return true;
            }
        }

        /// <summary>
        /// Revoke a right from the UserRight table
        /// </summary>
        /// <param name="blogId">ID of the blog</param>
        /// <param name="emailAddress">E-Mail address of the user</param>
        /// <param name="level">'S' for system</param>
        /// <param name="type">Access type; options are C, R, U, or D.</param>
        /// <returns>True is successful, false is unsuccessful</returns>
        /// <remarks>This is not meant to secure the blog from direct acces, but to assist in external API access.</remarks>
        internal Boolean RevokeRight(Int32 blogId, String emailAddress, Char level, Char type)
        {
            using (MinimaLINQDataContext db = new MinimaLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
            {
                Int32 authorId = db.Authors.Single(p => p.AuthorEmail == emailAddress).AuthorId;
                var ur = db.UserRights.Single(p => p.AuthorId == authorId && p.BlogId == blogId && p.UserRightLevel == level && p.UserRightType == type);

                db.UserRights.DeleteOnSubmit(ur);
                db.SubmitChanges();
                return true;
            }
        }

        #endregion
    }
}