package net.gepafin.tendermanagement.dao;

import net.gepafin.tendermanagement.config.Translator;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.CallEntity;
import net.gepafin.tendermanagement.entities.FlowDataEntity;
import net.gepafin.tendermanagement.entities.FlowEdgesEntity;
import net.gepafin.tendermanagement.enums.CallStatusEnum;
import net.gepafin.tendermanagement.enums.VersionActionTypeEnum;
import net.gepafin.tendermanagement.model.request.FlowDataRequestBean;
import net.gepafin.tendermanagement.model.request.FlowEdgesRequestBean;
import net.gepafin.tendermanagement.model.request.FlowRequestBean;
import net.gepafin.tendermanagement.model.request.VersionHistoryRequest;
import net.gepafin.tendermanagement.model.response.FlowDataResponseBean;
import net.gepafin.tendermanagement.model.response.FlowEdgesResponseBean;
import net.gepafin.tendermanagement.model.response.FlowResponseBean;
import net.gepafin.tendermanagement.repositories.CallRepository;
import net.gepafin.tendermanagement.repositories.FlowDataRepository;
import net.gepafin.tendermanagement.repositories.FlowEdgesRepository;
import net.gepafin.tendermanagement.service.CallService;
import net.gepafin.tendermanagement.service.FormService;
import net.gepafin.tendermanagement.util.DateTimeUtil;
import net.gepafin.tendermanagement.util.FieldValidator;
import net.gepafin.tendermanagement.util.LoggingUtil;
import net.gepafin.tendermanagement.util.Utils;
import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.itextpdf.text.pdf.PdfStructTreeController.returnType;

import jakarta.servlet.http.HttpServletRequest;

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

@Component
public class FlowDao {

    @Autowired
    private FlowDataRepository flowDataRepository;

    @Autowired
    private FlowEdgesRepository flowEdgesRepository;

    @Autowired
    private CallRepository callRepository;

    @Autowired
    private CallService callService;

    @Autowired
    private FormService formService;

    @Autowired
    private LoggingUtil loggingUtil;
    
    @Autowired
	private HttpServletRequest request;

    public FlowResponseBean createOrUpdateFlow(FlowRequestBean flowRequestBean, Long callId) {
        validateFlowRequestBean(flowRequestBean);
        CallEntity call = callService.validateCall(callId);
        checkIfFlowExits(call);
        call= setInitialAndFinalFormInCall(flowRequestBean, call);
        validateFlowRequest(flowRequestBean);
        List<FlowDataEntity> flowDataEntities = createFlowData(flowRequestBean,call);
        List<FlowEdgesEntity> flowEdgesEntities = createFlowEdges(flowRequestBean,call);
        FlowResponseBean flowResponseBean = getFlowByCallId(call.getId());
        return flowResponseBean;
    }

    public void validateFlowRequestBean(FlowRequestBean flowRequestBean){
        if (FieldValidator.isNullOrZero(flowRequestBean.getInitialForm()) || FieldValidator.isNullOrZero(flowRequestBean.getFinalForm())) {
            throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.INITAL_AND_FINAL_FORM_CANNOT_NULL));
        }

        if (flowRequestBean.getFlowEdges() == null || flowRequestBean.getFlowEdges().isEmpty()) {
            throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.FLOW_REQUEST_NOT_PROPER));
        }
    }

    public void checkIfFlowExits(CallEntity call) {
//        callDao.validateUpdate(call);
        List<FlowDataEntity> flowDataEntities = flowDataRepository.findByCallId(call.getId());
        List<FlowEdgesEntity> flowEdgesEntities = flowEdgesRepository.findByCallId(call.getId());
        if (Boolean.FALSE.equals(flowDataEntities.isEmpty())  || Boolean.FALSE.equals(flowEdgesEntities.isEmpty())) {
			if (call.getInitialForm() != null || call.getInitialForm() != null) {
				CallEntity oldCallEntity = Utils.getClonedEntityForData(call);
				call.setInitialForm(null);
				call.setFinalForm(null);
				call = callRepository.save(call);

				/**
				 * This code is responsible for adding a version history log for the "update
				 * call for flow" operation.
				 **/
				loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request)
						.actionType(VersionActionTypeEnum.UPDATE).oldData(oldCallEntity).newData(call).build());

			}
            flowDataRepository.deleteAll(flowDataEntities);
            flowEdgesRepository.deleteAll(flowEdgesEntities);
            
            flowDataEntities.forEach(data->{
            	/**
    			 * This code is responsible for adding a version history log for the "update
    			 * call for flow" operation.
    			 **/
    			loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request)
    					.actionType(VersionActionTypeEnum.DELETE).oldData(data).newData(null).build());
            });
            
            flowEdgesEntities.forEach(data->{
            	/**
    			 * This code is responsible for adding a version history log for the "update
    			 * call for flow" operation.
    			 **/
    			loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request)
    					.actionType(VersionActionTypeEnum.DELETE).oldData(data).newData(null).build());
    			
            });
			
			
        }
    }

    public void validateFlowRequest(FlowRequestBean flowRequestBean) {
        formService.validateForm(flowRequestBean.getInitialForm());
        formService.validateForm(flowRequestBean.getFinalForm());
        if(flowRequestBean.getFlowData()!=null && !flowRequestBean.getFlowData().isEmpty()) {
            flowRequestBean.getFlowData().forEach(flowData -> formService.validateForm(flowData.getFormId()));
        }
    }

    private List<FlowEdgesResponseBean> createFlowEdgesResponseBean(List<FlowEdgesEntity> flowEdgesEntities) {
        List<FlowEdgesResponseBean> flowEdgesResponseBeans = flowEdgesEntities.stream()
                .map(this::convertFlowEdgesEntityToFlowEdgesResponseBean).collect(Collectors.toList());
        return flowEdgesResponseBeans;
    }

    private List<FlowDataResponseBean> createFlowDataResponseBean(List<FlowDataEntity> flowDataEntities) {
        List<FlowDataResponseBean> flowDataResponseBeans = flowDataEntities.stream()
                .map(this::convertFlowDataEntityToFlowDataResponseBean).collect(Collectors.toList());
        return flowDataResponseBeans;
    }

    public FlowResponseBean setInitialAndFinalFormInFlowResponseBean(FlowResponseBean flowResponseBean, CallEntity call) {
        flowResponseBean.setInitialForm(call.getInitialForm());
        flowResponseBean.setFinalForm(call.getFinalForm());
        return flowResponseBean;
    }

	private CallEntity setInitialAndFinalFormInCall(FlowRequestBean flowRequestBean, CallEntity call) {

		CallEntity oldCallEntity = Utils.getClonedEntityForData(call);
		call.setInitialForm(flowRequestBean.getInitialForm());
		call.setFinalForm(flowRequestBean.getFinalForm());
		call.setUpdatedDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
		call = callRepository.save(call);

		/**
		 * This code is responsible for adding a version history log for the "update
		 * call for flow" operation.
		 **/
		loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request)
				.actionType(VersionActionTypeEnum.UPDATE).oldData(oldCallEntity).newData(call).build());
		return call;
	}

    public List<FlowDataEntity> createFlowData(FlowRequestBean flowRequestBean, CallEntity call) {
        if (flowRequestBean.getFlowData() != null || !flowRequestBean.getFlowEdges().isEmpty()) {
            List<FlowDataEntity> flowDataEntities = flowRequestBean.getFlowData().stream()
                    .map(flowDataRequestBean -> createFlowDataEntity(flowDataRequestBean, call))
                    .collect(Collectors.toList());
            flowDataEntities =  flowDataRepository.saveAll(flowDataEntities);
            flowDataEntities.forEach(data->{
            	
            	/**
    			 * This code is responsible for adding a version history log for the "delete flow data" operation.
    			 **/
    			loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request)
    					.actionType(VersionActionTypeEnum.INSERT).oldData(null).newData(data).build());
            });
            return flowDataEntities;
        }
        return null;
    }

    public FlowDataEntity createFlowDataEntity(FlowDataRequestBean flowDataRequestBean,CallEntity call) {
        FlowDataEntity flowDataEntity = new FlowDataEntity();
        flowDataEntity.setFormId(flowDataRequestBean.getFormId());
        if(Boolean.FALSE.equals(flowDataRequestBean.getChosenField().isEmpty()) || flowDataRequestBean.getChosenField()!=null){
        flowDataEntity.setChoosenField(flowDataRequestBean.getChosenField());
        }
        if(Boolean.FALSE.equals(flowDataRequestBean.getChosenValue().isEmpty()) || flowDataRequestBean.getChosenValue()!=null) {
            flowDataEntity.setChoosenValue(flowDataRequestBean.getChosenValue());
        }
            flowDataEntity.setCallId(call.getId());
        return flowDataEntity;
    }

    public List<FlowEdgesEntity> createFlowEdges(FlowRequestBean flowRequestBean, CallEntity call) {
        List<FlowEdgesEntity> flowEdgesEntities = flowRequestBean.getFlowEdges().stream()
                .map(flowEdgesRequestBean -> createFlowEdgesEntity(flowEdgesRequestBean, call))
                .collect(Collectors.toList());
        flowEdgesEntities = flowEdgesRepository.saveAll(flowEdgesEntities);
        flowEdgesEntities.forEach(data->{
        	/**
			 * This code is responsible for adding a version history log for the "update
			 * call for flow" operation.
			 **/
			loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request)
					.actionType(VersionActionTypeEnum.INSERT).oldData(null).newData(data).build());
        });
         return flowEdgesEntities;
    }

    public FlowEdgesEntity createFlowEdgesEntity(FlowEdgesRequestBean flowEdgesRequestBean,CallEntity call) {
        FlowEdgesEntity flowEdgesEntity = new FlowEdgesEntity();
        flowEdgesEntity.setTrackingId(flowEdgesRequestBean.getId());
        flowEdgesEntity.setSourceId(Long.valueOf(flowEdgesRequestBean.getSource()));
        flowEdgesEntity.setTargetId(Long.valueOf(flowEdgesRequestBean.getTarget()));
        flowEdgesEntity.setType(flowEdgesRequestBean.getType());
        flowEdgesEntity.setCallId(call.getId());
        return flowEdgesEntity;
    }

    public FlowDataResponseBean convertFlowDataEntityToFlowDataResponseBean(FlowDataEntity flowDataEntity) {
        FlowDataResponseBean flowDataResponseBean = new FlowDataResponseBean();
        flowDataResponseBean.setId(flowDataEntity.getId());
        flowDataResponseBean.setFormId(flowDataEntity.getFormId());
        flowDataResponseBean.setChosenField(flowDataEntity.getChoosenField());
        flowDataResponseBean.setChosenValue(flowDataEntity.getChoosenValue());
        return flowDataResponseBean;
    }

    public FlowEdgesResponseBean convertFlowEdgesEntityToFlowEdgesResponseBean(FlowEdgesEntity flowEdgesEntity) {
        FlowEdgesResponseBean flowEdgesResponseBean = new FlowEdgesResponseBean();
        flowEdgesResponseBean.setId(flowEdgesEntity.getTrackingId());
        flowEdgesResponseBean.setType(flowEdgesEntity.getType());
        flowEdgesResponseBean.setSource(String.valueOf(flowEdgesEntity.getSourceId()));
        flowEdgesResponseBean.setTarget(String.valueOf(flowEdgesEntity.getTargetId()));
        return flowEdgesResponseBean;
    }

    public FlowResponseBean getFlowByCallId(Long callId){
        CallEntity call= callService.validateCall(callId);
        FlowResponseBean flowResponseBean=new FlowResponseBean();
        List<FlowDataEntity> flowDataEntities=flowDataRepository.findByCallId(call.getId());
        List<FlowEdgesEntity> flowEdgesEntities=flowEdgesRepository.findByCallId(call.getId());
        List<FlowDataResponseBean> flowDataResponseBeans=createFlowDataResponseBean(flowDataEntities);
        List<FlowEdgesResponseBean> flowEdgesResponseBeans=createFlowEdgesResponseBean(flowEdgesEntities);
        flowResponseBean.setFlowData(flowDataResponseBeans);
        flowResponseBean.setFlowEdges(flowEdgesResponseBeans);
        if( flowResponseBean.getFlowEdges().isEmpty()){
            return null;
        }
        flowResponseBean.setCallId(call.getId());
        flowResponseBean.setCallStatus(CallStatusEnum.valueOf(call.getStatus()));
        flowResponseBean.setInitialForm(call.getInitialForm());
        flowResponseBean.setFinalForm(call.getFinalForm());
        return flowResponseBean;
    }

}