package com.billpaymentservice.bbps.serviceImpl;

import java.util.Map;

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.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;

import com.billpaymentservice.bbps.dto.GeneralResp;
import com.billpaymentservice.bbps.dto.ResponseModel;
import com.billpaymentservice.bbps.dto.request.ComplaintRequestDTO;
import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
import com.billpaymentservice.bbps.dto.response.ComplaintResponse;
import com.billpaymentservice.bbps.entites.BharatConnectMaster;
import com.billpaymentservice.bbps.entites.BillPayment;
import com.billpaymentservice.bbps.entites.BillerDetails;
import com.billpaymentservice.bbps.entites.ComplaintDetails;
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.ComplainRepository;
import com.billpaymentservice.bbps.service.ComplainService;
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 ComplainServiceImpl implements ComplainService {
	 @Value("${complaint.data.url}")
	 private String complainDataUrl;
	 public static final Logger LOGGER = LoggerFactory.getLogger(ComplainServiceImpl.class);
	 private final Helper helper;
     private final ObjectMapper objectMapper = new ObjectMapper();
     private final BharatConnectMasterRepository beneficiaryDetailsRepository;

	 private final HttpService httpService;
	 private final ComplainRepository complainRepository;
	 
	 public ComplainServiceImpl(Helper helper
			 ,HttpService httpService,
			 BharatConnectMasterRepository beneficiaryDetailsRepository,
			 ComplainRepository complainRepository) {
		 this.helper=helper;
		 this.httpService=httpService;
		 this.beneficiaryDetailsRepository=beneficiaryDetailsRepository;
		 this.complainRepository=complainRepository;
	 }
	 
	@Override
	public ResponseModel addComplain(ComplaintRequestDTO complainRequestDTO) {
         
		LOGGER.info("Initiating addComplain for request ID: {} and MID", complainRequestDTO.getReqId(),
				complainRequestDTO.getMid());
		String apiName = "ADDCOMPLAIN";
		String txnId = helper.generateTxnId(15);
		String requestId = complainRequestDTO.getReqId();
		String fullUrl = complainDataUrl + BBPSConstant.ADD_COMPLAIN_ENDPOINT;
		String requestJson = helper.convertObjectToJson(complainRequestDTO);
		   BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
		    HttpHeaders headers = new HttpHeaders();
		    headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
		    headers.set("agentId", headersData.getAgentId());
		    headers.set("tenantId", headersData.getTenantId());
		    headers.setContentType(MediaType.APPLICATION_JSON);

		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, complainRequestDTO.getMid(),
				"POST", requestJson);

		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, fullUrl, "POST", null);
		LOGGER.info("Calling external API: {}", fullUrl);
		LOGGER.info("Request payload: {}", requestJson);
		Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
		String responseData = responseMap.get("data");
		LOGGER.info("fetched data from api is :{}", responseData);
		helper.updateOutboundLogResponse(outboundLog, responseData);
		try {
			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});
			LOGGER.info("Parsed response data: {}", dataMap);
			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")));
			}
			
			ComplaintResponse responseWrapper = objectMapper.convertValue(dataMap, ComplaintResponse.class);
			GeneralResp generalResp = responseWrapper.getGeneralResp();
			 ModelMapper mapper = new ModelMapper();
		        mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
		        ComplaintDetails entity = mapper.map(responseWrapper.getComplaints(), ComplaintDetails.class);
		        entity.setReqId(complainRequestDTO.getReqId());
		        entity.setTxnId(txnId);
		       complainRepository.save(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) {
			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
			throw new CustomException("Invalid JSON received from API");
		}
		
		
	}

}