package net.gepafin.tendermanagement.dao;

import com.fasterxml.jackson.core.type.TypeReference;
import net.gepafin.tendermanagement.config.Translator;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.*;
import net.gepafin.tendermanagement.enums.*;
import net.gepafin.tendermanagement.model.request.ApplicationEvaluationRequest;
import net.gepafin.tendermanagement.model.request.ChecklistRequest;
import net.gepafin.tendermanagement.model.request.CriteriaRequest;
import net.gepafin.tendermanagement.model.request.FieldRequest;
import net.gepafin.tendermanagement.model.response.*;
import net.gepafin.tendermanagement.repositories.*;
import net.gepafin.tendermanagement.service.ApplicationService;
import net.gepafin.tendermanagement.service.UserService;
import net.gepafin.tendermanagement.util.Utils;
import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

import static net.gepafin.tendermanagement.util.Utils.setIfUpdated;

@Component
public class ApplicationEvaluationDao {

    @Autowired
    private ApplicationEvaluationRepository applicationEvaluationRepository;

    @Autowired
    private ApplicationService applicationService;

    @Autowired
    private CallRepository callRepository;

    @Autowired
    private ApplicationRepository applicationRepository;

    @Autowired
    private UserService userService;

    @Autowired
    private EvaluationCriteriaRepository evaluationCriteriaRepository;

    @Autowired
    private FormRepository formRepository;

    @Autowired
    private CallTargetAudienceChecklistRepository callTargetAudienceChecklistRepository;

    @Autowired
    private DocumentRepository documentRepository;

    @Autowired
    private ApplicationFormRepository applicationFormRepository;

    @Autowired
    private ApplicationFormFieldRepository applicationFormFieldRepository;

    @Autowired
    private AssignedApplicationsRepository assignedApplicationsRepository;

    @Autowired
    private CriteriaFormFieldRepository criteriaFormFieldRepository;

    @Autowired
    private EmailNotificationDao emailNotificationDao;

    @Autowired
    ApplicationAmendmentRequestRepository applicationAmendmentRequestRepository;

    private ApplicationEvaluationEntity convertToEntity(UserEntity user, ApplicationEvaluationRequest req, Long assignedApplciationId) {

        ApplicationEvaluationEntity entity = new ApplicationEvaluationEntity();

        AssignedApplicationsEntity assignedApplications = assignedApplicationsRepository.findByIdAndIsDeletedFalse(assignedApplciationId).orElse(null);
        ApplicationEntity application = applicationService.validateApplication(assignedApplications.getApplication().getId());
        entity.setApplicationId(application.getId());
        entity.setAssignedApplicationsEntity(assignedApplications);
        entity.setUserId(user.getId());
        entity.setCriteria(Utils.convertObjectToJson(req.getCriteria()));
        entity.setChecklist(Utils.convertObjectToJson(req.getChecklist()));
        entity.setFile(Utils.convertObjectToJson(req.getFiles()));
        entity.setNote(req.getNote());
        entity.setIsDeleted(false);
        entity.setStatus(ApplicationEvaluationStatusTypeEnum.OPEN.getValue());
        return entity;
    }

    private ApplicationEvaluationResponse convertToResponse(ApplicationEvaluationEntity entity) {

        ApplicationEvaluationResponse response = new ApplicationEvaluationResponse();
        populateBasicDetails(entity, response);

        CallEntity call = callRepository.findCallEntityByApplicationId(entity.getApplicationId());
        List<EvaluationCriteriaEntity> evaluationCriterias = evaluationCriteriaRepository.findByCallId(call.getId());
        List<CallTargetAudienceChecklistEntity> checklistEntities = callTargetAudienceChecklistRepository.findByCallId(call.getId());
        List<ApplicationFormEntity> applicationFormEntities = applicationFormRepository.findByApplicationId(entity.getApplicationId());

        setCriteriaResponses(entity, response, evaluationCriterias);
        setChecklistResponses(entity, response, checklistEntities);
        setFieldResponses(entity, response, applicationFormEntities);

        setApplicationDetails(response, entity);

        return response;
    }

    private void populateBasicDetails(ApplicationEvaluationEntity entity, ApplicationEvaluationResponse response) {

        response.setId(entity.getId());
        response.setApplicationId(entity.getApplicationId());
        AssignedApplicationsEntity assignedApplications = assignedApplicationsRepository.findByIdAndIsDeletedFalse(entity.getAssignedApplicationsEntity().getId()).orElse(null);
        response.setAssignedApplicationId(assignedApplications.getId());
        response.setNote(entity.getNote());
        response.setStatus(ApplicationEvaluationStatusTypeEnum.valueOf(entity.getStatus()));
        response.setCreatedDate(entity.getCreatedDate());
        response.setUpdatedDate(entity.getUpdatedDate());
    }



    private void setCriteriaResponses(ApplicationEvaluationEntity entity, ApplicationEvaluationResponse response, List<EvaluationCriteriaEntity> evaluationCriterias) {

        List<CriteriaResponse> criteriaResponsesFromEntity = entity.getCriteria() != null ?
                Utils.convertJsonToList(entity.getCriteria(), new TypeReference<List<CriteriaResponse>>() {
                }) :
                new ArrayList<>();

        List<CriteriaResponse> criteriaResponsesFromDB = getCriteriaResponse(entity.getApplicationId());
        addMissingCriteriaResponses(criteriaResponsesFromEntity, criteriaResponsesFromDB, entity.getApplicationId());
        criteriaResponsesFromEntity.forEach(criteriaResponse -> {
            EvaluationCriteriaEntity matchingEvaluationCriteria = evaluationCriterias.stream()
                    .filter(evaluationCriteria -> evaluationCriteria.getId().equals(criteriaResponse.getId())).findFirst().orElse(null);

            if (matchingEvaluationCriteria != null) {
                criteriaResponse.setLabel(matchingEvaluationCriteria.getLookupData().getValue());
                criteriaResponse.setMaxScore(matchingEvaluationCriteria.getScore());

                List<CriteriaMappedField> mappedFields = getMappedFieldsForCriteria(matchingEvaluationCriteria.getId(), entity.getApplicationId());
                criteriaResponse.setCriteriaMappedFields(mappedFields);
            }
        });

        response.setCriteria(criteriaResponsesFromEntity);
    }

    private void addMissingCriteriaResponses(List<CriteriaResponse> criteriaResponsesFromEntity, List<CriteriaResponse> criteriaResponsesFromDB, Long applicationId) {

        Set<Long> existingCriteriaIds = criteriaResponsesFromEntity.stream().map(CriteriaResponse::getId).collect(Collectors.toSet());

        for (CriteriaResponse dbResponse : criteriaResponsesFromDB) {
            if (!existingCriteriaIds.contains(dbResponse.getId())) {
                List<CriteriaMappedField> mappedFields = getMappedFieldsForCriteria(dbResponse.getId(), applicationId);
                dbResponse.setCriteriaMappedFields(mappedFields);
                criteriaResponsesFromEntity.add(dbResponse);
            }
        }
    }

    private List<CriteriaMappedField> getMappedFieldsForCriteria(Long evaluationCriteriaId, Long applicationId) {

        List<CriteriaFormFieldEntity> criteriaFormFields = criteriaFormFieldRepository.findByEvaluationCriteriaIdAndIsDeletedFalse(evaluationCriteriaId);
        List<CriteriaMappedField> mappedFields = new ArrayList<>();

        Set<String> uniqueFieldIds = new HashSet<>();

        List<ApplicationFormEntity> applicationForms = applicationFormRepository.findByApplicationId(applicationId);
        for (ApplicationFormEntity applicationForm : applicationForms) {
            for (CriteriaFormFieldEntity formField : criteriaFormFields) {
                String formFieldId = formField.getFormFieldId();

                if (!uniqueFieldIds.contains(formFieldId)) {
                    CriteriaMappedField mappedField = new CriteriaMappedField();
                    mappedField.setId(formFieldId);

                    FormEntity formEntity = formRepository.findById(formField.getFormId()).orElse(null);
                    if (formEntity != null) {
                        List<ContentResponseBean> contentBeans = Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class);
                        contentBeans.stream().filter(contentBean -> contentBean.getId().equals(formFieldId)).findFirst().ifPresent(contentBean -> {
                            String label = contentBean.getLabel();
                            if (contentBean.getSettings() != null) {
                                for (SettingResponseBean setting : contentBean.getSettings()) {
                                    if ("label".equals(setting.getName())) {
                                        label = setting.getValue() != null ? setting.getValue().toString() : label;
                                        break;
                                    }
                                }
                            }
                            mappedField.setFieldLabel(label);
                        });
                    }

                    Optional<ApplicationFormFieldEntity> formFieldEntityOptional = applicationFormFieldRepository.findByFieldIdAndApplicationFormIdAndApplicationFormApplicationId(
                            formFieldId, applicationForm.getId(), applicationId);

                    formFieldEntityOptional.ifPresent(field -> mappedField.setFieldValue(field.getFieldValue()));

                    mappedFields.add(mappedField);
                    uniqueFieldIds.add(formFieldId);
                }
            }
        }
        return mappedFields;
    }

    private void setChecklistResponses(ApplicationEvaluationEntity entity, ApplicationEvaluationResponse response, List<CallTargetAudienceChecklistEntity> checklistEntities) {

        List<ChecklistResponse> checklistResponsesFromEntity = entity.getChecklist() != null ?
                Utils.convertJsonToList(entity.getChecklist(), new TypeReference<List<ChecklistResponse>>() {
                }) :
                new ArrayList<>();

        List<ChecklistResponse> checklistResponsesFromDB = getChecklistResponse(entity.getApplicationId());
        addMissingChecklistResponses(checklistResponsesFromEntity, checklistResponsesFromDB);

        checklistResponsesFromEntity.forEach(checklistResponse -> {
            CallTargetAudienceChecklistEntity matchingChecklist = checklistEntities.stream().filter(checklistEntity -> checklistEntity.getId().equals(checklistResponse.getId()))
                    .findFirst().orElse(null);

            if (matchingChecklist != null) {
                checklistResponse.setLabel(matchingChecklist.getLookupData().getValue());
            }
        });

        response.setChecklist(checklistResponsesFromEntity);
    }

    private void addMissingChecklistResponses(List<ChecklistResponse> checklistResponsesFromEntity, List<ChecklistResponse> checklistResponsesFromDB) {

        Set<Long> existingChecklistIds = checklistResponsesFromEntity.stream().map(ChecklistResponse::getId).collect(Collectors.toSet());

        for (ChecklistResponse dbResponse : checklistResponsesFromDB) {
            if (!existingChecklistIds.contains(dbResponse.getId())) {
                checklistResponsesFromEntity.add(dbResponse);
            }
        }
    }

    private void setFieldResponses(ApplicationEvaluationEntity entity, ApplicationEvaluationResponse response, List<ApplicationFormEntity> applicationFormEntities) {

        List<FieldResponse> fieldResponsesFromEntity = entity.getFile() != null ? Utils.convertJsonToList(entity.getFile(), new TypeReference<List<FieldResponse>>() {
        }) : new ArrayList<>();
        List<FieldResponse> fieldResponsesFromDB = getFieldResponses(entity.getApplicationId());
        addMissingFieldResponses(fieldResponsesFromEntity, fieldResponsesFromDB);

        Set<String> processedFieldIds = new HashSet<>();

        fieldResponsesFromEntity.forEach(fieldResponse -> {
            if (processedFieldIds.contains(fieldResponse.getId())) {
                return;
            }

            applicationFormEntities.forEach(applicationForm -> {
                FormEntity formEntity = applicationForm.getForm();
                if (formEntity != null) {
                    List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class);
                    contentResponseBeans.forEach(contentResponseBean -> {
                        if ("fileupload".equals(contentResponseBean.getName()) && contentResponseBean.getId().equals(fieldResponse.getId())) {
                            String label = null;
                            if (contentResponseBean.getSettings() != null) {
                                for (SettingResponseBean setting : contentResponseBean.getSettings()) {
                                    if ("label".equals(setting.getName())) {
                                        label = setting.getValue() != null ? setting.getValue().toString() : label;
                                        break;
                                    }
                                }
                            }
                            fieldResponse.setLabel(label);

                            Optional<ApplicationFormFieldEntity> optionalFormField =
                                    applicationFormFieldRepository.findByFieldIdAndApplicationFormIdAndApplicationFormApplicationId(
                                    fieldResponse.getId(), applicationForm.getId(), entity.getApplicationId());

                            if (optionalFormField.isPresent()) {
                                ApplicationFormFieldEntity formField = optionalFormField.get();
                                if (formField.getFieldValue() != null) {
                                    String[] documentIds = formField.getFieldValue().split(",");
                                    List<DocumentResponseBean> documentResponseBeans = new ArrayList<>();

                                    for (String docId : documentIds) {
                                        Long documentId = Long.valueOf(docId.trim());
                                        documentRepository.findByIdAndNotDeleted(documentId).ifPresent(documentEntity -> {
                                            DocumentResponseBean responseBean = new DocumentResponseBean();
                                            responseBean.setId(documentEntity.getId());
                                            responseBean.setName(documentEntity.getFileName());
                                            responseBean.setType(DocumentTypeEnum.valueOf(documentEntity.getType()));
                                            responseBean.setSource(DocumentSourceTypeEnum.valueOf(documentEntity.getSource()));
                                            responseBean.setSourceId(documentEntity.getSourceId());
                                            responseBean.setFilePath(documentEntity.getFilePath());
                                            responseBean.setCreatedDate(documentEntity.getCreatedDate());
                                            responseBean.setUpdatedDate(documentEntity.getUpdatedDate());
                                            documentResponseBeans.add(responseBean);
                                        });
                                    }

                                    fieldResponse.setFileDetail(documentResponseBeans);
                                }
                            }
                            processedFieldIds.add(fieldResponse.getId());
                        }
                    });
                }
            });
        });
        response.setFiles(fieldResponsesFromEntity);
    }

    private void addMissingFieldResponses(List<FieldResponse> fieldResponsesFromEntity, List<FieldResponse> fieldResponsesFromDB) {

        Set<String> existingFieldIds = fieldResponsesFromEntity.stream().map(FieldResponse::getId).collect(Collectors.toSet());

        for (FieldResponse dbResponse : fieldResponsesFromDB) {
            if (!existingFieldIds.contains(dbResponse.getId())) {
                fieldResponsesFromEntity.add(dbResponse);
            }
        }
    }

    private void setApplicationDetails(ApplicationEvaluationResponse response, ApplicationEvaluationEntity entity) {

        ApplicationEntity application = applicationService.validateApplication(entity.getApplicationId() != null ? entity.getApplicationId() : null);
        UserEntity user = userService.validateUser(application.getUserId());

        CallEntity call = callRepository.findCallEntityByApplicationId(entity.getApplicationId());

        String firstName = user.getFirstName() != null ? user.getFirstName() : "";
        String lastName = user.getLastName() != null ? user.getLastName() : "";
        String beneficiary = String.join(" ", firstName, lastName).trim();
        response.setApplicationStatus(ApplicationStatusTypeEnum.valueOf(application.getStatus()));
        response.setBeneficiary(beneficiary);
        response.setMinScore(call.getThreshold() != null ? call.getThreshold() : null);
        response.setCallName(application.getCall().getName() != null ? application.getCall().getName() : null);
        response.setProtocolNumber(application.getProtocol() != null ? application.getProtocol().getProtocolNumber() : null);
        response.setSubmissionDate(application.getSubmissionDate() != null ? application.getSubmissionDate() : null);
        response.setEvaluationDate(application.getSubmissionDate() != null ? application.getSubmissionDate().plusDays(30) : null);
        LocalDateTime callEndDate = application.getCall().getEndDate();
        response.setCallEndDate(callEndDate);
    }


    public ApplicationEvaluationResponse createOrUpdateApplicationEvaluation(
            UserEntity user,
            ApplicationEvaluationRequest req,
            Long assignedApplicationId) {

        Optional<ApplicationEvaluationEntity> existingEntityOptional =
                applicationEvaluationRepository.findByAssignedApplicationsEntity_IdAndIsDeletedFalse(assignedApplicationId);
        ApplicationEvaluationEntity entity;
        Optional<AssignedApplicationsEntity> assignedApplications =
                assignedApplicationsRepository.findByIdAndIsDeletedFalse(assignedApplicationId);

        if (existingEntityOptional.isPresent()) {
            entity = existingEntityOptional.get();
            entity.setCriteria(Utils.convertObjectToJson(filterNonNullCriteria(processCriteria(entity, req))));
            entity.setChecklist(Utils.convertObjectToJson(filterNonNullChecklist(processChecklist(entity, req))));
            entity.setFile(Utils.convertObjectToJson(filterNonNullFields(processField(entity, req))));
            entity.setIsDeleted(false);
            setIfUpdated(entity::getNote, entity::setNote, req.getNote());
        } else {
            entity = convertToEntity(user, req, assignedApplicationId);
        }
        ApplicationStatusForEvaluation status = req.getApplicationStatus();

        ApplicationEvaluationEntity savedEntity = applicationEvaluationRepository.save(entity);
        if (status != null) {
            ApplicationEntity application = applicationService.validateApplication(assignedApplications.get().getApplication().getId());
            AssignedApplicationsEntity assignedApplicationsEntity = assignedApplications.get();
            return updateApplicationEvaluationStatus(application, assignedApplicationsEntity, status);
        } else {
            return convertToResponse(savedEntity);
        }
    }


    private List<ChecklistRequest> filterNonNullChecklist(List<ChecklistRequest> checklistRequests) {

        return checklistRequests.stream().filter(request -> request.getValid() != null).collect(Collectors.toList());
    }

    private List<CriteriaRequest> filterNonNullCriteria(List<CriteriaRequest> criteriaRequests) {

        return criteriaRequests.stream().filter(request -> request.getScore() != null && request.getValid() != null).collect(Collectors.toList());
    }

    private List<FieldRequest> filterNonNullFields(List<FieldRequest> fieldRequests) {

        return fieldRequests.stream().filter(request -> request.getValid() != null).collect(Collectors.toList());
    }

    private List<CriteriaRequest> processCriteria(ApplicationEvaluationEntity entity, ApplicationEvaluationRequest req) {

        List<CriteriaResponse> existingCriteriaList = entity.getCriteria() != null ? Utils.convertJsonToList(entity.getCriteria(), new TypeReference<List<CriteriaResponse>>() {
        }) : new ArrayList<>();

        Map<Long, CriteriaResponse> existingCriteriaMap = existingCriteriaList.stream().collect(Collectors.toMap(CriteriaResponse::getId, criteria -> criteria));

        List<CriteriaRequest> updatedCriteriaList = req.getCriteria().stream().map(incoming -> {
            CriteriaRequest request = new CriteriaRequest();
            request.setId(incoming.getId());
            request.setScore(incoming.getScore());
            request.setValid(incoming.getValid());

            CriteriaResponse existingCriteria = existingCriteriaMap.get(incoming.getId());
            if (existingCriteria != null) {
                request.setScore(incoming.getScore() != null ? incoming.getScore() : null);
                request.setValid(incoming.getValid() != null ? incoming.getValid() : null);
            }
            return request;
        }).collect(Collectors.toList());

        List<CriteriaRequest> missingCriteriaRequests = existingCriteriaList.stream()
                .filter(existing -> !updatedCriteriaList.stream().map(CriteriaRequest::getId).toList().contains(existing.getId())).map(existing -> {
                    CriteriaRequest request = new CriteriaRequest();
                    request.setId(existing.getId());
                    request.setScore(existing.getScore());
                    request.setValid(existing.getValid());
                    return request;
                }).toList();

        updatedCriteriaList.addAll(missingCriteriaRequests);
        return updatedCriteriaList;
    }

    private List<ChecklistRequest> processChecklist(ApplicationEvaluationEntity entity, ApplicationEvaluationRequest req) {

        List<ChecklistResponse> existingChecklistList = entity.getChecklist() != null ?
                Utils.convertJsonToList(entity.getChecklist(), new TypeReference<List<ChecklistResponse>>() {
                }) :
                new ArrayList<>();

        Map<Long, ChecklistResponse> existingChecklistMap = existingChecklistList.stream().collect(Collectors.toMap(ChecklistResponse::getId, checklist -> checklist));

        List<ChecklistRequest> updatedChecklistList = req.getChecklist().stream().map(incoming -> {
            ChecklistRequest request = new ChecklistRequest();
            request.setId(incoming.getId());
            request.setValid(incoming.getValid());

            ChecklistResponse existingChecklist = existingChecklistMap.get(incoming.getId());
            if (existingChecklist != null && incoming.getValid() == null) {
                request.setValid(null);
            }
            return request;
        }).collect(Collectors.toList());

        List<ChecklistRequest> missingChecklistRequests = existingChecklistList.stream()
                .filter(existing -> !updatedChecklistList.stream().map(ChecklistRequest::getId).toList().contains(existing.getId())).map(existing -> {
                    ChecklistRequest request = new ChecklistRequest();
                    request.setId(existing.getId());
                    request.setValid(existing.getValid() != null ? existing.getValid() : null);
                    return request;
                }).toList();

        updatedChecklistList.addAll(missingChecklistRequests);
        return updatedChecklistList;
    }

    private List<FieldRequest> processField(ApplicationEvaluationEntity entity, ApplicationEvaluationRequest req) {

        List<FieldResponse> existingFieldList = entity.getFile() != null ? Utils.convertJsonToList(entity.getFile(), new TypeReference<List<FieldResponse>>() {
        }) : new ArrayList<>();

        Map<String, FieldResponse> existingFieldMap = existingFieldList.stream().collect(Collectors.toMap(FieldResponse::getId, field -> field));

        List<FieldRequest> updatedFieldList = req.getFiles().stream().map(incoming -> {
            FieldRequest request = new FieldRequest();
            request.setId(incoming.getId());
            request.setValid(incoming.getValid());

            FieldResponse existingField = existingFieldMap.get(incoming.getId());
            if (existingField != null) {
                request.setValid(incoming.getValid() != null ? incoming.getValid() : null);
            }
            return request;
        }).collect(Collectors.toList());

        List<FieldRequest> missingFieldRequests = existingFieldList.stream()
                .filter(existing -> !updatedFieldList.stream().map(FieldRequest::getId).toList().contains(existing.getId())).map(existing -> {
                    FieldRequest request = new FieldRequest();
                    request.setId(existing.getId());
                    request.setValid(existing.getValid());
                    return request;
                }).toList();

        updatedFieldList.addAll(missingFieldRequests);
        return updatedFieldList;
    }

    public ApplicationEvaluationEntity validateApplicationEvaluation(Long id) {

        Optional<ApplicationEvaluationEntity> entityOptional = applicationEvaluationRepository.findByIdAndIsDeletedFalse(id);
        if (entityOptional.isEmpty()) {
            throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.APPLICATION_EVALUATION_NOT_FOUND, id));
        }
        return entityOptional.get();
    }


    public ApplicationEvaluationResponse getApplicationEvaluationByApplicationId(UserEntity user, Long applicationId, Long assignedApplicationId) {

        applicationService.validateApplication(applicationId);

        Optional<ApplicationEvaluationEntity> entityOptional;

        if (applicationId != null && assignedApplicationId != null) {
            entityOptional = applicationEvaluationRepository.findByApplicationIdAndAssignedApplicationsEntity_IdAndIsDeletedFalse(applicationId, assignedApplicationId);
        } else if (applicationId != null) {
            entityOptional = applicationEvaluationRepository.findByApplicationIdAndIsDeletedFalse(applicationId);
        } else if (assignedApplicationId != null) {
            entityOptional = applicationEvaluationRepository.findByAssignedApplicationsEntity_IdAndIsDeletedFalse(assignedApplicationId);
        } else {
            entityOptional = applicationEvaluationRepository.findFirstByIsDeletedFalseOrderByCreatedDateDesc();
        }
        return entityOptional.map(this::convertToResponse)
                .orElseGet(() -> {
                    return getEvaluationResponseByApplicationid(user, applicationId, assignedApplicationId);
                });
    }

    public ApplicationEvaluationResponse getEvaluationResponseByApplicationid(UserEntity user, Long applicationId, Long assignedApplicationId) {

        ApplicationEvaluationEntity entity = new ApplicationEvaluationEntity();
        ApplicationEvaluationResponse response = new ApplicationEvaluationResponse();
        CallEntity call = null;
        ApplicationEntity application = null;
        AssignedApplicationsEntity assignedApplications = null;
        if (applicationId != null && assignedApplicationId == null) {
            application = applicationService.validateApplication(applicationId);
            call = callRepository.findCallEntityByApplicationId(applicationId);
            assignedApplications = assignedApplicationsRepository.findByApplicationIdAndIsDeletedFalse(applicationId).orElse(null);
        } else if (assignedApplicationId != null) {
            assignedApplications = assignedApplicationsRepository.findByIdAndIsDeletedFalse(assignedApplicationId)
                    .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.ASSIGNED_APPLICATION_NOT_FOUND_MSG)));
            application = applicationService.validateApplication(assignedApplications.getApplication().getId());
            call = callRepository.findCallEntityByApplicationId(application.getId());

        } else {
            call = callRepository.findCallEntityByApplicationId(applicationId);
            assignedApplications = assignedApplicationsRepository.findByApplicationIdAndIsDeletedFalse(applicationId).orElse(null);
        }
        List<EvaluationCriteriaEntity> evaluationCriterias = evaluationCriteriaRepository.findByCallId(call.getId());
        List<CallTargetAudienceChecklistEntity> checklistEntities = callTargetAudienceChecklistRepository.findByCallId(call.getId());
        List<ApplicationFormEntity> applicationFormEntities = applicationFormRepository.findByApplicationId(applicationId);
        response.setApplicationId(application.getId());
        response.setAssignedApplicationId(assignedApplications.getId());
        response.setNote(null);
        response.setApplicationStatus(ApplicationStatusTypeEnum.valueOf(application.getStatus()));
        response.setStatus(ApplicationEvaluationStatusTypeEnum.valueOf(ApplicationEvaluationStatusTypeEnum.OPEN.getValue()));
        response.setMinScore(call.getThreshold()!=null?call.getThreshold():null);
        LocalDateTime callEndDate = application.getCall().getEndDate();
        response.setCallEndDate(callEndDate);
        setCriteriaResponses(entity, application.getId(), response, evaluationCriterias);
        setChecklistResponses(entity, application.getId(), response, checklistEntities);
        setFileResponses(entity, application.getId(), response, applicationFormEntities);

        setApplicationDetails(response, application.getId(), user);

        return response;
    }

    private void setCriteriaResponses(ApplicationEvaluationEntity entity, Long applicationId, ApplicationEvaluationResponse response,
            List<EvaluationCriteriaEntity> evaluationCriterias) {

        List<CriteriaResponse> criteriaResponses = entity.getCriteria() != null ? Utils.convertJsonToList(entity.getCriteria(), new TypeReference<List<CriteriaResponse>>() {
        }) : getCriteriaResponse(applicationId);

        criteriaResponses.forEach(criteriaResponse -> {
            EvaluationCriteriaEntity matchingEvaluationCriteria = evaluationCriterias.stream()
                    .filter(evaluationCriteria -> evaluationCriteria.getId().equals(criteriaResponse.getId())).findFirst().orElse(null);

            List<ApplicationFormEntity> applicationForms = applicationFormRepository.findByApplicationId(applicationId);
            Map<String, CriteriaMappedField> mappedFieldMap = new HashMap<>();

            if (matchingEvaluationCriteria != null) {
                criteriaResponse.setLabel(matchingEvaluationCriteria.getLookupData().getValue());
                criteriaResponse.setMaxScore(matchingEvaluationCriteria.getScore());

                List<CriteriaFormFieldEntity> criteriaFormFields = criteriaFormFieldRepository.findByEvaluationCriteriaIdAndIsDeletedFalse(matchingEvaluationCriteria.getId());

                for (ApplicationFormEntity applicationForm : applicationForms) {
                    for (CriteriaFormFieldEntity criteriaFormField : criteriaFormFields) {
                        String formFieldId = criteriaFormField.getFormFieldId();
                        if (!mappedFieldMap.containsKey(formFieldId)) {
                            CriteriaMappedField mappedField = new CriteriaMappedField();
                            mappedField.setId(formFieldId);
                            FormEntity formEntity = formRepository.findById(criteriaFormField.getFormId()).orElse(null);

                            if (formEntity != null) {
                                List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class);
                                contentResponseBeans.stream().filter(bean -> bean.getId().equals(formFieldId)).findFirst().ifPresent(contentResponseBean -> {
                                    String label = contentResponseBean.getLabel();
                                    if (contentResponseBean.getSettings() != null) {
                                        for (SettingResponseBean setting : contentResponseBean.getSettings()) {
                                            if ("label".equals(setting.getName())) {
                                                label = setting.getValue() != null ? setting.getValue().toString() : label;
                                                break;
                                            }
                                        }
                                    }
                                    mappedField.setFieldLabel(label);
                                });
                            }
                            Optional<ApplicationFormFieldEntity> formFieldEntityOptional =
                                    applicationFormFieldRepository.findByFieldIdAndApplicationFormIdAndApplicationFormApplicationId(
                                    formFieldId, applicationForm.getId(), applicationId);

                            formFieldEntityOptional.ifPresent(formField -> mappedField.setFieldValue(formField.getFieldValue()));
                            mappedFieldMap.put(formFieldId, mappedField);
                        }
                    }
                }
                criteriaResponse.setCriteriaMappedFields(new ArrayList<>(mappedFieldMap.values()));
            }
        });

        response.setCriteria(criteriaResponses);
    }

    private void setChecklistResponses(ApplicationEvaluationEntity entity, Long applicationId, ApplicationEvaluationResponse response,
            List<CallTargetAudienceChecklistEntity> checklistEntities) {

        List<ChecklistResponse> checklistResponses = entity.getChecklist() != null ? Utils.convertJsonToList(entity.getChecklist(), new TypeReference<List<ChecklistResponse>>() {
        }) : getChecklistResponse(applicationId);

        checklistResponses.forEach(checklistResponse -> {
            CallTargetAudienceChecklistEntity matchingChecklist = checklistEntities.stream().filter(checklistEntity -> checklistEntity.getId().equals(checklistResponse.getId()))
                    .findFirst().orElse(null);

            if (matchingChecklist != null) {
                checklistResponse.setLabel(matchingChecklist.getLookupData().getValue());
            }
        });

        response.setChecklist(checklistResponses);
    }

    private void setFileResponses(ApplicationEvaluationEntity entity, Long applicationId, ApplicationEvaluationResponse response,
            List<ApplicationFormEntity> applicationFormEntities) {

        List<FieldResponse> fieldResponses = entity.getFile() != null ? Utils.convertJsonToList(entity.getFile(), new TypeReference<List<FieldResponse>>() {
        }) : getFieldResponses(applicationId);
        Set<String> processedFieldIds = new HashSet<>();

        fieldResponses.forEach(fieldResponse -> {
            if (processedFieldIds.contains(fieldResponse.getId())) {
                return;
            }

            applicationFormEntities.forEach(applicationForm -> {
                FormEntity formEntity = applicationForm.getForm();
                if (formEntity != null) {
                    List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class);
                    contentResponseBeans.forEach(contentResponseBean -> {
                        if ("fileupload".equals(contentResponseBean.getName()) && contentResponseBean.getId().equals(fieldResponse.getId())) {
                            String label = null;
                            if (contentResponseBean.getSettings() != null) {
                                for (SettingResponseBean setting : contentResponseBean.getSettings()) {
                                    if ("label".equals(setting.getName())) {
                                        label = setting.getValue() != null ? setting.getValue().toString() : label;
                                        break;
                                    }
                                }
                            }
                            fieldResponse.setLabel(label);

                            Optional<ApplicationFormFieldEntity> optionalFormField =
                                    applicationFormFieldRepository.findByFieldIdAndApplicationFormIdAndApplicationFormApplicationId(
                                    fieldResponse.getId(), applicationForm.getId(), applicationId);

                            if (optionalFormField.isPresent() && optionalFormField.get().getFieldValue() != null) {
                                String[] documentIds = optionalFormField.get().getFieldValue().split(",");
                                List<DocumentResponseBean> documentResponseBeans = new ArrayList<>();

                                for (String docId : documentIds) {
                                    Long documentId = Long.valueOf(docId.trim());
                                    documentRepository.findByIdAndNotDeleted(documentId).ifPresent(documentEntity -> {
                                        DocumentResponseBean responseBean = new DocumentResponseBean();
                                        responseBean.setId(documentEntity.getId());
                                        responseBean.setName(documentEntity.getFileName());
                                        responseBean.setType(DocumentTypeEnum.valueOf(documentEntity.getType()));
                                        responseBean.setSource(DocumentSourceTypeEnum.valueOf(documentEntity.getSource()));
                                        responseBean.setSourceId(documentEntity.getSourceId());
                                        responseBean.setFilePath(documentEntity.getFilePath());
                                        responseBean.setCreatedDate(documentEntity.getCreatedDate());
                                        responseBean.setUpdatedDate(documentEntity.getUpdatedDate());
                                        documentResponseBeans.add(responseBean);
                                    });
                                }

                                fieldResponse.setFileDetail(documentResponseBeans);
                            }

                            // Mark this field ID as processed to prevent duplicates
                            processedFieldIds.add(fieldResponse.getId());
                        }
                    });
                }
            });
        });

        response.setFiles(fieldResponses);
    }

    private void setApplicationDetails(ApplicationEvaluationResponse response, Long applicationId, UserEntity user) {

        ApplicationEntity application = applicationService.validateApplication(applicationId);
        userService.validateUser(application.getUserId());
        String firstName = user.getFirstName() != null ? user.getFirstName() : "";
        String lastName = user.getLastName() != null ? user.getLastName() : "";

        String beneficiary = String.join(" ", firstName, lastName).trim();
        response.setBeneficiary(beneficiary);

        response.setCallName(application.getCall().getName() != null ? application.getCall().getName() : null);
        response.setProtocolNumber(application.getProtocol() != null ? application.getProtocol().getProtocolNumber() : null);
        response.setSubmissionDate(application.getSubmissionDate() != null ? application.getSubmissionDate() : null);
        response.setEvaluationDate(application.getSubmissionDate() != null ? application.getSubmissionDate().plusDays(30) : null);

    }

    List<CriteriaResponse> getCriteriaResponse(Long applicationId) {

        CallEntity call = callRepository.findCallEntityByApplicationId(applicationId);
        List<EvaluationCriteriaEntity> evaluationCriterias = evaluationCriteriaRepository.findByCallId(call.getId());

        List<CriteriaResponse> criteriaResponses = evaluationCriterias.stream().map(criteria -> {
            CriteriaResponse response = new CriteriaResponse();
            response.setId(criteria.getId());
            response.setLabel(criteria.getLookupData().getValue());
            response.setScore(null);
            response.setMaxScore(criteria.getScore());
            response.setValid(null);

            List<CriteriaFormFieldEntity> criteriaFormFields = criteriaFormFieldRepository.findByEvaluationCriteriaIdAndIsDeletedFalse(criteria.getId());

            List<CriteriaMappedField> mappedFields = new ArrayList<>();
            Set<String> processedFormFieldIds = new HashSet<>();

            for (CriteriaFormFieldEntity criteriaFormField : criteriaFormFields) {
                if (processedFormFieldIds.contains(criteriaFormField.getFormFieldId())) {
                    continue;
                }

                CriteriaMappedField mappedField = new CriteriaMappedField();
                mappedField.setId(criteriaFormField.getFormFieldId());

                FormEntity formEntity = formRepository.findById(criteriaFormField.getFormId()).orElse(null);
                if (formEntity != null) {
                    List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class);
                    contentResponseBeans.stream().filter(bean -> bean.getId().equals(criteriaFormField.getFormFieldId())).findFirst().ifPresent(contentResponseBean -> {
                        String label = contentResponseBean.getLabel();
                        if (contentResponseBean.getSettings() != null) {
                            for (SettingResponseBean setting : contentResponseBean.getSettings()) {
                                if ("label".equals(setting.getName())) {
                                    label = setting.getValue() != null ? setting.getValue().toString() : label;
                                    break;
                                }
                            }
                        }
                        mappedField.setFieldLabel(label);
                    });
                }

                applicationFormRepository.findByApplicationId(applicationId).stream().flatMap(
                        applicationForm -> applicationFormFieldRepository.findByFieldIdAndApplicationFormIdAndApplicationFormApplicationId(criteriaFormField.getFormFieldId(),
                                applicationForm.getId(), applicationId).stream()).findFirst().ifPresent(formField -> mappedField.setFieldValue(formField.getFieldValue()));

                mappedFields.add(mappedField);
                processedFormFieldIds.add(criteriaFormField.getFormFieldId());
            }

            response.setCriteriaMappedFields(mappedFields);
            return response;
        }).collect(Collectors.toList());

        return criteriaResponses;
    }

    List<ChecklistResponse> getChecklistResponse(Long applicationId) {

        CallEntity call = callRepository.findCallEntityByApplicationId(applicationId);
        List<CallTargetAudienceChecklistEntity> checklistEntities = callTargetAudienceChecklistRepository.findByCallId(call.getId());
        List<ChecklistResponse> checklistResponses = checklistEntities.stream().map(checklist -> {
            ChecklistResponse response = new ChecklistResponse();
            response.setId(checklist.getId());
            response.setLabel(checklist.getLookupData().getValue());
            response.setValid(null);

            return response;
        }).collect(Collectors.toList());

        return checklistResponses;
    }

    public List<FieldResponse> getFieldResponses(Long applicationId) {

        List<ApplicationFormEntity> applicationFormEntities = applicationFormRepository.findByApplicationId(applicationId);
        List<FieldResponse> fieldResponses = new ArrayList<>();

        for (ApplicationFormEntity applicationForm : applicationFormEntities) {
            FormEntity formEntity = applicationForm.getForm();

            if (formEntity != null) {
                List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class);

                for (ContentResponseBean contentResponseBean : contentResponseBeans) {
                    if ("fileupload".equals(contentResponseBean.getName())) {
                        String fieldId = contentResponseBean.getId();
                        Long applicationFormId = applicationForm.getId();

                        Optional<ApplicationFormFieldEntity> optionalFormField = applicationFormFieldRepository.findByFieldIdAndApplicationFormIdAndApplicationFormApplicationId(
                                fieldId, applicationFormId, applicationId);

                        if (optionalFormField.isPresent()) {
                            ApplicationFormFieldEntity formField = optionalFormField.get();

                            if (formField.getFieldValue() != null) {
                                FieldResponse fieldResponse = new FieldResponse();
                                fieldResponse.setId(fieldId);
                                String label = null;
                                if (contentResponseBean.getSettings() != null) {
                                    for (SettingResponseBean setting : contentResponseBean.getSettings()) {
                                        if ("label".equals(setting.getName())) {
                                            label = setting.getValue() != null ? setting.getValue().toString() : label;
                                            break;
                                        }
                                    }
                                }
                                fieldResponse.setLabel(label);
                                fieldResponse.setValid(null);
                                String[] documentIds = formField.getFieldValue().split(",");
                                List<DocumentResponseBean> documentResponseBeans = new ArrayList<>();

                                for (String docId : documentIds) {
                                    Long documentId = Long.valueOf(docId.trim());
                                    documentRepository.findByIdAndNotDeleted(documentId).ifPresent(documentEntity -> {
                                        DocumentResponseBean responseBean = new DocumentResponseBean();
                                        responseBean.setId(documentEntity.getId());
                                        responseBean.setName(documentEntity.getFileName());
                                        responseBean.setType(DocumentTypeEnum.valueOf(documentEntity.getType()));
                                        responseBean.setSource(DocumentSourceTypeEnum.valueOf(documentEntity.getSource()));
                                        responseBean.setSourceId(documentEntity.getSourceId());
                                        responseBean.setFilePath(documentEntity.getFilePath());
                                        responseBean.setCreatedDate(documentEntity.getCreatedDate());
                                        responseBean.setUpdatedDate(documentEntity.getUpdatedDate());
                                        documentResponseBeans.add(responseBean);
                                    });
                                }

                                fieldResponse.setFileDetail(documentResponseBeans);

                                // Now add fieldResponse to the list
                                fieldResponses.add(fieldResponse);
                            }
                        }
                    }
                }
            }
        }
        return fieldResponses;
    }

    public void deleteById(Long id) {

        ApplicationEvaluationEntity applicationEvaluationEntity = validateApplicationEvaluation(id);
        applicationEvaluationEntity.setIsDeleted(true);
        saveApplicationEvaluationEntity(applicationEvaluationEntity);
    }

    public ApplicationEvaluationEntity saveApplicationEvaluationEntity(ApplicationEvaluationEntity applicationEvaluationEntityData) {

        return applicationEvaluationRepository.save(applicationEvaluationEntityData);
    }

    public ApplicationEvaluationResponse updateApplicationEvaluationStatus(ApplicationEntity application, AssignedApplicationsEntity assignedApplicationsEntity,
            ApplicationStatusForEvaluation newStatus) {

        Optional<ApplicationEvaluationEntity> existingEntityOptional = applicationEvaluationRepository.findByAssignedApplicationsEntity_IdAndIsDeletedFalse(
                assignedApplicationsEntity.getId());
        ApplicationEvaluationEntity entity;


        if (existingEntityOptional.isPresent()) {
            ApplicationEvaluationEntity existingEntity = existingEntityOptional.get();
            application.setStatus(newStatus.getValue());
            application = applicationRepository.save(application);
            String statusType = application.getStatus();
            if (application.getStatus().equals(ApplicationStatusTypeEnum.APPROVED.getValue()) || application.getStatus().equals(ApplicationStatusTypeEnum.REJECTED.getValue())) {
                existingEntity.setStatus(ApplicationEvaluationStatusTypeEnum.CLOSE.getValue());
                assignedApplicationsEntity.setStatus(AssignedApplicationEnum.CLOSE.getValue());
            }
            entity = applicationEvaluationRepository.save(existingEntity);
            assignedApplicationsRepository.save(assignedApplicationsEntity);

            ApplicationAmendmentRequestEntity amendmentRequest = applicationAmendmentRequestRepository.findByApplicationEvaluationIdAndIsDeletedFalse(entity.getId());
            if (Boolean.TRUE.equals(statusType.equals((ApplicationStatusTypeEnum.APPROVED.getValue())))) {
                emailNotificationDao.sendAdmissibilityNotificationEmailForApprovedApplication(amendmentRequest);
            }
            if (Boolean.TRUE.equals(statusType.equals((ApplicationStatusTypeEnum.REJECTED.getValue())))) {
                emailNotificationDao.sendInadmissibilityEmailForRejectedApplication(amendmentRequest);
            }
            return convertToResponse(entity);
        }
        return null;
    }
}