using Application.Services.Database.MongoDB;
using Application.Services.Database.PostgreSQL;
using Application.Services.Email;
using Domain.Entities;

namespace Application.Endpoints.Chats.SendMessage;

public class SendMessageHandler(
    IChatMongoDbService chatMongoDbService,
    IPatientRepository patientRepository,
    IDoctorRepository doctorRepository,
    IEmailService emailService)
{
    public async Task<BaseResponse> Handle(SendMessageCommand request, CancellationToken token)
    {
        var validation = new SendMessageValidator(doctorRepository, patientRepository);
        var validationResult = await validation.ValidateAsync(request, token);

        if (!validationResult.IsValid)
        {
            var firstError = validationResult.Errors.FirstOrDefault();
            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
            var errorMessage = firstError.ErrorMessage;

            return new BaseResponse
            {
                StatusCode = errorCode,
                Message = errorMessage,
                Data = null
            };
        }

        var chatId = IdentifierGenerator.GenerateId(request.Sender, request.Receiver);

        var criteria = new List<(string, string)>();
        criteria.Add(("_id", chatId));

        var documents = await chatMongoDbService.FindAsync<Chat>(criteria, token);
        if (documents.Count == 0)
            return new BaseResponse
            {
                StatusCode = HttpStatusCodes.NotFound,
                Message = "Access to medical history not found.",
                Data = null
            };

        var chat = documents[0].Messages;
        chat.Add(new Message(request.Sender, request.Message));

        var newChat = new Chat();
        newChat.SetId(chatId);
        newChat.SetMessages(chat);

        await chatMongoDbService.ModifyAsync("_id", chatId, newChat, token);

        var chatUrl = "";
        var userDetails = await GetSenderAndReceiverNames(request.Sender, request.Receiver, token);
        var emailBody =
            emailService.GenerateMessageNotificationEmail(userDetails.SenderName, userDetails.ReceiverName, chatUrl);
        await emailService.SendEmailAsync(userDetails.ReceiverEmail, emailService.GetMessageNotificationSubject(),
            emailBody);

        return new BaseResponse
        {
            StatusCode = HttpStatusCodes.NoContent,
            Message = null,
            Data = null
        };
    }

    private async Task<(string SenderName, string ReceiverName, string ReceiverEmail)> GetSenderAndReceiverNames(
        Guid senderId, Guid receiverId, CancellationToken token)
    {
        var senderName = "Sender"; // Default if not found
        var receiverName = "Receiver"; // Default if not found
        var receiverEmail = "receiver@example.com";

        // Assuming the sender could be a doctor or patient
        var senderPatient = await patientRepository.GetByIdAsync(senderId, token);
        var senderDoctor = await doctorRepository.GetByIdAsync(senderId, token);
        senderName = senderPatient?.Name ?? "Dr. " + senderDoctor?.Name ?? senderName;

        // Assuming the receiver could be a doctor or patient
        var receiverPatient = await patientRepository.GetByIdAsync(receiverId, token);
        var receiverDoctor = await doctorRepository.GetByIdAsync(receiverId, token);
        receiverName = receiverPatient?.Name ?? "Dr. " + receiverDoctor?.Name ?? receiverName;
        receiverEmail = receiverPatient?.Email ?? receiverDoctor?.Email ?? receiverEmail;

        return (senderName, receiverName, receiverEmail);
    }
}