using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Neo.Afx.ComponentModel;
using Neo.Afx.Services.Correspondence.Entities;

namespace Neo.Afx.Services.Correspondence
{
    /// <summary>
    /// Correspondence database context container
    /// </summary>
    public class CorrespondenceDatabase : Database<CorrespondenceContext>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CorrespondenceDatabase"/> class.
        /// </summary>
        public CorrespondenceDatabase()
            : base(new CorrespondenceContext())
        {
        }

        #region UserName
        /// <summary>
        /// Gets the name of the user.
        /// </summary>
        /// <value>
        /// The name of the user.
        /// </value>
        public string UserName
        {
            get
            {
                if (HttpContext.Current.User != null && HttpContext.Current.User.Identity.IsAuthenticated)
                {
                    return HttpContext.Current.User.Identity.Name.ToLower();
                }

                return "";
            }
        }
        #endregion

        #region Create
        /// <summary>
        /// Creates the specified entity ID.
        /// </summary>
        /// <param name="entityID">The entity ID.</param>
        /// <param name="itemID">The item ID.</param>
        /// <param name="messageTypeID">The message type ID.</param>
        /// <param name="recipients">The recipients.</param>
        /// <param name="cc">The cc.</param>
        /// <param name="bcc">The BCC.</param>
        /// <param name="subject">The subject.</param>
        /// <param name="message">The message.</param>
        /// <param name="isHtml"><code>true</code> if Is HTML; <code>false</code> otherwise.</param>
        /// <returns></returns>
        public KeyValuePair<long, string> Create(int entityID, long itemID, byte messageTypeID, string recipients, string cc, string bcc, string subject, string message, bool isHtml)
        {
            KeyValuePair<long, string> returnResult;

            try
            {
                var result = Context.Pr_MessageCreate(entityID, itemID, messageTypeID, recipients, cc, bcc, subject, message, isHtml, UserName).SingleOrDefault();

                returnResult = result.HasValue ? new KeyValuePair<long, string>(result.Value, (result.Value != -1) ? String.Empty : "Unknown error occured") : new KeyValuePair<long, string>(-1, "Unknown error occured");
            }
            catch (Exception ex)
            {
                returnResult = new KeyValuePair<long, string>(-1, ex.InnerException.Message);
            }

            return returnResult;
        }
        #endregion

        #region Update
        /// <summary>
        /// Updates the specified message ID.
        /// </summary>
        /// <param name="messageID">The message ID.</param>
        /// <param name="recipients">The recipients.</param>
        /// <param name="cc">The cc.</param>
        /// <param name="bcc">The BCC.</param>
        /// <param name="subject">The subject.</param>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public string Update(long messageID, string recipients, string cc, string bcc, string subject, string message)
        {
            string error;
            try
            {
                var result = Context.Pr_MessageUpdate(messageID, recipients, cc, bcc, subject, message, UserName).SingleOrDefault();

                if (result.HasValue)
                {
                    error = (result.Value) ? String.Empty : "Unknown error occured";
                }
                else
                {
                    error = "Unknown error occured";
                }
            }
            catch (Exception ex)
            {
                error = ex.InnerException.Message;
            }

            return error;
        }
        #endregion

        #region Delete
        /// <summary>
        /// Deletes the specified message ID.
        /// </summary>
        /// <param name="messageID">The message ID.</param>
        /// <returns></returns>
        public string Delete(long messageID)
        {
            string error;
            try
            {
                var result = Context.Pr_MessageDelete(messageID, UserName).SingleOrDefault();

                if (result.HasValue)
                {
                    error = (result.Value) ? String.Empty : "Unknown error occured";
                }
                else
                {
                    error = "Unknown error occured";
                }
            }
            catch (Exception ex)
            {
                error = ex.InnerException.Message;
            }

            return error;
        }
        #endregion

        #region GetMessage
        /// <summary>
        /// Gets the message.
        /// </summary>
        /// <param name="messageID">The message ID.</param>
        /// <returns></returns>
        public Message GetMessage(long messageID)
        {
            return Context.Messages.Include("MessageType").Include("UserCreatedBy").Where(a => a.MessageID == messageID && a.IsCancelled == false).FirstOrDefault();
        }
        #endregion

        #region GetMessages
        /// <summary>
        /// Gets the messages.
        /// </summary>
        /// <param name="entityID">The entity ID.</param>
        /// <param name="itemID">The item ID.</param>
        /// <returns></returns>
        public IEnumerable<Message> GetMessages(int entityID, long itemID)
        {
            //dev note: do not limit messages based on isCancelled as it'll hide any emails that could not be sent on the interface
            return from q in Context.Messages.Include("MessageType").Include("UserCreatedBy").OrderBy(a => a.CreatedDate)
                   where q.EntityID == entityID && q.ItemID == itemID
                   select q;
        }
        #endregion

        #region GetMessageTypes
        /// <summary>
        /// Gets the message types.
        /// </summary>
        /// <returns></returns>
        public IEnumerable<MessageType> GetMessageTypes()
        {
            return from q in Context.MessageTypes
                   select q;
        }
        #endregion

        #region GetMessageTemplates
        /// <summary>
        /// Gets the message templates.
        /// </summary>
        /// <param name="includeSystemTemplates"><code>true</code> if Include system templates; <code>false</code> otherwise.</param>
        /// <returns></returns>
        public IEnumerable<MessageTemplate> GetMessageTemplates(bool includeSystemTemplates)
        {
            if (includeSystemTemplates)
            {
                return from q in Context.MessageTemplates
                       where !q.IsCancelled
                       select q;
            }
            else
            {
                return from q in Context.MessageTemplates
                       where !q.IsCancelled && q.IsSystemTemplate == false
                       select q;
            }
        }
        #endregion

        #region GetMessageContent
        /// <summary>
        /// Gets the content of the message.
        /// </summary>
        /// <param name="messageID">The message ID.</param>
        /// <returns>Returns the message body content</returns>
        public string GetMessageContent(long messageID)
        {
            var msgContents = Context.Messages.Where(m => m.MessageID == messageID).ToList();
            var sent = new DateTime(1, 1, 1);
            if (msgContents[0].SentDate != null)
            {
                sent = (DateTime)msgContents[0].SentDate;
            }

            var returnMessage = ("<b>To:</b> " + msgContents[0].Recipients +
                                (msgContents[0].CC != null ? (msgContents[0].CC.Length > 0 ? "<br />" + "<b>CC:</b> " + msgContents[0].CC : "") : "")
                                + "<br /><b>Created Date:</b> " + msgContents[0].CreatedDate.ToShortDateString()
                                + (sent != new DateTime(1, 1, 1) ? "<br /><b>Sent Date:</b> " + sent.ToShortDateString() : "<br /><b>Sent Date:</b> Not Sent Yet")
                                + "<br /><br />" + msgContents[0].Content);

            return returnMessage;
        }

        public void CreateAttachment(KeyValuePair<long, string> messageid, int v1, byte[] imageData, string v2, int v3, string v4, string v5)
        {
            throw new NotImplementedException();
        }
        #endregion

        #region CreateAttachment
        /// <summary>
        /// Creates an attachment for a message
        /// </summary>
        /// <param name="messageID"></param>
        /// <param name="createdByID"></param>
        /// <param name="content"></param>
        /// <param name="mimeType"></param>
        /// <param name="size"></param>
        /// <param name="name"></param>
        /// <param name="ext"></param>
        public void CreateAttachment(long messageID, long createdByID, byte[] content, string mimeType, long size, string name, string ext)
        {
            Context.Pr_MessageCreateAttachment(messageID, createdByID, content, mimeType, size, name, ext);
        }
        #endregion

        #region GetEntityRecipient
        /// <summary>
        /// Calculate Message Recipient based on entity
        /// </summary>
        /// <param name="messageTypeID"></param>
        /// <param name="entityID"></param>
        /// <param name="itemID"></param>
        /// <param name="userID"></param>
        public string GetEntityRecipient(short messageTypeID, long entityID, long itemID, long userID)
        {
            return Context.Pr_EntityRecipientGet(messageTypeID, entityID, itemID, userID).FirstOrDefault();
        }
        #endregion
    }
}