/*
 * ============LICENSE_START=======================================================
 * Ran Simulator Controller
 * ================================================================================
 * Copyright (C) 2020-2021 Wipro Limited.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */

package org.onap.ransim.rest.api.services;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.log4j.Logger;
import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import org.onap.ransim.rest.api.models.GNBCUCPFunction;
import org.onap.ransim.rest.api.models.GNBCUUPFunction;
import org.onap.ransim.rest.api.models.GNBDUFunction;
import org.onap.ransim.rest.api.models.NRCellCU;
import org.onap.ransim.rest.api.models.NRCellDU;
import org.onap.ransim.rest.api.models.NSSAIConfig;
import org.onap.ransim.rest.api.models.NearRTRIC;
import org.onap.ransim.rest.api.models.PLMNInfo;
import org.onap.ransim.rest.api.models.RANSliceInfo;
import org.onap.ransim.rest.api.models.RRMPolicyRatio;
import org.onap.ransim.rest.api.models.SliceProfile;
import org.onap.ransim.rest.api.models.TACells;
import org.onap.ransim.rest.api.repository.GNBCUCPRepository;
import org.onap.ransim.rest.api.repository.GNBCUUPRepository;
import org.onap.ransim.rest.api.repository.GNBDURepository;
import org.onap.ransim.rest.api.repository.NRCellCURepository;
import org.onap.ransim.rest.api.repository.NearRTRICRepository;
import org.onap.ransim.rest.api.repository.RANInventoryRepository;
import org.onap.ransim.rest.api.repository.RRMPolicyRepository;
import org.onap.ransim.rest.api.repository.TACellRepository;
import org.onap.ransim.rest.web.mapper.GNBCUCPModel;
import org.onap.ransim.rest.web.mapper.GNBCUUPModel;
import org.onap.ransim.rest.web.mapper.GNBDUModel;
import org.onap.ransim.rest.web.mapper.NRCellCUModel;
import org.onap.ransim.rest.web.mapper.NRCellDUModel;
import org.onap.ransim.rest.web.mapper.NearRTRICModel;
import org.onap.ransim.rest.web.mapper.RANSliceInfoModel;
import org.onap.ransim.rest.web.mapper.RRMPolicyRatioModel;

@Service
public class RANSliceConfigService {
        private static Logger logger = Logger.getLogger(RANSliceConfigService.class.getName());
	@Autowired
	private NRCellCURepository nRCellCURepository;
	
	@Autowired
	private GNBCUCPRepository gNBCUCPRepository;
	
	@Autowired
	private GNBCUUPRepository gNBCUUPRepository;
	
	@Autowired
	private GNBDURepository gNBDURepository;
	
	@Autowired
	private NearRTRICRepository nearRTRICRepository;
	
	@Autowired
	private RRMPolicyRepository rRMPolicyRepository;
	
	@Autowired
	private RANInventoryRepository ranInventoryRepo;
	
	@Autowired
	private TACellRepository tACellRepository;
	
	private ModelMapper modelMapper = new ModelMapper();
	
	/**
	 * To store/update the NRCEllCU details
	 * 
	 * @param nRCellCUModel
	 * @return NRCellCUModel
	 */
	public NRCellCUModel saveNRcellCU(NRCellCUModel nRCellCUModel) {
		logger.debug("Request received to save NRcellCU: id::"+ nRCellCUModel.getCellLocalId());
		 NRCellCU cellCUEntity = new NRCellCU();
		 modelMapper.map(nRCellCUModel, cellCUEntity);
		 if(!cellCUEntity.getpLMNInfoList().isEmpty()) {
			for(PLMNInfo plmn:cellCUEntity.getpLMNInfoList()) {
				//plmn.setnRCellCU(cellCUEntity);
			}
		 }
		NRCellCU cellCUEntityResponse = nRCellCURepository.save(cellCUEntity); 
		modelMapper.map(cellCUEntityResponse,nRCellCUModel);
		return nRCellCUModel;
	}
	
	/**
	 * To fetch the NRCellCU details
	 * 
	 * @param cellLocalId
	 * @return NRCellCUModel
	 */
	public NRCellCUModel fetchNRCellCUDetails(Integer cellLocalId) {
		logger.debug("Request received to fetchNRCellCUDetails: id::"+ cellLocalId);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		NRCellCU cellCUEntity = nRCellCURepository.findById(cellLocalId).isPresent()?nRCellCURepository.findById(cellLocalId).get():null;
		NRCellCUModel nRCellCUModel = new NRCellCUModel();
		modelMapper.map(cellCUEntity,nRCellCUModel);
		return nRCellCUModel;
	}
	
	/**
	 * To store the slice / config details of GNBCUCPFunction
	 * @param gNBCUCPModel
	 * @return
	 */
	public GNBCUCPModel saveGNBCUCP(GNBCUCPModel gNBCUCPModel) {
		logger.debug("Request received to save GNBCUCPModel: id::"+ gNBCUCPModel.getgNBCUName());
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		GNBCUCPFunction gNBCUCPFunction=new GNBCUCPFunction();  NearRTRIC nearRTRICRef  = new NearRTRIC();
		try {
		modelMapper.map(gNBCUCPModel, gNBCUCPFunction);
		if(gNBCUCPModel.getNearRTRICId()!=null && nearRTRICRepository.findById(gNBCUCPModel.getNearRTRICId()).isPresent()) {
			gNBCUCPFunction.setNearRTRIC(nearRTRICRepository.findById(gNBCUCPModel.getNearRTRICId()).get());
		}
		if(gNBCUCPFunction!=null && !gNBCUCPFunction.getCellCUList().isEmpty()) {
			gNBCUCPFunction.getCellCUList().forEach(cellCU->{
				cellCU.setgNBCUCPFunction(gNBCUCPFunction);
			});
		}
		GNBCUCPFunction gNBCUCPEntity = gNBCUCPRepository.save(gNBCUCPFunction);
		modelMapper.map(gNBCUCPEntity,gNBCUCPModel);
		}catch(Exception e) {
			logger.debug("Error occured during saveGNBCUCP"+e.getMessage());
			return null;
		}
		return gNBCUCPModel;
	}
	
	/**
	 * To fetch the gNBCUCP details
	 * 
	 * @param cucpName
	 * @return GNBCUCPModel
	 */
	public GNBCUCPModel fetchGNBCUCPData(String cucpName) {
		logger.debug("Request received to fetch GNBCUCPFunction: name::"+ cucpName);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		GNBCUCPFunction gNBCUCPEntity = gNBCUCPRepository.findById(cucpName).isPresent()?gNBCUCPRepository.findById(cucpName).get():null;
		GNBCUCPModel gNBCUCPModel = new GNBCUCPModel();
		modelMapper.map(gNBCUCPEntity,gNBCUCPModel);
		return gNBCUCPModel;
	}
	
	/**
	 * To store the slice / config details of GNBCUCPFunction
	 * @param gNBCUCPModel
	 * @return
	 */
	public GNBCUUPModel saveGNBCUUP(GNBCUUPModel gNBCUUPModel) {
		logger.debug("Request received to save GNBCUUPModel: id::"+ gNBCUUPModel.getgNBCUUPId());
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		GNBCUUPFunction gNBCUUPFunction=new GNBCUUPFunction();
		modelMapper.map(gNBCUUPModel, gNBCUUPFunction);
		if(gNBCUUPModel.getNearRTRICId()!=null && nearRTRICRepository.findById(gNBCUUPModel.getNearRTRICId()).isPresent()) {
			gNBCUUPFunction.setNearRTRIC(nearRTRICRepository.findById(gNBCUUPModel.getNearRTRICId()).get());
		}
		if(gNBCUUPFunction!=null && !gNBCUUPFunction.getpLMNInfoList().isEmpty()) {
			gNBCUUPFunction.getpLMNInfoList().forEach(plmn->{
				//plmn.setgNBCUUPFunction(gNBCUUPFunction);
			});
		}
		GNBCUUPFunction gNBCUUPEntity = gNBCUUPRepository.save(gNBCUUPFunction);
		modelMapper.map(gNBCUUPEntity,gNBCUUPModel);
		return gNBCUUPModel;
	}
	
	/**
	 * To fetch the gNBCUUP details
	 * 
	 * @param cucpName
	 * @return GNBCUUPModel
	 */
	public GNBCUUPModel fetchGNBCUUPData(Integer gNBCUUPId) {
		logger.debug("Request received to fetch GNBCUUPFunction: id::"+ gNBCUUPId);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		GNBCUUPFunction gNBCUUPEntity = gNBCUUPRepository.findById(gNBCUUPId).isPresent()?gNBCUUPRepository.findById(gNBCUUPId).get():null;
		GNBCUUPModel gNBCUUPModel = new GNBCUUPModel();
		modelMapper.map(gNBCUUPEntity,gNBCUUPModel);
		return gNBCUUPModel;
	}
	
	/**
	 * To store the slice / config details of GNBDUFunction
	 * @param GNBDUModel
	 * @return
	 */
	public GNBDUModel saveGNBDU(GNBDUModel gNBDUModel) {
		logger.debug("Request received to save GNBDUModel: id::"+ gNBDUModel.getgNBDUId());
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		GNBDUFunction gNBDUFunction=new GNBDUFunction();NearRTRIC nearRTRICRef  = new NearRTRIC();
		modelMapper.map(gNBDUModel, gNBDUFunction);
		if(gNBDUModel.getNearRTRICId()!=null && nearRTRICRepository.findById(gNBDUModel.getNearRTRICId()).isPresent()) {
			nearRTRICRef = nearRTRICRepository.findById(gNBDUModel.getNearRTRICId()).get();
			gNBDUFunction.setNearRTRIC(nearRTRICRef);
		}
		NearRTRIC nearRTRICRefNew = nearRTRICRef;
		nearRTRICRefNew.setNearRTRICId(gNBDUModel.getNearRTRICId());
		if(gNBDUFunction!=null && !gNBDUFunction.getCellDUList().isEmpty()) {
			gNBDUFunction.getCellDUList().forEach(cellDU->{
				cellDU.setgNBDUFunction(gNBDUFunction);
			});
		}
		GNBDUFunction gNBDUEntity = gNBDURepository.save(gNBDUFunction);
		modelMapper.map(gNBDUEntity,gNBDUModel);
		return gNBDUModel;
	}
	
	/**
	 * To fetch the gNBDU details
	 * 
	 * @param gNBDUId
	 * @return GNBDUModel
	 */
	public GNBDUModel fetchGNBDUData(Integer gNBDUId) {
		logger.debug("Request received to fetch GNBDUFunction: id::"+ gNBDUId);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		GNBDUFunction gNBDUEntity = gNBDURepository.findById(gNBDUId).isPresent()?gNBDURepository.findById(gNBDUId).get():null;
		GNBDUModel gNBDUModel = new GNBDUModel();
		modelMapper.map(gNBDUEntity,gNBDUModel);
		return gNBDUModel;
	}
	
	/**
	 * Stored NearRTRIC
	 * 
	 * @param nearRTRIC
	 * @return
	 */
	public NearRTRICModel saveNearRTRIC(NearRTRICModel nearRTRIC) {
		logger.debug("Request received to store NearRTRIC: id::"+ nearRTRIC.getNearRTRICId());
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		NearRTRIC nearRTRICEntity = new NearRTRIC();
		modelMapper.map(nearRTRIC, nearRTRICEntity);		
		NearRTRIC nearRTRICEntityEResponse = nearRTRICRepository.save(nearRTRICEntity);
		modelMapper.map(nearRTRICEntityEResponse,nearRTRIC);
		return nearRTRIC;
	}
	
	/**
	 * To fetch the nearRTRIC details
	 * 
	 * @param nearRTRICId
	 * @return NearRTRICModel
	 */
	public NearRTRICModel fetchNearRTRICData(Integer nearRTRICId) {
		logger.debug("Request received to fetch GNBDUFunction: id::"+ nearRTRICId);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		NearRTRIC nearRTRICEntity = nearRTRICRepository.findById(nearRTRICId).isPresent()?nearRTRICRepository.findById(nearRTRICId).get():null;
		NearRTRICModel nearRTRICModel = new NearRTRICModel();
		modelMapper.map(nearRTRICEntity,nearRTRICModel);
		return nearRTRICModel;
	}
	
	/**
	 * To retrieve the RRMPolicy of a network function
	 * 
	 * @param resourceType
	 * @param resourceID
	 * @return
	 */
	public RRMPolicyRatioModel fetchRRMPolicyOfNE(String resourceType, String resourceID) {
		logger.debug("Request received to fetch RRMPolicy:"+ resourceType+"--"+resourceID);
			modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
			RRMPolicyRatioModel rrmPolicyResponse = new RRMPolicyRatioModel();
			RRMPolicyRatio rrmPolicyEntity = rRMPolicyRepository.findByResourceTypeAndId(resourceType, resourceID);
			modelMapper.map(rrmPolicyEntity, rrmPolicyResponse);
			return rrmPolicyResponse;
		}
	
	/**
	 * To update RRM policy of NF
	 * 
	 * @param rrmPolicy
	 * @return
	 */
	public RRMPolicyRatioModel updateRRMPolicy(RRMPolicyRatioModel rrmPolicy) {
		logger.debug("Request received to update RRMPolicy:"+ rrmPolicy.getRrmPolicyID());
		RRMPolicyRatio rrmPolicyEntity = new RRMPolicyRatio();
		modelMapper.map(rrmPolicy, rrmPolicyEntity);
		rrmPolicyEntity = rRMPolicyRepository.save(rrmPolicyEntity);
		modelMapper.map(rrmPolicyEntity, rrmPolicy);
		return rrmPolicy;
	}
	
	/**
	 * @param trackingArea
	 * @return List<NearRTRICModel>
	 */
	public List<NearRTRICModel> findRICsInTA(String trackingArea) {
		logger.debug("Request received to find the NearRTRICs in Tracking Area::"+ trackingArea);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<NearRTRIC> nearRTRICsList = nearRTRICRepository.getListOfRICsInTrackingArea(trackingArea);
		List<NearRTRICModel> ricModelList = nearRTRICsList.stream()
				.map(ricEntity -> modelMapper.map(ricEntity, NearRTRICModel.class)).collect(Collectors.toList());
		return ricModelList;
	}
	
	/**
	 * @param cellsList
	 * @return
	 */
	public List<NearRTRICModel> findNearRTRICofCells(List<Integer> cellsList){
		List<NearRTRIC> ricEntitiesList =  new ArrayList<>();
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<String> cucpNames = gNBCUCPRepository.findCUCPByCellIds(cellsList);
		cucpNames.forEach(cucpName -> {
			List<NearRTRIC> ricEntities = new ArrayList<>();
			ricEntities = nearRTRICRepository.findNearRTRICByCUCPName(cucpName);
			ricEntitiesList.addAll(ricEntities);
		});
		List<NearRTRICModel> ricModelList = ricEntitiesList.stream()
				.map(ricEntity -> modelMapper.map(ricEntity, NearRTRICModel.class)).collect(Collectors.toList());
		return ricModelList;
	}
	
	
	/**
	 * To update the RAN Slice details
	 * 
	 * @param rANSliceInfoModel
	 * @return RANSliceInfoModel
	 */
	public RANSliceInfoModel updateRANInventory(RANSliceInfoModel rANSliceInfoModel) {
		logger.debug("Request received to update inventory for id::"+ rANSliceInfoModel.getRanNFNSSIId());
		RANSliceInfo rANSliceInfoEntity = new RANSliceInfo();
		modelMapper.map(rANSliceInfoModel, rANSliceInfoEntity);
		if(ranInventoryRepo.findById(rANSliceInfoModel.getRanNFNSSIId()).isPresent()) {
			RANSliceInfo ranInfo = ranInventoryRepo.findById(rANSliceInfoModel.getRanNFNSSIId()).get();
			List<String> ranNSSIList = ranInfo.getRanNSSIList();
			ranNSSIList.addAll(rANSliceInfoEntity.getRanNSSIList());
			rANSliceInfoEntity.setRanNSSIList(ranNSSIList);
			
			List<String> nSSAIList = ranInfo.getnSSAIList();
			nSSAIList.addAll(rANSliceInfoEntity.getnSSAIList());
			rANSliceInfoEntity.setnSSAIList(nSSAIList);
			
			List<SliceProfile> sliceProfilesList = ranInfo.getSliceProfilesList();
			sliceProfilesList.addAll(rANSliceInfoEntity.getSliceProfilesList());
			rANSliceInfoEntity.setSliceProfilesList(sliceProfilesList);
		}
		else {
		if(!rANSliceInfoEntity.getSliceProfilesList().isEmpty()) {
			for(SliceProfile profile:rANSliceInfoEntity.getSliceProfilesList()) {
				profile.setrANSliceInventory(rANSliceInfoEntity);
			}
		 }
		}
		rANSliceInfoEntity = ranInventoryRepo.save(rANSliceInfoEntity);
		modelMapper.map(rANSliceInfoEntity, rANSliceInfoModel);
		return rANSliceInfoModel;
	}
	
	/**
	 * @param ranNFNSSIId
	 * @return RANSliceInfoModel
	 */
	public RANSliceInfoModel fetchRANSlice(String ranNFNSSIId) {
		logger.debug("Request received to read inventory details for id::"+ ranNFNSSIId);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		RANSliceInfo ranSliceInfo = ranInventoryRepo.findById(ranNFNSSIId).isPresent()?ranInventoryRepo.findById(ranNFNSSIId).get():null;
		RANSliceInfoModel rANSliceInfoModel = new RANSliceInfoModel();
		modelMapper.map(ranSliceInfo, rANSliceInfoModel);
		return rANSliceInfoModel;
	}
	
	/**
	 * @param trackingArea
	 * @return List<String>
	 */
	public List<String> fetchCellsofTA(String trackingArea) {
		logger.debug("Request recieved to fetch the cell details of TA:"+ trackingArea);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		String cells =  tACellRepository.findById(trackingArea).isPresent()?tACellRepository.findById(trackingArea).get().getCellsList():null;
		return cells!=null? Arrays.asList(cells.split(",")):null;
		
	}
	
	public Iterable<TACells> fetchAllTA()
	{
	  logger.info("Request recieved to fetch all TA:"); 
	  return tACellRepository.findAll();
	}
	
	/**
	 * @param nearRTRICId
	 * @return List<NRCellCUModel>
	 */
	public List<NRCellCUModel> fetchCUCellsofRIC(Integer nearRTRICId) {
		logger.debug("Request recieved to fetch the cell (CU) details of nearRTRICId:"+ nearRTRICId);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<NRCellCU> cellCUEntities = new ArrayList<NRCellCU>();
		NearRTRIC nearRTRIC = nearRTRICRepository.findById(nearRTRICId).isPresent()?nearRTRICRepository.findById(nearRTRICId).get():null;
		if(nearRTRIC!=null) {
		List<GNBCUCPFunction> cucpFunctions = nearRTRIC.getgNBCUCPList();
		cucpFunctions.forEach(cucpFunction->{
			List<NRCellCU> cellCUList = new ArrayList<NRCellCU>();
			cellCUList.addAll(cucpFunction.getCellCUList());
			cellCUEntities.addAll(cellCUList);
		});
		List<NRCellCUModel> cuCellModels = cellCUEntities.stream()
				.map(cellCUEntity -> modelMapper.map(cellCUEntity, NRCellCUModel.class)).collect(Collectors.toList());
		return cuCellModels;
		}
		return new ArrayList<NRCellCUModel>();
	}
	
	/**
	 * @param trackingArea
	 * @return List<NRCellDUModel>
	 */
	public Map<Integer, List<NRCellDUModel>> fetchDUCellsofRIC(String sNSSAI) {
		logger.debug("Request recieved to fetch the cell (DU) details of sNSSAI:"+ sNSSAI);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		Set<NRCellDU> cellDUEntities = new HashSet<NRCellDU>();Set<NRCellDU> cellDUs = new HashSet<NRCellDU>();
		List<NearRTRICModel> ricModels = findRICsByNSSAI(sNSSAI);
		Map<Integer, List<NRCellDUModel>> cellsMap = new HashMap<Integer, List<NRCellDUModel>>();
		List<NearRTRIC> ricEntities = ricModels.stream()
				.map(ric -> modelMapper.map(ric, NearRTRIC.class)).collect(Collectors.toList());
		ricEntities.forEach(ricEntity -> {
			List<GNBDUFunction> duFunctions = ricEntity.getgNBDUList();
			duFunctions.forEach(duFunction -> {
				List<NRCellDU> cellDUList =duFunction.getCellDUList();
				cellDUList.forEach(cellDU->{
					List<PLMNInfo> plmnList = cellDU.getpLMNInfoList();
					plmnList.forEach(plmn->{
						if(sNSSAI.equalsIgnoreCase(plmn.getsNSSAI().getsNSSAI())){
							cellDUs.add(cellDU);
						}
					});
				});
				//cellDUList.addAll(duFunction.getCellDUList());
				cellDUEntities.addAll(cellDUs);
			});
			List<NRCellDUModel> duCellModels = cellDUEntities.stream()
					.map(cellDUEntity -> modelMapper.map(cellDUEntity, NRCellDUModel.class)).collect(Collectors.toList());
			cellsMap.put(ricEntity.getNearRTRICId(), duCellModels);
		});
		
		return cellsMap;
	}
	
	/**
	 * @param ranNFNSSIID
	 * @return List<NearRTRICModel>
	 */
	public List<NearRTRICModel> findNearRTRICByNSSI(String ranNFNSSIID) {
		logger.debug("Request recieved to fetch nearRTRIC of NSSI:"+ ranNFNSSIID);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<NearRTRIC> nearRTRICEntities = nearRTRICRepository.findNearRTRICByNSSI(ranNFNSSIID);
		List<NearRTRICModel> nearRTRICModels = nearRTRICEntities.stream()
				.map(nearRTRICEntity -> modelMapper.map(nearRTRICEntity, NearRTRICModel.class)).collect(Collectors.toList());
		return nearRTRICModels;
	}
	
	/**
	 * @param sNSSAI
	 * @return List<NearRTRICModel>
	 */
	public List<NearRTRICModel> findRICsByNSSAI(String sNSSAI){
		logger.debug("Request recieved to fetch nearRTRIC of NSSAI:"+ sNSSAI);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		Set<NearRTRIC> nearRTRICEntities = nearRTRICRepository.findNearRTRICByNSSAI(sNSSAI);
		List<NearRTRICModel> nearRTRICModels = nearRTRICEntities.stream()
				.map(nearRTRICEntity -> modelMapper.map(nearRTRICEntity, NearRTRICModel.class))
				.collect(Collectors.toList());
		return nearRTRICModels;
	}
	
	/**
	 * @param sNSSAI
	 * @return config Details
	 */
	public Map<String,Integer> findSliceProfileconfig(String sNSSAI){
		logger.debug("Request recieved to fetch Config requested for a slice:"+ sNSSAI);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		Map<String,Integer> configDetails = new HashMap<String, Integer>();
		String ranNFNSSIId = ranInventoryRepo.findRANNFNSSIofNSSAI(sNSSAI);
		RANSliceInfo rANSliceInfo = ranInventoryRepo.findById(ranNFNSSIId).isPresent()? ranInventoryRepo.findById(ranNFNSSIId).get():null;
		if(rANSliceInfo.getSliceProfilesList().size()>0) {
			rANSliceInfo.getSliceProfilesList().forEach(sliceProfile->{
				if(sNSSAI.equalsIgnoreCase(sliceProfile.getsNSSAI())){
					//configDetails.put("maxNoOfConns",sliceProfile.getMaxNumberofConns());
					configDetails.put("dLThptPerSlice",sliceProfile.getdLThptPerSlice());
					configDetails.put("uLThptPerSlice",sliceProfile.getuLThptPerSlice());
				}
			});
		}
		return configDetails;
	}
	
	/**
	 * @param sNSSAI
	 * @return RIC Config for a slice
	 */
	public Map<Integer, NSSAIConfig> findSliceConfig(String sNSSAI){
		logger.debug("Request recieved to fetch Slice config Details at RICs:"+ sNSSAI);
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<NearRTRICModel> nearRTRICModels = findRICsByNSSAI(sNSSAI);
		Map<Integer, NSSAIConfig> configMap = new HashMap<Integer, NSSAIConfig>();
		nearRTRICModels.forEach(nearRTRIC->{
			nearRTRIC.getpLMNInfoList().forEach(plmn->{
				if(sNSSAI.equalsIgnoreCase(plmn.getsNSSAI().getsNSSAI())) {
					configMap.put(nearRTRIC.getNearRTRICId(),plmn.getsNSSAI().getConfigData());
				}
			});
		});
		return configMap;
	}
	
	/**
	 * @param sNSSAI
	 * @return List<GNBDUModel>
	 */
	public List<GNBDUModel> findDUsofSNssai(String sNSSAI){
		logger.debug("Request recieved to fetch all DUs of NSSAI");
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<GNBDUFunction> duList = (List<GNBDUFunction>) gNBDURepository.findDUsByNSSAI(sNSSAI);
		List<GNBDUModel> duModels = duList.stream()
				.map(duEntity -> modelMapper.map(duEntity, GNBDUModel.class)).collect(Collectors.toList());
		return duModels;
	}
	
	/**
	 * @param sNSSAI
	 * @return List<GNBCUCPModel>
	 */
	public List<GNBCUCPModel> findCUsofSNssai(String sNSSAI){
		logger.debug("Request recieved to fetch all CUs of NSSAI");
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<GNBCUCPFunction> cuList = (List<GNBCUCPFunction>) gNBCUCPRepository.findCUCPsByNSSAI(sNSSAI);
		List<GNBCUCPModel> cuModels = cuList.stream()
				.map(cuEntity -> modelMapper.map(cuEntity, GNBCUCPModel.class)).collect(Collectors.toList());
		return cuModels;
	}
	
	/**
	 * @param sNSSAI
	 * @return Map<String, String>
	 */
	public Map<String, String> getSubscriberDetails(String sNSSAI){
		logger.debug("Request recieved to fetch SubscriberDetails");
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		Map<String, String> details = new HashMap<String, String>();
		String ranNFNSSIId = ranInventoryRepo.findRANNFNSSIofNSSAI(sNSSAI);
		details.put("ranNFNSSIId", ranNFNSSIId);
		details.put("sNSSAI", sNSSAI);
		RANSliceInfo rANSliceInfo = ranInventoryRepo.findById(ranNFNSSIId).isPresent()? ranInventoryRepo.findById(ranNFNSSIId).get():null;
		if(rANSliceInfo.getSliceProfilesList().size()>0) {
			rANSliceInfo.getSliceProfilesList().forEach(sliceProfile->{
				if(sNSSAI.equalsIgnoreCase(sliceProfile.getsNSSAI())){
					details.put("sliceProfileId",sliceProfile.getSliceProfileId());
				}
			});
		}
		List<NearRTRICModel> nearRTRICModels = findRICsByNSSAI(sNSSAI);
		nearRTRICModels.forEach(nearRTRIC->{
			nearRTRIC.getpLMNInfoList().forEach(plmn->{
				if(sNSSAI.equalsIgnoreCase(plmn.getsNSSAI().getsNSSAI())) {
					details.put("subscriptionServiceType",plmn.getsNSSAI().getSubscriptionServiceType());
					details.put("globalSubscriberId",plmn.getsNSSAI().getGlobalSubscriberId());
				}
			});
		});
		
		return details;
	}
	
	// Data required for PM data Simulation
	/**
	 * @return List<GNBCUCPModel>
	 */
	public List<GNBCUCPModel> findAllCUCPFunctions(){
		logger.debug("Request recieved to fetch all CUCPs");
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<GNBCUCPFunction> cucpsList = (List<GNBCUCPFunction>) gNBCUCPRepository.findAll();
		List<GNBCUCPModel> cucpModels = cucpsList.stream()
				.map(cucpEntity -> modelMapper.map(cucpEntity, GNBCUCPModel.class)).collect(Collectors.toList());
		return cucpModels;
	}
	
	/**
	 * @return List<GNBDUModel>
	 */
	public List<GNBDUModel> findAllDUFunctions(){
		logger.debug("Request recieved to fetch all DUs");
		modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		List<GNBDUFunction> duList = (List<GNBDUFunction>) gNBDURepository.findAll();
		List<GNBDUModel> duModels = duList.stream().map(duEntity -> {
			GNBDUModel gnbDuModel = modelMapper.map(duEntity, GNBDUModel.class);
			gnbDuModel.setNearRTRICId(duEntity.getNearRTRIC().getNearRTRICId());
			return gnbDuModel;
		}).collect(Collectors.toList());
		return duModels;
	}
	
	public List<NearRTRICModel> findAllNearRTRIC()
	{
	    logger.debug("Request received to fetch all NearRTRICModel");
	    modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
	    List<NearRTRIC> rtricList = (List<NearRTRIC>) nearRTRICRepository.findAll();
	    List<NearRTRICModel> rtricmodels = rtricList.stream()
	            .map(rtricEntity -> modelMapper.map(rtricEntity, NearRTRICModel.class)).collect(Collectors.toList());
	    return rtricmodels;
	}
	
}