using System;
using System.Linq;
using MailKit;
using MimeKit;
using Wino.Core.Domain;
using Wino.Core.Domain.Entities.Mail;
using Wino.Core.Domain.Enums;

namespace Wino.Services.Extensions
{
    public static class MailkitClientExtensions
    {
        public static char MailCopyUidSeparator = '_';

        public static uint ResolveUid(string mailCopyId)
        {
            var splitted = mailCopyId.Split(MailCopyUidSeparator);

            if (splitted.Length > 1 && uint.TryParse(splitted[1], out uint parsedUint)) return parsedUint;

            throw new ArgumentOutOfRangeException(nameof(mailCopyId), mailCopyId, "Invalid mailCopyId format.");
        }

        public static UniqueId ResolveUidStruct(string mailCopyId)
            => new UniqueId(ResolveUid(mailCopyId));

        public static string CreateUid(Guid folderId, uint messageUid)
            => $"{folderId}{MailCopyUidSeparator}{messageUid}";

        public static MailImportance GetImportance(this MimeMessage messageSummary)
        {
            if (messageSummary.Headers != null && messageSummary.Headers.Contains(HeaderId.Importance))
            {
                var rawImportance = messageSummary.Headers[HeaderId.Importance];

                return rawImportance switch
                {
                    "Low" => MailImportance.Low,
                    "High" => MailImportance.High,
                    _ => MailImportance.Normal,
                };
            }

            return MailImportance.Normal;
        }

        public static bool GetIsRead(this MessageFlags? flags)
            => flags.GetValueOrDefault().HasFlag(MessageFlags.Seen);

        public static bool GetIsFlagged(this MessageFlags? flags)
            => flags.GetValueOrDefault().HasFlag(MessageFlags.Flagged);

        public static string GetThreadId(this IMessageSummary messageSummary)
        {
            // First check whether we have the default values.

            if (!string.IsNullOrEmpty(messageSummary.ThreadId))
                return messageSummary.ThreadId;

            if (messageSummary.GMailThreadId != null)
                return messageSummary.GMailThreadId.ToString();

            return default;
        }

        public static string GetMessageId(this MimeMessage mimeMessage)
            => mimeMessage.MessageId;

        public static string GetReferences(this MessageIdList messageIdList)
            => string.Join(";", messageIdList);

        public static string GetInReplyTo(this MimeMessage mimeMessage)
        {
            if (mimeMessage.Headers.Contains(HeaderId.InReplyTo))
            {
                // Normalize if <> brackets are there.
                var inReplyTo = mimeMessage.Headers[HeaderId.InReplyTo];

                if (inReplyTo.StartsWith("<") && inReplyTo.EndsWith(">"))
                    return inReplyTo.Substring(1, inReplyTo.Length - 2);

                return inReplyTo;
            }

            return string.Empty;
        }

        private static string GetPreviewText(this MimeMessage message)
        {
            if (string.IsNullOrEmpty(message.HtmlBody))
                return message.TextBody;
            else
                return HtmlAgilityPackExtensions.GetPreviewText(message.HtmlBody);
        }

        public static MailCopy GetMailDetails(this IMessageSummary messageSummary, MailItemFolder folder, MimeMessage mime)
        {
            // MessageSummary will only have UniqueId, Flags, ThreadId.
            // Other properties are extracted directly from the MimeMessage.

            // IMAP doesn't have unique id for mails.
            // All mails are mapped to specific folders with incremental Id.
            // Uid 1 may belong to different messages in different folders, but can never be
            // same for different messages in same folders.
            // Here we create arbitrary Id that maps the Id of the message with Folder UniqueId.
            // When folder becomes invalid, we'll clear out these MailCopies as well.

            var messageUid = CreateUid(folder.Id, messageSummary.UniqueId.Id);
            var previewText = mime.GetPreviewText();

            var copy = new MailCopy()
            {
                Id = messageUid,
                CreationDate = mime.Date.UtcDateTime,
                ThreadId = messageSummary.GetThreadId(),
                MessageId = mime.GetMessageId(),
                Subject = mime.Subject,
                IsRead = messageSummary.Flags.GetIsRead(),
                IsFlagged = messageSummary.Flags.GetIsFlagged(),
                PreviewText = previewText,
                FromAddress = GetActualSenderAddress(mime),
                FromName = GetActualSenderName(mime),
                IsFocused = false,
                Importance = mime.GetImportance(),
                References = mime.References?.GetReferences(),
                InReplyTo = mime.GetInReplyTo(),
                HasAttachments = mime.Attachments.Any(),
                FileId = Guid.NewGuid()
            };

            return copy;
        }

        // TODO: Name and Address parsing should be handled better.
        // At some point Wino needs better contact management.

        public static string GetActualSenderName(MimeMessage message)
        {
            if (message == null)
                return string.Empty;

            return message.From.Mailboxes.FirstOrDefault()?.Name ?? message.Sender?.Name ?? Translator.UnknownSender;

            // From MimeKit

            // The "From" header specifies the author(s) of the message.
            // If more than one MimeKit.MailboxAddress is added to the list of "From" addresses,
            // the MimeKit.MimeMessage.Sender should be set to the single MimeKit.MailboxAddress
            // of the personal actually sending the message.

            // Also handle: https://stackoverflow.com/questions/46474030/mailkit-from-address

            //if (message.Sender != null)
            //    return string.IsNullOrEmpty(message.Sender.Name) ? message.Sender.Address : message.Sender.Name;
            //else if (message.From?.Mailboxes != null)
            //{
            //    var firstAvailableName = message.From.Mailboxes.FirstOrDefault(a => !string.IsNullOrEmpty(a.Name))?.Name;

            //    if (string.IsNullOrEmpty(firstAvailableName))
            //    {
            //        var firstAvailableAddress = message.From.Mailboxes.FirstOrDefault(a => !string.IsNullOrEmpty(a.Address))?.Address;

            //        if (!string.IsNullOrEmpty(firstAvailableAddress))
            //        {
            //            return firstAvailableAddress;
            //        }
            //    }

            //    return firstAvailableName;
            //}

            //// No sender, no from, I don't know what to do.
            //return Translator.UnknownSender;
        }

        // TODO: This is wrong.
        public static string GetActualSenderAddress(MimeMessage message)
        {
            return message.From.Mailboxes.FirstOrDefault()?.Address ?? message.Sender?.Address ?? Translator.UnknownSender;
            //if (mime == null)
            //    return string.Empty;

            //bool hasSingleFromMailbox = mime.From.Mailboxes.Count() == 1;

            //if (hasSingleFromMailbox)
            //    return mime.From.Mailboxes.First().GetAddress(idnEncode: true);
            //else if (mime.Sender != null)
            //    return mime.Sender.GetAddress(idnEncode: true);
            //else
            //    return Translator.UnknownSender;
        }
    }
}