package net.gepafin.tendermanagement.dao;

import com.amazonaws.services.s3.AmazonS3Client;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.*;
import net.gepafin.tendermanagement.enums.*;
import net.gepafin.tendermanagement.model.request.ApplicationAmendmentRequest;
import net.gepafin.tendermanagement.model.request.AttachmentRequest;
import net.gepafin.tendermanagement.model.request.EmailConfig;
import net.gepafin.tendermanagement.model.request.EmailLogRequest;
import net.gepafin.tendermanagement.model.response.AmendmentFormFieldResponse;
import net.gepafin.tendermanagement.model.response.EmailContentResponse;
import net.gepafin.tendermanagement.model.response.SystemEmailTemplateResponse;
import net.gepafin.tendermanagement.repositories.*;
import net.gepafin.tendermanagement.service.*;
import net.gepafin.tendermanagement.service.impl.EmailService;
import net.gepafin.tendermanagement.service.impl.EmailServiceFactory;
import net.gepafin.tendermanagement.util.DateTimeUtil;
import net.gepafin.tendermanagement.service.impl.SystemEmailService;
import net.gepafin.tendermanagement.util.S3DocxProcessor;
import net.gepafin.tendermanagement.util.Utils;
import net.gepafin.tendermanagement.util.Validator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static net.gepafin.tendermanagement.dao.ApplicationAmendmentRequestDao.filterByName;

@Component
public class EmailNotificationDao {

    private static final Logger log = LoggerFactory.getLogger(EmailNotificationDao.class);

    @Autowired
    private SystemEmailTemplatesService systemEmailTemplatesService;

    @Autowired
    private ApplicationService applicationService;

    @Autowired
    private UserService userService;

    @Autowired
    private HubService hubService;

    @Autowired
    EmailServiceFactory emailServiceFactory;

    @Autowired
    HubRepository hubRepository;

    @Autowired
    private EmailLogDao emailLogDao;

    @Autowired
    private EmailLogRepository emailLogRepository;

    @Autowired
    private CompanyService companyService;

    @Autowired
    private ApplicationFormRepository applicationFormRepository;

    @Autowired
    private ApplicationEvaluationRepository applicationEvaluationRepository;

    @Value("${default.hub.uuid}")
    private String defaultHubUuid;

    @Value("${rinaldo_email}")
    private String rinaldoEmail;

    @Autowired
    private SystemEmailTemplatesDao systemEmailTemplatesDao;

    @Autowired
    private Validator validator;

    @Autowired
    private AmazonS3Client s3Client;

    @Autowired
    private DocumentRepository documentRepository;

    @Autowired
    private ApplicationAmendmentRequestDao applicationAmendmentRequestDao;

    @Autowired
    private ApplicationDao applicationDao;

    public void sendEmail(ApplicationEntity applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum templateType, Map<String, String> bodyPlaceholders,
            List<String> additionalRecipients, Long amendmentId,String emailType) {

        HubEntity hubEntity = hubService.valdateHub(applicationEntity.getHubId());
//        String service = determineService(applicationEntity.getHubId());
//        String legalMail = service.equals("Gepafin S.p.a.") ? "bandi.gepafin@legalmail.it" : "bandi.sviluppumbria@legalmail.it";

        EmailContentResponse emailContent = prepareEmailContent(applicationEntity, templateType, hubEntity, bodyPlaceholders,emailType);
        UserEntity userEntity = userService.validateUser(applicationEntity.getUserId());
        sendEmails(applicationEntity, userEntity, additionalRecipients,amendmentId,emailContent.getSystemEmailTemplateResponse(),emailContent.getSubject(),emailContent.getBody());
    }

    public EmailContentResponse prepareEmailContent(
            ApplicationEntity applicationEntity,
            SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum templateType,
            HubEntity hubEntity,
            Map<String, String> bodyPlaceholders,String emailType
    ) {
        SystemEmailTemplateResponse systemEmailTemplateResponse = systemEmailTemplatesService.retrieveTemplateByTypeAndCall(templateType, hubEntity, null);
        if(Boolean.TRUE.equals(templateType.equals(SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.DOCUMENTATION_INTEGRATION_REQUEST)) && Boolean.TRUE.equals(validator.isProductionProfileActivated()) && applicationEntity.getCall().getId().equals(23l)) {
        systemEmailTemplateResponse.setHtmlContent(systemEmailTemplatesDao.replaceEmailSignature(hubEntity,GepafinConstant.APPLICATION_AMENDMENT_REQUESTED_MAIL_BODY,null));
        }
            Map<String, String> subjectPlaceholders = new HashMap<>();
        CompanyEntity company = companyService.validateCompany(applicationEntity.getCompanyId());
        subjectPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
        subjectPlaceholders.put("{{company_name}}", company.getCompanyName());
//        bodyPlaceholders.put("{{legal_mail}}", legalMail);
        subjectPlaceholders.put("{{email_type}}",emailType);
        String subject = Utils.replacePlaceholders(systemEmailTemplateResponse.getSubject(), subjectPlaceholders);
        String body = Utils.replacePlaceholders(systemEmailTemplateResponse.getHtmlContent(), bodyPlaceholders);

        return new EmailContentResponse(subject, body, systemEmailTemplateResponse);
    }

    private void sendEmails(ApplicationEntity applicationEntity, UserEntity userEntity, List<String> additionalRecipients,Long amendmentId,SystemEmailTemplateResponse systemEmailTemplateResponse,String subject,String body) {

        Optional<ApplicationEvaluationEntity> applicationEvaluationEntity = applicationEvaluationRepository.findByApplicationIdAndIsDeletedFalse(applicationEntity.getId());
        CompanyEntity company = companyService.validateCompany(applicationEntity.getCompanyId());
        ApplicationAmendmentRequestEntity applicationAmendmentRequest =null;
        if(amendmentId!=null) {
            applicationAmendmentRequest = applicationAmendmentRequestDao.validateApplicationAmendmentRequest(amendmentId);
        }
        List<AttachmentRequest> attachmentRequests =new ArrayList<>();
        S3DocxProcessor processor = new S3DocxProcessor(s3Client);
        List<String> urls=new ArrayList<>();
        Map<String, String> replacements=new HashMap<>();
        List<DocumentEntity> documentEntities=new ArrayList<>();
        if(systemEmailTemplateResponse.getEmailScenario().equals(EmailScenarioTypeEnum.SPECIAL_APPLICATION_AMENDMENT_REQUESTED)) {
             replacements = Map.of(
                    "{call_name}", applicationEntity.getCall().getName(),
                    "{amount_accepted}", String.valueOf(applicationEntity.getAmountAccepted()),
                    "{pec}", "bandi.gepafin@legalmail.it"
            );
            documentEntities=documentRepository.findBySourceInAndIsDeletedFalse(List.of(applicationAmendmentRequest.getAmendmentDocumentType(),"MODELLO_AUTOCERTIFICAZIONE","MODELLO_PRIVACY"));
        }
        if(Boolean.TRUE.equals(userEntity.getHub().getUniqueUuid().equals(defaultHubUuid)) && Boolean.TRUE.equals(systemEmailTemplateResponse.getEmailScenario().equals(EmailScenarioTypeEnum.APPLICATION_AMENDMENT_REQUESTED))) {
            List<Long> documentIds=applicationDao.validateDocumentIds(applicationAmendmentRequest.getAmendmentInitialDocument());
            Set<Long> setOfDocumentIds = (documentIds == null)
                    ? Collections.emptySet()
                    : new HashSet<>(documentIds);
         documentEntities=documentRepository.findAllByIdInAndIsDeletedFalse(setOfDocumentIds);
        }
        if(Boolean.TRUE.equals(userEntity.getHub().getUniqueUuid().equals(defaultHubUuid)) && Boolean.TRUE.equals(systemEmailTemplateResponse.getEmailScenario().equals(EmailScenarioTypeEnum.APPLICATION_REJECTED))) {
            List<Long> documentIds=applicationDao.validateDocumentIds(applicationEntity.getRejectedDocument());
            Set<Long> setOfDocumentIds = (documentIds == null)
                    ? Collections.emptySet()
                    : new HashSet<>(documentIds);
            documentEntities=documentRepository.findAllByIdInAndIsDeletedFalse(setOfDocumentIds);
        }

            urls = documentEntities.stream()
                .map(DocumentEntity::getFilePath)   // or getUrl()
                .collect(Collectors.toList());
            if(Boolean.FALSE.equals(urls.isEmpty())) {
            Map<String, AttachmentRequest> processedFiles = null;
            try {
                processedFiles = processor.processFiles(urls, replacements);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            for (Map.Entry<String, AttachmentRequest> entry : processedFiles.entrySet()) {
                AttachmentRequest attachmentRequest = new AttachmentRequest();
                attachmentRequest.setName(entry.getKey());     // e.g. "path/file1.docx"
                attachmentRequest.setFile(entry.getValue().getFile());   // updated file content
                attachmentRequests.add(attachmentRequest);
            }
        }
        UserWithCompanyEntity userWithCompany=companyService.getUserWithCompany(userEntity.getId(),company.getId());
                String companyEmail = userWithCompany.getEmail();
                String contactEmail = userWithCompany.getContactEmail();
                    if (Boolean.TRUE.equals(userEntity.getHub().getUniqueUuid().equals(defaultHubUuid))){
                        List<String> recipientEmails=new ArrayList<>();
                        if (company.getPec()!=null) {
                            recipientEmails.add(company.getPec());
                        }else {
                            recipientEmails.add(userWithCompany.getPec());
                        }
                        EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.COMPANY,company.getId() ,
                                String.valueOf(recipientEmails), userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());
                        emailLogRequest.setAttachments(attachmentRequests);
                        sendMail(applicationEntity.getHubId(), subject, body, recipientEmails, emailLogRequest);
                    }
                    else {
                        if (companyEmail != null && !companyEmail.isEmpty()) {
                            EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.COMPANY, company.getId(),
                                    companyEmail, userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());
                            emailLogRequest.setAttachments(attachmentRequests);
                            sendMail(applicationEntity.getHubId(), subject, body, List.of(companyEmail), emailLogRequest);
                        }
                        if (contactEmail != null && !contactEmail.isEmpty() && !contactEmail.equals(companyEmail)) {
                            EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.COMPANY, company.getId(),
                                    contactEmail, userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());
                            emailLogRequest.setAttachments(attachmentRequests);
                            sendMail(applicationEntity.getHubId(), subject, body, List.of(contactEmail), emailLogRequest);
                        }
                    }

                if (userEntity.getBeneficiary().getEmail() != null) {
                    String beneficiaryEmail = null;
                    if (Boolean.TRUE.equals(userEntity.getHub().getUniqueUuid().equals(defaultHubUuid))){
                        beneficiaryEmail=applicationEntity.getPecEmail();
                    }else {
                        beneficiaryEmail=userEntity.getBeneficiary().getEmail();
                    }
                    EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.BENEFICIARY,userEntity.getBeneficiary().getId() ,
                            beneficiaryEmail, userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());
                    emailLogRequest.setAttachments(attachmentRequests);
                    sendMail(applicationEntity.getHubId(), subject, body, List.of(beneficiaryEmail), emailLogRequest);
                }
                if(userEntity.getHub().getEmail() != null){
                    String hubEmails = userEntity.getHub().getEmail();
                    String[] hubEmailArray = hubEmails.split(",");
                    for (String hubEmail : hubEmailArray) {
                        hubEmail = hubEmail.trim();
                        if (!hubEmail.isEmpty()) {
                            EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.PROPERTIES,null,
                                    hubEmail, userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());
                            emailLogRequest.setAttachments(attachmentRequests);
                            sendMail(applicationEntity.getHubId(), subject, body, List.of(hubEmail), emailLogRequest);
                        }
                    }
                }
               if (GepafinConstant.RINALDO_EMAIL.equals(rinaldoEmail)) {
                   EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.PROPERTIES,null ,
                           rinaldoEmail, userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());

                   //SMTP
                   emailLogRequest.setAttachments(attachmentRequests);
                   sendMail(null, subject, body, List.of(rinaldoEmail), emailLogRequest);
               }
              if (applicationEvaluationEntity.isPresent()) {
                  Long preInstructorId = applicationEvaluationEntity.get().getUserId(); // Assuming UserEntity has an email field
                  UserEntity instructorUser = userService.validateUser(preInstructorId);
                  String preInstructorEmail = instructorUser.getEmail();
                  if (preInstructorEmail != null && !preInstructorEmail.isEmpty()) {
                      EmailLogRequest emailLogRequest = emailLogDao.createEmailLogRequest(systemEmailTemplateResponse.getEmailScenario(), RecipientTypeEnum.INSTRUCTOR, instructorUser.getId(),
                              preInstructorEmail, userEntity.getId(), applicationEntity.getId(), amendmentId, applicationEntity.getCall().getId());
                      emailLogRequest.setAttachments(attachmentRequests);
                      sendMail(applicationEntity.getHubId(), subject, body, List.of(preInstructorEmail), emailLogRequest);
                  }
              }
    }
//
//    private String determineService(Long hubId) {
//
//        HubEntity hub = hubRepository.findById(hubId).orElseThrow(() -> new IllegalArgumentException("Invalid Hub ID: " + hubId));
//        return hub.getEmailServiceType().equalsIgnoreCase("MAILGUN_SERVICE") ? "Sviluppumbria" : "Gepafin S.p.a.";
//    }

    public void sendMailToNotifyBeneficiaryRegardingNewAmendment(ApplicationAmendmentRequestEntity applicationAmendmentRequestEntity) {

        ApplicationEntity applicationEntity = applicationService.validateApplication(applicationAmendmentRequestEntity.getApplicationId());
        Map<String, String> bodyPlaceholders = prepareEmailPlaceholders(applicationEntity, applicationAmendmentRequestEntity);
        sendEmail(applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.DOCUMENTATION_INTEGRATION_REQUEST, bodyPlaceholders, null,
                applicationAmendmentRequestEntity.getId(),null);
    }
    public Map<String, String> prepareEmailPlaceholders(ApplicationEntity applicationEntity, ApplicationAmendmentRequestEntity applicationAmendmentRequestEntity){
        Map<String, String> bodyPlaceholders = new HashMap<>();
        bodyPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
        String protocolNumber=applicationEntity.getProtocol().getExternalProtocolNumber();
        if(protocolNumber==null){
            protocolNumber= String.valueOf(applicationEntity.getProtocol().getProtocolNumber());
        }
        bodyPlaceholders.put("{{protocol_number}}", protocolNumber);
        String protocolDate= DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getCreatedDate(), GepafinConstant.DD_MM_YYYY);
        if(applicationEntity.getProtocol().getExternalProtocolDate()!=null){
            protocolDate= DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getExternalProtocolDate(), GepafinConstant.DD_MM_YYYY);
        }
        bodyPlaceholders.put("{{protocol_date}}", protocolDate);
        bodyPlaceholders.put("{{protocol_time}}", DateTimeUtil.parseLocalTimeToString(applicationEntity.getProtocol().getTime(), GepafinConstant.HH_MM_SS));
        bodyPlaceholders.put("{{response_days}}", applicationAmendmentRequestEntity.getResponseDays().toString());

        try {
            // Retrieve forms and initialize required collections
            List<ApplicationFormEntity> forms = applicationFormRepository.findByApplicationId(applicationEntity.getId());
            List<AmendmentFormFieldResponse> allFormFields = new ArrayList<>();
            StringBuilder bulletPoints = new StringBuilder();

            // Extract data from forms
            for (ApplicationFormEntity form : forms) {
                String content = form.getForm().getContent();
                List<Map<String, Object>> fileUploadResult = filterByName(content, "fileupload");
                allFormFields.addAll(getIdAndLabelFromResult(fileUploadResult));

                List<Map<String, Object>> fileSelectResult = filterByName(content,GepafinConstant.FILE_SELECT);
                allFormFields.addAll(getIdAndLabelFromResult(fileSelectResult));
            }

            // Process allFormFields and generate bullet points
            for (AmendmentFormFieldResponse field : allFormFields) {
                // Build bullet points
//                bulletPoints.append(field.getLabel());
                bulletPoints.append("<li>").append(field.getLabel()).append("</li>");

            }
            // Add the generated bullet points to placeholders
            bodyPlaceholders.put("{{form_dataInput}}", bulletPoints.toString());
        } catch (Exception e) {
            log.error("Failed to process form fields: ", e);
        }


        bodyPlaceholders.put("{{note}}", applicationAmendmentRequestEntity.getNote());
        return bodyPlaceholders;
    }

    public List<AmendmentFormFieldResponse> getIdAndLabelFromResult(List<Map<String, Object>> result) {
        List<AmendmentFormFieldResponse> formFieldResponses = new ArrayList<>();

        for (Map<String, Object> item : result) {
            AmendmentFormFieldResponse formFieldResponse = new AmendmentFormFieldResponse();
            formFieldResponse.setFieldId((String) item.get("id"));

            // Extract "label" value from the "settings" array
            List<Map<String, Object>> settings = (List<Map<String, Object>>) item.get("settings");
            String label = settings.stream()
                    .filter(setting -> "label".equals(setting.get("name")))
                    .map(setting -> (String) setting.get("value"))
                    .findFirst()
                    .orElse(""); // Default to empty string if not found

            if (label == null || label.trim().isEmpty()) {
                continue;
            }

            formFieldResponse.setLabel(label); // Set the label as fieldValue
            formFieldResponses.add(formFieldResponse);
        }

        return formFieldResponses;
    }

    public void sendApplicationFailureNotificationEmail(ApplicationAmendmentRequestEntity amendmentRequest) {

        ApplicationEntity applicationEntity = applicationService.validateApplication(amendmentRequest.getApplicationId());
        UserEntity user = userService.validateUser(applicationEntity.getUserId());
        Map<String, String> bodyPlaceholders = new HashMap<>();
        bodyPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
        LocalDateTime lastReminderDateTime=amendmentRequest.getCreatedDate();
            List<EmailLogEntity> emailLogEntity = emailLogRepository.findByUserIdAndAmendmentIdAndIsDeletedFalse(user.getId(),amendmentRequest.getId());
            if(emailLogEntity!=null && (!emailLogEntity.isEmpty())){
                EmailLogEntity emailLogEntity1=emailLogEntity.get(0);
                lastReminderDateTime=emailLogEntity1.getSendDateTime();
        }
        bodyPlaceholders.put("{{date_time_emailSend}}", DateTimeUtil.formatLocalDateTime(lastReminderDateTime, GepafinConstant.DD_MM_YYYY));

        sendEmail(applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.INADMISSIBILITY_NOTIFICATION_DUE_TO_FAILURE, bodyPlaceholders, null,amendmentRequest.getId(),null);
    }

    public void sendAdmissibilityNotificationEmailForAdmissibleApplication(ApplicationEntity applicationEntity) {
        Map<String, String> bodyPlaceholders = new HashMap<>();
        bodyPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
        String protocolNumber=applicationEntity.getProtocol().getExternalProtocolNumber();
        if(protocolNumber==null){
            protocolNumber= String.valueOf(applicationEntity.getProtocol().getProtocolNumber());
        }
        bodyPlaceholders.put("{{protocol_number}}", protocolNumber);
        String protocolDate= DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getCreatedDate(), GepafinConstant.DD_MM_YYYY);
        if(applicationEntity.getProtocol().getExternalProtocolDate()!=null){
            protocolDate= DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getExternalProtocolDate(), GepafinConstant.DD_MM_YYYY);
        }
        bodyPlaceholders.put("{{protocol_date}}", protocolDate);
        bodyPlaceholders.put("{{protocol_time}}", DateTimeUtil.parseLocalTimeToString(applicationEntity.getProtocol().getTime(), GepafinConstant.HH_MM_SS));

        sendEmail(applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.ADMISSIBILITY_NOTIFICATION, bodyPlaceholders, null,null,null);
    }

    public void sendInadmissibilityEmailForRejectedApplication(ApplicationEntity applicationEntity,ApplicationEvaluationEntity applicationEvaluationEntity,String tipoInammissibilita,String emailType) {
        Map<String, String> bodyPlaceholders = new HashMap<>();
        bodyPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
        String protocolNumber=applicationEntity.getProtocol().getExternalProtocolNumber();
        if(protocolNumber==null){
            protocolNumber= String.valueOf(applicationEntity.getProtocol().getProtocolNumber());
        }
        bodyPlaceholders.put("{{protocol_number}}", protocolNumber);
        String protocolDate= DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getCreatedDate(), GepafinConstant.DD_MM_YYYY);
        if(applicationEntity.getProtocol().getExternalProtocolDate()!=null){
            protocolDate= DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getExternalProtocolDate(), GepafinConstant.DD_MM_YYYY);
        }
        bodyPlaceholders.put("{{protocol_date}}", protocolDate);
        bodyPlaceholders.put("{{protocol_time}}", DateTimeUtil.parseLocalTimeToString(applicationEntity.getProtocol().getTime(), GepafinConstant.HH_MM_SS));
        HubEntity hubEntity = hubService.valdateHub(applicationEntity.getHubId());
        bodyPlaceholders.put("{{tipo_inammissibilita}}", tipoInammissibilita);
        bodyPlaceholders.put("{{form_text}}", applicationEvaluationEntity.getMotivation());
        sendEmail(applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.INADMISSIBILITY_TEMPLATE, bodyPlaceholders, null,null,emailType);
    }

    public void sendMail(Long hubId, String subject, String body, List<String> recipientEmails, EmailLogRequest emailLogRequest) {

        EmailConfig emailConfig = new EmailConfig();
        if (recipientEmails.stream().anyMatch(email -> email.equals(GepafinConstant.RINALDO_EMAIL))) {
            emailConfig.setEmailServiceType(EmailServiceTypeEnum.SYSTEM_EMAIL_SERVICE.getValue());
            EmailService emailService = emailServiceFactory.getEmailService(emailConfig.getEmailServiceType());
            emailService.sendEmail(subject, body,  recipientEmails, emailConfig, emailLogRequest);
        } else {
            emailConfig = retrieveEmailConfig(hubId);
            EmailService emailService = emailServiceFactory.getEmailService(emailConfig.getEmailServiceType());
            emailService.sendEmail(subject, body,  recipientEmails, emailConfig, emailLogRequest);
        }
    }

    public EmailConfig retrieveEmailConfig(Long hubId) {

        HubEntity hubEntity = hubRepository.findById(hubId).orElseThrow(() -> new IllegalArgumentException("Invalid Hub ID: " + hubId));
        String emailServiceType = hubEntity.getEmailServiceType();
        String encryptedConfigJson = hubEntity.getEmailServiceConfig();
        String decryptedConfigJson = Utils.decryptCredential(encryptedConfigJson);
        EmailConfig emailConfig = parseEmailConfig(decryptedConfigJson);
        emailConfig.setEmailServiceType(emailServiceType);
        return emailConfig;
    }

    private static EmailConfig parseEmailConfig(String configJson) {

        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.readValue(configJson, EmailConfig.class);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException("Failed to parse email configuration JSON", e);
        }
    }

    public void sendMailForApplicationTechnicalEvaluationRejected(ApplicationEntity applicationEntity,HubEntity hub,ApplicationEvaluationEntity applicationEvaluationEntity) {

        Map<String, String> bodyPlaceholders = prepareEmailPlaceholdersForTechnicalEvaluationRejected(applicationEntity,hub,applicationEvaluationEntity);
        sendEmail(applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.INADMISSIBILITY_NOTIFICATION_DUE_TO_TECHNICAL_EVALUATION_FAILURE, bodyPlaceholders, null,
                null,null);
    }

//    public void sendMailForApplicationTechnicalEvaluationRejected(ApplicationEntity applicationEntity,HubEntity hub,ApplicationEvaluationEntity applicationEvaluationEntity,Map<String, Object> emailJson) {
//
//        HubEntity hubEntity = hubService.valdateHub(applicationEntity.getHubId());
//        SystemEmailTemplateResponse systemEmailTemplateResponse=new SystemEmailTemplateResponse();
//        systemEmailTemplateResponse.setSubject((String) emailJson.get("subject"));
//        systemEmailTemplateResponse.setHtmlContent((String) emailJson.get("message"));
//        Map<String, String> subjectPlaceholders = new HashMap<>();
//        CompanyEntity company = companyService.validateCompany(applicationEntity.getCompanyId());
//        subjectPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
//        subjectPlaceholders.put("{{company_name}}", company.getCompanyName());
//        Map<String, String> bodyPlaceholders = prepareEmailPlaceholdersForTechnicalEvaluationRejected(applicationEntity,hub,applicationEvaluationEntity);
//        String subject = Utils.replacePlaceholders(systemEmailTemplateResponse.getSubject(), subjectPlaceholders);
//        String body = Utils.replacePlaceholders(systemEmailTemplateResponse.getHtmlContent(), bodyPlaceholders);
//        SystemEmailTemplateResponse systemEmailTemplateResponse1=new SystemEmailTemplateResponse();
//        systemEmailTemplateResponse1.setSubject(subject);
//        systemEmailTemplateResponse1.setHtmlContent(body);
//        systemEmailTemplateResponse1.setEmailScenario(EmailScenarioTypeEnum.APPLICATION_TECHNICAL_EVALUATION_REJECTED);
//        EmailContentResponse emailContentResponse=new EmailContentResponse(subject,body,systemEmailTemplateResponse1);
//        UserEntity userEntity = userService.validateUser(applicationEntity.getUserId());
//        sendEmails(applicationEntity, userEntity, null,null,emailContentResponse.getSystemEmailTemplateResponse(),emailContentResponse.getSubject(),emailContentResponse.getBody());
//
//    }
    public Map<String, String> prepareEmailPlaceholdersForTechnicalEvaluationRejected(ApplicationEntity applicationEntity,HubEntity hub,ApplicationEvaluationEntity applicationEvaluationEntity) {
        Map<String, String> bodyPlaceholders = new HashMap<>();
        bodyPlaceholders.put("{{call_name}}", applicationEntity.getCall().getName());
        String protocolNumber = applicationEntity.getProtocol().getExternalProtocolNumber();
        if (protocolNumber == null) {
            protocolNumber = String.valueOf(applicationEntity.getProtocol().getProtocolNumber());
        }
        bodyPlaceholders.put("{{protocol_number}}", protocolNumber);
        String protocolDate = DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getCreatedDate(), GepafinConstant.DD_MM_YYYY);
        if (applicationEntity.getProtocol().getExternalProtocolDate() != null) {
            protocolDate = DateTimeUtil.formatLocalDateTime(applicationEntity.getProtocol().getExternalProtocolDate(), GepafinConstant.DD_MM_YYYY);
        }
        bodyPlaceholders.put("{{protocol_date}}", protocolDate);
        bodyPlaceholders.put("{{protocol_time}}", DateTimeUtil.parseLocalTimeToString(applicationEntity.getProtocol().getTime(), GepafinConstant.HH_MM_SS));
        bodyPlaceholders.put("{{email_signature}}", hub.getEmailSignature());
        bodyPlaceholders.put("{{platform_link}}", hub.getDomainName());
        bodyPlaceholders.put("{{form_text}}", applicationEvaluationEntity.getMotivation());

        return bodyPlaceholders;
    }
    public void sendMailforSpecialAmendment(ApplicationAmendmentRequestEntity applicationAmendmentRequestEntity,ApplicationEntity applicationEntity) {

        Map<String, String> bodyPlaceholders = prepareEmailPlaceholders(applicationEntity, applicationAmendmentRequestEntity);
        sendEmail(applicationEntity, SystemEmailTemplatesEntity.SystemEmailTemplatesEntityTypeEnum.SPECIAL_APPLICATION_AMENDMENT_REQUESTED, bodyPlaceholders, null,
                applicationAmendmentRequestEntity.getId(),null);
    }
    }