TourIAm/TIAM.Services.Server/MessageSenderService.cs

using System.Net;
using System.Net.Mail;
using AyCode.Core.Helpers;
using AyCode.Models.Enums;
using Microsoft.Extensions.Configuration;
using SendGrid;
using SendGrid.Helpers.Mail;
using TIAM.Core.Consts;
using TIAM.Database.DataLayers.Admins;
using TIAM.Entities.Emails;
using TIAM.Entities.Users;

namespace TIAM.Services.Server
{
    public class MessageSenderService(IConfiguration configuration, AdminDal adminDal) : IMessageSenderService
    {
        private readonly string smtpHost = "smtp.rackhost.hu";
        private readonly int smtpPort = 587; // Change if needed
        private readonly string smtpUser = "system@touriam.com";
        private readonly string smtpPass = "Villany1";

        public async Task<string> SendMessageAsync(EmailMessage message, int messageType)
        {
            var result = "";
            switch (messageType)
            {
                case (int)MessageTypesEnum.email:
                    Console.WriteLine($@"EmailMessage!!!");
                    // Access DerivedClass properties
                    //var subject = emailMessage.Subject;

                    //adminDal.AddEmailMessageAsync(message).Forget();
                    //result = (await SendMailWithSendgrid(message)).ToString(); //?? HttpStatusCode.BadRequest.ToString();
                    result = (await SendMailWithSmtp(message)).ToString(); //?? HttpStatusCode.BadRequest.ToString();
                    break;
                case (int)MessageTypesEnum.sms:
                    //await SendSmsWithTwilio(message.Message);
                    break;
                case (int)MessageTypesEnum.push:
                    //await SendPushWithFirebase(message.Message);
                    break;
                case (int)MessageTypesEnum.chat:
                //await SendChatWithSignalR(message.Message);
                default:

                    break;
            }

            return result;
        }

        public async Task<HttpStatusCode> SendMailWithSendgrid(EmailMessage message)
        {
            Console.WriteLine($@"Sender: {message.SenderId}");
            Console.WriteLine($@"Message: {message.Text}");
            //resolve user!!!

            User senderUser;

            var apiKey = configuration["SendGrid:Key"];
            var client = new SendGridClient(apiKey);
            EmailAddress from;
            if (!message.SenderId.HasValue || message.SenderId == TiamConstClient.SysAccounts["SystemEmailSender"])
            {
                //SYSTEM MAIL
                message.SenderId = TiamConstClient.SysAccounts.FirstOrDefault(x => x.Key == "SystemEmailSender").Value;
                senderUser = null; //TODO get user from DB soon
            }
            else
            {
                //USER sent message
                senderUser = adminDal.GetUserById(message.SenderId.Value);
            }


            if (senderUser == null)
            {

                if (message.SenderId == Guid.Empty || TiamConstClient.SysAccounts.Any(x => x.Value == message.SenderId))
                {
                    //System message
                    message.EmailAddress = TiamConstClient.SystemEmailAddress;
                    from = new EmailAddress(TiamConstClient.SystemEmailAddress, "TourIAm mailservice");
                }
                else
                {
                    //user not valid, don't send message
                    return HttpStatusCode.BadRequest;
                }
            }
            else
            {
                from = new EmailAddress(TiamConstClient.SystemEmailAddress, senderUser.Profile.Name);
            }

            Response[] responses = [];

            try
            {
                List<Task<Response>> sendTasks = new List<Task<Response>>();
                foreach (var messageRecipient in message.Recipients)
                {
                    var to = new EmailAddress(messageRecipient.EmailAddress, messageRecipient.EmailAddress);

                    Console.WriteLine($"Message recipient: {messageRecipient.EmailAddress}");
                    var plainTextContent = message.Text;

                    //MailHelper.CreateSingleEmailToMultipleRecipients()
                    var msg = MailHelper.CreateSingleEmail(from, to, message.Subject, plainTextContent, plainTextContent);
                    //msg.AddBccs()
                    sendTasks.Add(client.SendEmailAsync(msg));
                }

                responses = await Task.WhenAll(sendTasks).ConfigureAwait(false);

                foreach (var response in responses)
                {
                    Console.WriteLine($"{response.StatusCode}, {response.Body.ReadAsStringAsync()}");
                }
                //message.Id = Guid.NewGuid();
                //adminDal.AddEmailMessageAsync(message).Forget();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            if (responses.Any(response => !response.IsSuccessStatusCode))
            {
                Console.WriteLine("Some emails failed to send");
                return HttpStatusCode.InternalServerError;
            }

            Console.WriteLine("All emails sent successfully");
            return HttpStatusCode.OK;




            //List<bool> results = new List<bool>();
            //foreach (var messageRecipient in message.Recipients)
            //{
            //    var to = new EmailAddress(messageRecipient.EmailAddress, messageRecipient.EmailAddress);
            //    var plainTextContent = message.Text;
            //    //var _htmlContent = message.;

            //    //MailHelper.CreateSingleEmailToMultipleRecipients()
            //    var msg = MailHelper.CreateSingleEmail(from, to, message.Subject, plainTextContent, plainTextContent);
            //    var response = await client.SendEmailAsync(msg).ConfigureAwait(false);
            //    if(response.IsSuccessStatusCode)
            //    {
            //        results.Add(true);                   
            //    }
            //    else { results.Add(false); }
            //}

            //if(results.Any(x => x=false))
            //{
            //    return HttpStatusCode.BadRequest;                
            //}
            //else
            //{
            //    return HttpStatusCode.OK;
            //}
            ////return response.StatusCode;

        }


        //public async Task<HttpStatusCode> SendMailWithSmtp(EmailMessage message)
        //{
        //    Console.WriteLine($"Sender: {message.SenderId}");
        //    Console.WriteLine($"Message: {message.Text}");

        //    if (message.Recipients == null || !message.Recipients.Any())
        //    {
        //        return HttpStatusCode.BadRequest;
        //    }

        //    using (var smtpClient = new SmtpClient(smtpHost, smtpPort))
        //    {
        //        smtpClient.Credentials = new NetworkCredential(smtpUser, smtpPass);
        //        smtpClient.EnableSsl = true;

        //        var fromAddress = new MailAddress(smtpUser, "Your Mail Service");

        //        List<Task> sendTasks = new List<Task>();

        //        foreach (var recipient in message.Recipients)
        //        {
        //            var toAddress = new MailAddress(recipient.EmailAddress);
        //            var mailMessage = new MailMessage(fromAddress, toAddress)
        //            {
        //                Subject = message.Subject,
        //                Body = message.Text,
        //                IsBodyHtml = true
        //            };

        //            //sendTasks.Add(Task.Run(() => smtpClient.SendMailAsync(mailMessage)));
        //            sendTasks.Add(smtpClient.SendMailAsync(mailMessage));
        //        }

        //        try
        //        {
        //            await Task.WhenAll(sendTasks);
        //            Console.WriteLine("All emails sent successfully");
        //            return HttpStatusCode.OK;
        //        }
        //        catch (Exception ex)
        //        {
        //            Console.WriteLine($"Failed to send emails: {ex.Message}");
        //            return HttpStatusCode.InternalServerError;
        //        }
        //    }
        //}

        //public async Task<HttpStatusCode> SendMailWithSmtp(EmailMessage message)
        //{
        //    Console.WriteLine($"Sender: {message.SenderId}");
        //    Console.WriteLine($"Message: {message.Text}");

        //    if (message.Recipients == null || !message.Recipients.Any())
        //    {
        //        return HttpStatusCode.BadRequest;
        //    }

        //    List<Task> sendTasks = new List<Task>();

        //    foreach (var recipient in message.Recipients)
        //    {
        //        var smtpClient = new SmtpClient(smtpHost, smtpPort)
        //        {
        //            Credentials = new NetworkCredential(smtpUser, smtpPass),
        //            EnableSsl = true,                    
        //            TargetName = $"SMTPS/{smtpHost}"
        //        };

        //        var fromAddress = new MailAddress(smtpUser, "Your Mail Service");
        //        var toAddress = new MailAddress(recipient.EmailAddress);
        //        var mailMessage = new MailMessage(fromAddress, toAddress)
        //        {
        //            Subject = message.Subject,
        //            Body = message.Text,
        //            IsBodyHtml = true
        //        };

        //        sendTasks.Add(Task.Run(async () =>
        //        {
        //            try
        //            {
        //                await smtpClient.SendMailAsync(mailMessage);
        //            }
        //            catch (Exception ex)
        //            {
        //                Console.WriteLine($"Failed to send email to {recipient.EmailAddress}: {ex.Message}");
        //                throw; // Ensure exceptions bubble up
        //            }
        //            finally
        //            {
        //                smtpClient.Dispose();
        //            }
        //        }));
        //    }

        //    var timeoutTask = Task.Delay(TimeSpan.FromSeconds(30)); // Prevent indefinite waiting
        //    var allTasks = Task.WhenAll(sendTasks);
        //    var completedTask = await Task.WhenAny(allTasks, timeoutTask);

        //    if (completedTask == timeoutTask)
        //    {
        //        Console.WriteLine("Email sending timed out.");
        //        return HttpStatusCode.RequestTimeout;
        //    }

        //    try
        //    {
        //        await allTasks; // Rethrow if there were failures
        //        Console.WriteLine("All emails sent successfully");
        //        return HttpStatusCode.OK;
        //    }
        //    catch (Exception)
        //    {
        //        Console.WriteLine("Some emails failed to send");
        //        return HttpStatusCode.InternalServerError;
        //    }
        //}

        public async Task<HttpStatusCode> SendMailWithSmtp(EmailMessage message)
        {
            Console.WriteLine($"Sender: {message.SenderId}");
            Console.WriteLine($"Message: {message.Text}");

            if (message.Recipients == null || !message.Recipients.Any())
            {
                return HttpStatusCode.BadRequest;
            }

            List<Task> sendTasks = new List<Task>();

            foreach (var recipient in message.Recipients)
            {
                sendTasks.Add(Task.Run(async () =>
                {
                    try
                    {
                        using (var smtpClient = new SmtpClient(smtpHost, smtpPort))
                        {
                            smtpClient.Credentials = new NetworkCredential(smtpUser, smtpPass);
                            smtpClient.EnableSsl = true; // Try false for port 587
                            smtpClient.TargetName = $"SMTPS/{smtpHost}";

                            var fromAddress = new MailAddress(smtpUser, "Your Mail Service");
                            var toAddress = new MailAddress(recipient.EmailAddress);
                            var mailMessage = new MailMessage(fromAddress, toAddress)
                            {
                                Subject = message.Subject,
                                Body = message.Text,
                                IsBodyHtml = true
                            };

                            await smtpClient.SendMailAsync(mailMessage);
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Failed to send email to {recipient.EmailAddress}: {ex.Message}");
                        if (ex.InnerException != null)
                        {
                            Console.WriteLine($"Inner Exception: {ex.InnerException.Message}");
                        }
                        throw;
                    }
                }));
            }

            var timeoutTask = Task.Delay(TimeSpan.FromSeconds(30)); // Prevent indefinite waiting
            var allTasks = Task.WhenAll(sendTasks);
            var completedTask = await Task.WhenAny(allTasks, timeoutTask);

            if (completedTask == timeoutTask)
            {
                Console.WriteLine("Email sending timed out.");
                return HttpStatusCode.RequestTimeout;
            }

            try
            {
                await allTasks; // Rethrow if there were failures
                Console.WriteLine("All emails sent successfully");
                return HttpStatusCode.OK;
            }
            catch (Exception)
            {
                Console.WriteLine("Some emails failed to send");
                return HttpStatusCode.InternalServerError;
            }
        }


        public string GenerateWelcomeEmail(string userName, string activationCode)
        {
            string template = EmailTemplateHelper.GetTemplate(TiamConstClient.WelcomeEmailTemplateName);

            var placeholders = new Dictionary<string, string>
            {
                { "UserName", userName },
                { "ActivationCode", activationCode }
            };

            return EmailTemplateHelper.ReplacePlaceholders(template, placeholders);
        }

        

    }
}