package net.gepafin.tendermanagement.dao;

import jakarta.servlet.http.HttpServletRequest;
import net.gepafin.tendermanagement.entities.LookUpDataEntity;
import net.gepafin.tendermanagement.entities.LookUpDataEntity.LookUpDataTypeEnum;
import net.gepafin.tendermanagement.enums.VersionActionTypeEnum;
import net.gepafin.tendermanagement.model.request.LookUpDataReq;
import net.gepafin.tendermanagement.model.request.LookUpDataRequest;
import net.gepafin.tendermanagement.model.request.VersionHistoryRequest;
import net.gepafin.tendermanagement.model.response.LookUpDataResponseBean;
import net.gepafin.tendermanagement.repositories.LookUpDataRepository;
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.ResourceNotFoundException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
import net.gepafin.tendermanagement.config.Translator;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

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

@Component
public class LookUpDataDao {

    @Autowired
    private LookUpDataRepository lookUpDataRepository;

    @Autowired
    HttpServletRequest request;

    @Autowired
    LoggingUtil loggingUtil;

    public LookUpDataResponseBean createLookUpData(LookUpDataRequest lookUpDataReq) {
        LookUpDataEntity entity = convertLookUpDataReqToLookUpDataEntity(lookUpDataReq);
        return convertLookUpDataEntityToResponseBean(entity);
    }
    private LookUpDataEntity convertLookUpDataReqToLookUpDataEntity(LookUpDataRequest lookUpDataReq) {
        LookUpDataEntity entity = new LookUpDataEntity();
        entity.setTitle(lookUpDataReq.getTitle());
        entity.setType(lookUpDataReq.getType().getValue());
        entity.setValue(lookUpDataReq.getValue());
        entity.setValue(lookUpDataReq.getResponse());
        validateLookUpDataEntity(entity);
        lookUpDataRepository.save(entity);

        /** This code is responsible for adding a version history log for the "Create LoopUpData" operation. **/
        loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request).actionType(VersionActionTypeEnum.INSERT).oldData(null).newData(entity).build());
        return entity;
    }
    
    public void validateLookUpDataEntity(LookUpDataEntity entity) {
        if (entity.getValue() == null || entity.getValue().trim().isEmpty()) {
            throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.VALUE_CANNOT_BE_EMPTY));
        }
    }
    
    public LookUpDataEntity validateLookUpData(Long id) {
    	return lookUpDataRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.LOOKUP_DATA_NOT_FOUND)));
    }

    public LookUpDataResponseBean getLookUpDataById(Long id) {
    	return convertLookUpDataEntityToResponseBean(validateLookUpData(id));
    }

    public LookUpDataResponseBean updateLookUpData(Long id, LookUpDataRequest lookUpDataReq) {
        LookUpDataEntity entity = validateLookUpData(id);
        LookUpDataEntity oldLookUpData = Utils.getClonedEntityForData(entity);

        setIfUpdated(entity::getTitle, entity::setTitle, lookUpDataReq.getTitle());
        setIfUpdated(entity::getValue, entity::setValue, lookUpDataReq.getValue());
        setIfUpdated(entity::getResponse, entity::setResponse, lookUpDataReq.getResponse());
        lookUpDataRepository.save(entity);

        /** This code is responsible for adding a version history log for the "Update LookUpData" operation. **/
        loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request).actionType(VersionActionTypeEnum.UPDATE).oldData(oldLookUpData).newData(entity).build());


        return convertLookUpDataEntityToResponseBean(entity);
    }

    public void deleteLookUpData(Long id) {
        LookUpDataEntity oldLookUpData = validateLookUpData(id);

        /** This code is responsible for adding a version history log for the "Delete LookUpData" operation. **/
        loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request).actionType(VersionActionTypeEnum.DELETE).oldData(oldLookUpData).build());

        lookUpDataRepository.deleteById(id);
    }

    private LookUpDataResponseBean convertLookUpDataEntityToResponseBean(LookUpDataEntity entity) {
        LookUpDataResponseBean response = new LookUpDataResponseBean();
        response.setId(entity.getId());
        response.setTitle(entity.getTitle());
        response.setType(LookUpDataEntity.LookUpDataTypeEnum.valueOf(entity.getType()));
        response.setValue(entity.getValue());
        response.setResponse(entity.getResponse());
        response.setCreatedDate(entity.getCreatedDate());
        response.setUpdatedDate(entity.getUpdatedDate());
        return response;
    }

    public List<LookUpDataResponseBean> getLookUpDataByTypes(List<LookUpDataTypeEnum> types) {
        return types.stream()
                .flatMap(type -> lookUpDataRepository.findByType(type.getValue()).stream())
                .map(this::convertLookUpDataEntityToResponseBean)
                .collect(Collectors.toList());
    }

    public LookUpDataEntity getOrCreateLookUpDataEntity(LookUpDataReq req, LookUpDataEntity.LookUpDataTypeEnum type) {

        if (req.getLookUpDataId() == null || req.getLookUpDataId().equals(0L)) {
            LookUpDataEntity newEntity = new LookUpDataEntity();
            newEntity.setTitle(req.getTitle());
            newEntity.setValue(req.getValue());
            newEntity.setResponse(req.getResponse());
            newEntity.setType(type.getValue());
            validateLookUpDataEntity(newEntity);
            LookUpDataEntity lookUpDataEntity = lookUpDataRepository.save(newEntity);
            
            /** This code is responsible for adding a version history log for the "create or update lookup data" operation **/
    		loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request).actionType(VersionActionTypeEnum.INSERT).oldData(null).newData(lookUpDataEntity).build());
            return lookUpDataEntity;
        }

		return lookUpDataRepository.findById(req.getLookUpDataId())
				.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
						Translator.toLocale(GepafinConstant.LOOK_UP_DATA_NOT_VALID_MSG)));
	}


}