// java
package com.billpaymentservice.bbps.serviceImpl;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.billpaymentservice.bbps.dto.GeneralResp;
import com.billpaymentservice.bbps.dto.MasterApiResponse;
import com.billpaymentservice.bbps.dto.ResponseModel;
import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
import com.billpaymentservice.bbps.dto.request.ContactMasterRequest;
import com.billpaymentservice.bbps.dto.request.CustomParamRequest;
import com.billpaymentservice.bbps.dto.request.DispositionRequest;
import com.billpaymentservice.bbps.dto.request.MasterCategoryRequest;
import com.billpaymentservice.bbps.dto.request.MasterRequest;
import com.billpaymentservice.bbps.dto.request.PlanRequest;
import com.billpaymentservice.bbps.dto.response.AmountOptionsResponse;
import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
import com.billpaymentservice.bbps.dto.response.BillerResponse;
import com.billpaymentservice.bbps.dto.response.ChannelsListResponse;
import com.billpaymentservice.bbps.dto.response.CustomParamResp;
import com.billpaymentservice.bbps.dto.response.CustomerParamGroupsResponse;
import com.billpaymentservice.bbps.dto.response.DispositionResponse;
import com.billpaymentservice.bbps.dto.response.PlanResponse;
import com.billpaymentservice.bbps.dto.response.PlaneCategoriesResponse;
import com.billpaymentservice.bbps.entites.BharatConnectMaster;
import com.billpaymentservice.bbps.entites.BillerDetails;
import com.billpaymentservice.bbps.entites.DispositionDetails;
import com.billpaymentservice.bbps.entites.InboundTraceLog;
import com.billpaymentservice.bbps.entites.OutboundTraceLog;
import com.billpaymentservice.bbps.exception.CustomException;
import com.billpaymentservice.bbps.repository.BharatConnectMasterRepository;
import com.billpaymentservice.bbps.repository.BillerDataRepository;
import com.billpaymentservice.bbps.repository.DispositionRepository;
import com.billpaymentservice.bbps.repository.InboundTraceLogRepository;
import com.billpaymentservice.bbps.repository.MerchantRepository;
import com.billpaymentservice.bbps.repository.OutboundTraceLogRepository;
import com.billpaymentservice.bbps.service.MasterDataService;
import com.billpaymentservice.bbps.util.BBPSConstant;
import com.billpaymentservice.bbps.util.EntityRelationshipUtil;
import com.billpaymentservice.bbps.util.Helper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

@Service
public class MasterDataServiceImpl implements MasterDataService {

	private static final Logger LOGGER = LoggerFactory.getLogger(MasterDataServiceImpl.class);

	@Value("${master.data.url}")
	private String masterRegisterUrl;
	private final BharatConnectMasterRepository beneficiaryDetailsRepository;

	private MerchantRepository merchantRegisterRepo;
	private HttpClientApi httpClientApi;
	private final DispositionRepository dispositionRepository;
	private final Helper helper;
	private final BillerDataRepository billerDataRespository;
	private static final Logger log = LoggerFactory.getLogger(MasterDataServiceImpl.class);
	private final HttpService httpService;
	private final ObjectMapper objectMapper = new ObjectMapper();
	private final InboundTraceLogRepository inboundTraceLogRepository;
	private final OutboundTraceLogRepository outboundTraceLogRepository;

	public MasterDataServiceImpl(MerchantRepository merchantRegisterRepo, HttpService httpService,
			HttpClientApi httpClientApi, Helper helper, BillerDataRepository billerDataRespository,
			DispositionRepository dispositionRepository, BharatConnectMasterRepository beneficiaryDetailsRepository,
			InboundTraceLogRepository inboundTraceLogRepository,
			OutboundTraceLogRepository outboundTraceLogRepository) {
		this.merchantRegisterRepo = merchantRegisterRepo;
		this.httpService = httpService;
		this.httpClientApi = httpClientApi;
		this.helper = helper;
		this.billerDataRespository = billerDataRespository;
		this.dispositionRepository = dispositionRepository;
		this.beneficiaryDetailsRepository = beneficiaryDetailsRepository;
		this.inboundTraceLogRepository = inboundTraceLogRepository;
		this.outboundTraceLogRepository = outboundTraceLogRepository;

	}

	@Override
	public ResponseModel getMasterData(MasterRequest masterRequest) {
		LOGGER.info("Request DTO: {}", masterRequest);

		String txnID = helper.generateTxnId(15);
		String apiName = "GetMasterData";
		String requestId = masterRequest.getReqId();
		String requestJson = helper.convertObjectToJson(masterRequest);
     
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, masterRequest.getMid(), "POST",
				requestJson);
         
		try {
			// Merchant Validation
			helper.validateMerchant(masterRequest.getMid());

//			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
//				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
//				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
//			}

			// check Tender Id is present DB
			BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
			log.info("Response -: " + headersData);
			if (headersData == null) {
				helper.updateInboundLogFailure(inboundLog, "Tenant Id Is Null", "NOT_FOUND");
				return new ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST, headersData);
			}

			// get full url
			String fullUrl = masterRegisterUrl + BBPSConstant.MASTER_CATEGORY_URL + headersData.getTenantId();
			LOGGER.info("Calling external API: {}", fullUrl);

			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> responseMap = httpService.getRequest(fullUrl);
			String responseData = responseMap.get("data");
			LOGGER.info("Response Data: {}", responseData);

			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode
						String.valueOf(dataMap.get("remarks")) // remarks
				);
			}

			MasterApiResponse responseWrapper = objectMapper.convertValue(dataMap, MasterApiResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;

		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException ex) {
			LOGGER.warn("Merchant validation failed: {}", ex.getMessage());
			return ex.getResponseModel(); // Directly return ResponseModel from exception
		}
	}

	@Override
	public ResponseModel getBillerByBillerId(BillerDetailRequest billerDetailRequest) {
		
		helper.validateMerchant(billerDetailRequest.getMid());
		String txnID = helper.generateTxnId(15);
		String apiName = "GetBillerByBillerId";
		String requestId = billerDetailRequest.getReqId();
		String billerId = billerDetailRequest.getBillerId();
		String fullUrl = masterRegisterUrl + BBPSConstant.BILLER_DATA_FETCH_URL + billerId;

		String requestJson = helper.convertObjectToJson(billerDetailRequest);
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, billerDetailRequest.getMid(), "POST",
				requestJson);

		OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

		Map<String, String> responseMap = httpService.getRequest(fullUrl);
		String responseData = responseMap.get("data");
		log.info("data is :{}", responseData);

		helper.updateOutboundLogResponse(outboundLog, responseData);

		try {
			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), String.valueOf(dataMap.get("status")),
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
						String.valueOf(dataMap.get("remarks")));
			}

			BillerDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillerDataResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ModelMapper mapper = new ModelMapper();
			mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
			BillerDetails entity = mapper.map(responseWrapper.getBillerDAO(), BillerDetails.class);
			EntityRelationshipUtil.linkBillerRelationships(entity);
			helper.saveOrUpdateBillerData(entity);

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;
		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		}

	}

	@Override
	public ResponseModel getCustomerParamByBillerId(CustomParamRequest customerParamRequest) {

		String txnID = helper.generateTxnId(15);
		String apiName = "GetCustomerParamByBillerId";
		String requestId = customerParamRequest.getReqId();
		String requestJson = helper.convertObjectToJson(customerParamRequest);
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, customerParamRequest.getMid(), "POST",
				requestJson);

		try {
			helper.validateMerchant(customerParamRequest.getMid());

//			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
//				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
//				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
//			}

			String billerId = customerParamRequest.getBillerId();
			String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMPARAM_URL + billerId;

			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> responseMap = httpService.getRequest(fullUrl);
			String responseData = responseMap.get("data");
			log.info("data is :{}", responseData);

			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});
			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
						String.valueOf(dataMap.get("remarks")));
			}

			CustomParamResp responseWrapper = objectMapper.convertValue(dataMap, CustomParamResp.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;
		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException ex) {
			LOGGER.warn("Merchant validation failed: {}", ex.getMessage());
			return ex.getResponseModel(); // Directly return ResponseModel from exception
		}

	}

	@Override
	public ResponseModel getContactMaster(ContactMasterRequest contactMasterRequest) {

		return new ResponseModel();
	}

	@Override
	public ResponseModel fetchMasterDataCategoryWise(MasterCategoryRequest masterRequest) {
		LOGGER.info("Fetching Master Data Category-wise " + masterRequest);

		String txnID = helper.generateTxnId(15);
		String apiName = "FetchMasterDataCategoryWise";
		String requestId = masterRequest.getReqId();
		String requestJson = helper.convertObjectToJson(masterRequest);
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, masterRequest.getMid(), "POST",
				requestJson);

		try {
			helper.validateMerchant(masterRequest.getMid());

			String fullUrl = String.format("%s%s?billerName=%s&category=%s&page=%d&pagesize=%d", masterRegisterUrl,
					BBPSConstant.BILLER_URL, masterRequest.getBillerName(), masterRequest.getCategory(),
					masterRequest.getPageStart(), masterRequest.getPageEnd());

			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> responseMap = httpService.getRequest(fullUrl);
			String responseData = responseMap.get("data");
			LOGGER.info("Response Data: {}", responseData);

			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode
						String.valueOf(dataMap.get("remarks")) // remarks
				);
			}

			BillerResponse responseWrapper = objectMapper.convertValue(dataMap, BillerResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;
		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException ex) {
			LOGGER.warn("Merchant validation failed: {}", ex.getMessage());
			return ex.getResponseModel(); // Directly return ResponseModel from exception
		}
	}

	@Override
	public ResponseModel getDispositionDetails(DispositionRequest dispositionDetailRequest) {
		String txnID = helper.generateTxnId(15);
		String apiName = "GetDispositionDetails";
		String requestId = dispositionDetailRequest.getReqId();
		;
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, dispositionDetailRequest.getMid(),
				"GET", "N/A");

		String fullUrl = masterRegisterUrl + BBPSConstant.DISPOSTION_URL;
		OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
		Map<String, String> responseMap = httpService.getRequest(fullUrl);
		String responseData = responseMap.get("data");

		helper.updateOutboundLogResponse(outboundLog, responseData);
		try {

			ObjectMapper objectMapper = new ObjectMapper();

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});
			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
						String.valueOf(dataMap.get("remarks")));
			}

			DispositionResponse responseWrapper = objectMapper.convertValue(dataMap, DispositionResponse.class);
			System.out.println(responseWrapper);
			GeneralResp generalResp = responseWrapper.getGeneralResp();
			ModelMapper mapper = new ModelMapper();
			mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
			List<DispositionDetails> entities = responseWrapper.getDispositionsList().stream()
					.map(dto -> mapper.map(dto, DispositionDetails.class)).collect(Collectors.toList());

			System.out.println(entities);

			if (entities != null) {
				dispositionRepository.saveAll(entities);
			} else {
				LOGGER.warn("No disposition found in response to save.");
			}

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;
		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException ex) {
			LOGGER.warn("Merchant validation failed: {}", ex.getMessage());
			return ex.getResponseModel(); // Directly return ResponseModel from exception
		}
	}

	@Override
	public ResponseModel fetchCustomerParamGroup(BillerDetailRequest requestModel) {
		LOGGER.info("Fetching Master Data Category-wise for MID={}", requestModel.getMid());

		String txnID = helper.generateTxnId(15);
		String apiName = "FetchCustomerParamGroup";
		String requestId = requestModel.getReqId();
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, requestModel.getMid(), "POST",
				helper.convertObjectToJson(requestModel));

		try {
			helper.validateMerchant(requestModel.getMid());

			String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMER_PARAM_GROUP + requestModel.getBillerId();
			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
			String responseData = apiResponse.get("data").toString();
			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
						String.valueOf(dataMap.get("remarks")));
			}

			CustomerParamGroupsResponse responseWrapper = objectMapper.convertValue(dataMap,
					CustomerParamGroupsResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;

		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException ex) {
			LOGGER.warn("Merchant validation failed: {}", ex.getMessage());
			return ex.getResponseModel(); // Directly return ResponseModel from exception
		}

	}

	@Override
	public ResponseModel fetchAllMasterAmountOption(BillerDetailRequest requestModel) {
		LOGGER.info("Fetching Master Data Amount List for MID={}", requestModel.getMid());

		String txnID = helper.generateTxnId(15);
		String apiName = "FetchAllMasterAmountOption";
		String requestId = requestModel.getReqId();
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, requestModel.getMid(), "POST",
				helper.convertObjectToJson(requestModel));

		try {
			helper.validateMerchant(requestModel.getMid());

			String fullUrl = masterRegisterUrl + BBPSConstant.AMOUNT_OPTIONS + requestModel.getBillerId();
			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
			log.info("Response" + apiResponse);
			String responseData = apiResponse.get("data").toString();

			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
						String.valueOf(dataMap.get("remarks")));
			}

			AmountOptionsResponse responseWrapper = objectMapper.convertValue(dataMap, AmountOptionsResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;

		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException e) {
			LOGGER.error("Custom Exception: {}", e.getMessage());
			throw e; // Rethrow custom exceptions to be handled by the controller
		}

	}

	@Override
	public ResponseModel fetchPlanCategorie(BillerDetailRequest requestModel) {
		LOGGER.info("Fetching Master Data Amount List for MID={}", requestModel.getMid());

		String txnID = helper.generateTxnId(15);
		String apiName = "FetchPlanCategorie";
		String requestId = requestModel.getReqId();
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, requestModel.getMid(), "POST",
				helper.convertObjectToJson(requestModel));

		try {
			helper.validateMerchant(requestModel.getMid());

			String fullUrl = masterRegisterUrl + BBPSConstant.PLAN_CATEGORIES + requestModel.getBillerId();
			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
			log.info("Response" + apiResponse);
			String responseData = apiResponse.get("data").toString();

			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
						String.valueOf(dataMap.get("remarks")));
			}

			PlaneCategoriesResponse responseWrapper = objectMapper.convertValue(dataMap, PlaneCategoriesResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;

		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException e) {
			LOGGER.error("Custom Exception: {}", e.getMessage());
			throw e; // Rethrow custom exceptions to be handled by the controller
		}
	}

	@Override
	public ResponseModel fetchInitiatingChannel(BillerDetailRequest requestModel) {
		LOGGER.info("Fetching Initiating Channel List for MID={}", requestModel.getMid());

		String txnID = helper.generateTxnId(15);
		String apiName = "FetchInitiatingChannel";
		String requestId = requestModel.getReqId();
		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, requestModel.getMid(), "POST",
				helper.convertObjectToJson(requestModel));

		try {
			helper.validateMerchant(requestModel.getMid());

			String fullUrl = masterRegisterUrl + BBPSConstant.INITIATING_CHANNEL;
			LOGGER.info("Calling Master API: {}", fullUrl);

			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);

			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
			log.info("Response" + apiResponse);
			String responseData = apiResponse.get("data").toString();

			helper.updateOutboundLogResponse(outboundLog, responseData);

			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});

			if (!dataMap.containsKey("generalResp")) {
				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
				throw new CustomException(String.valueOf(dataMap.get("message")), // message
						String.valueOf(dataMap.get("status")), // status
						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
						String.valueOf(dataMap.get("remarks")));
			}

			ChannelsListResponse responseWrapper = objectMapper.convertValue(dataMap, ChannelsListResponse.class);
			GeneralResp generalResp = responseWrapper.getGenericResp();

			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);

			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());

			return responseModel;

		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		} catch (CustomException e) {
			LOGGER.error("Custom Exception: {}", e.getMessage());
			throw e; // Rethrow custom exceptions to be handled by the controller
		}
	}

	public ResponseModel fetchPlanByCategories(PlanRequest requestModel) {
	    LOGGER.info("Fetching Initiating Fetch Plan Category By Biller Id for MID={}", requestModel.getMid());

	    String txnID = helper.generateTxnId(15);
	    String apiName = "FetchPlanByCategories";
	    String requestId = requestModel.getReqId();

	    helper.validateMerchant(requestModel.getMid());

	    String url = String.format("%s%s?billerId=%s%s%s%s&page=%d&pagesize=%d",
	            masterRegisterUrl,
	            BBPSConstant.PLANS_URL,
	            requestModel.getBillerId(),
	            requestModel.getCategory() != null ? "&category=" + requestModel.getCategory() : "",
	            requestModel.getAmountInRupees() != null ? "&amountInRupees=" + requestModel.getAmountInRupees() : "",
	            requestModel.getCircle() != null ? "&circle=" + requestModel.getCircle() : "",
	            requestModel.getPage(),
	            requestModel.getPagesize()
	    );

	    LOGGER.info("Calling Master API: {}", url);

	    // Convert request to JSON and create inbound & outbound logs
	    String requestJson = helper.convertObjectToJson(requestModel);
	    InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, requestModel.getMid(), "POST", requestJson);
	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, url, "GET", null);

	    try {
	        Map<String, String> apiResponse = httpService.getRequest(url);
	        String responseData = apiResponse.get("data");
	        log.info("Response Data: {}", responseData);

	        // Update outbound log with response
	        helper.updateOutboundLogResponse(outboundLog, responseData);

	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});

	        if (!dataMap.containsKey("generalResp")) {
	            // Failure response
	        	helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
	            throw new CustomException(
	                    String.valueOf(dataMap.get("message")),
	                    String.valueOf(dataMap.get("status")),
	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
	                    String.valueOf(dataMap.get("remarks"))
	            );
	        }

	        // Success response
	        PlanResponse responseWrapper = objectMapper.convertValue(dataMap, PlanResponse.class);
	        GeneralResp generalResp = responseWrapper.getGeneralResp();

	        ResponseModel responseModel = new ResponseModel(
	                generalResp.getMessage(),
	                generalResp.getStatus(),
	                Integer.parseInt(generalResp.getStatusCode()),
	                responseWrapper
	        );

	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
	        return responseModel;

	    } catch (JsonProcessingException e) {
	        log.error("Error parsing responseData JSON: {}", e.getMessage());
	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
	        throw new CustomException("Invalid JSON received from API");
	    } catch (CustomException e) {
	    	
	        LOGGER.error("Custom Exception: {}", e.getMessage());
	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "Custom_exception");
	        throw e; // Rethrow for controller-level handling
	    } 
	}

}