package com.billpaymentservice.bbps.serviceImpl;

import java.util.ArrayList;
import java.util.HashMap;
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.DispositionsDTO;
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.MasterRequest;
import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
import com.billpaymentservice.bbps.dto.response.BillerResponse;
import com.billpaymentservice.bbps.dto.response.CategoryResponse;
import com.billpaymentservice.bbps.dto.response.ContactMasterResponse;
import com.billpaymentservice.bbps.dto.response.CustomParamResp;
import com.billpaymentservice.bbps.dto.response.DispositionResponse;
import com.billpaymentservice.bbps.entites.AmountOption;
import com.billpaymentservice.bbps.entites.BBPSMerchantValidation;
import com.billpaymentservice.bbps.entites.BillPayment;
import com.billpaymentservice.bbps.entites.BillerDetails;
import com.billpaymentservice.bbps.entites.BillerResponseParams;
import com.billpaymentservice.bbps.entites.DispositionDetails;
import com.billpaymentservice.bbps.entites.InterchangeFee;
import com.billpaymentservice.bbps.entites.InterchangeFeeDetail;
import com.billpaymentservice.bbps.exception.AppException;
import com.billpaymentservice.bbps.exception.CustomException;
import com.billpaymentservice.bbps.repository.BillerDataRepository;
import com.billpaymentservice.bbps.repository.DispositionRepository;
import com.billpaymentservice.bbps.repository.MerchantRepository;
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;

import jakarta.servlet.http.HttpServletRequest;

@Service
public class MasterDataServiceImpl implements MasterDataService {

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

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

	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();
	
	// Inject HttpService
	public MasterDataServiceImpl(MerchantRepository merchantRegisterRepo,
            HttpService httpService,
            HttpClientApi httpClientApi,
            Helper helper,
            BillerDataRepository billerDataRespository,
            DispositionRepository dispositionRepository
           ) {
            this.merchantRegisterRepo = merchantRegisterRepo;
            this.httpService = httpService;
            this.httpClientApi = httpClientApi;
            this.helper = helper;
            this.billerDataRespository=billerDataRespository;
            this.dispositionRepository=dispositionRepository;
          
             
                                               }
	@Override
	public ResponseModel getBillerByBillerId(BillerDetailRequest billerDetailRequest) {
	    
	    String billerId = billerDetailRequest.getBillerId();
	    String fullUrl = masterRegisterUrl + BBPSConstant.BILLER_DATA_FETCH_URL+billerId;

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

	    ObjectMapper objectMapper = new ObjectMapper();

	    try {
	        Map<String, Object> dataMap = objectMapper.readValue(responseData,
	                new TypeReference<Map<String, Object>>() {
	                });
	        if (!dataMap.containsKey("generalResp")) {
	            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")) );
	        }
	        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);
	       // billerDataRespository.save(entity);
	        ResponseModel responseModel = new ResponseModel( 
	            generalResp.getMessage(),
	            generalResp.getStatus(),
	            Integer.parseInt(generalResp.getStatusCode()),
	            responseWrapper
	        );
	        return responseModel;

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

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

	    String fullUrl = masterRegisterUrl + BBPSConstant.MASTER_CATEGORY_URL + masterRequest.getTenantId();
	    LOGGER.info("Calling external API: {}", fullUrl);

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

	    ObjectMapper objectMapper = new ObjectMapper();

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

	        // ✅ Same check as in getBillerByBillerId()
	        if (!dataMap.containsKey("generalResp")) {
	            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
	        );
	        return responseModel;

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


	@Override
	public ResponseModel fetchMasterDataCategoryWise(MerchantRequestModel requestModel,
			String category, int pageStart, int pageEnd) {
		LOGGER.info("Fetching Master Data Category-wise for MID={}, Category={}, PageStart={}, PageEnd={}",
				requestModel.getMid(), category, pageStart, pageEnd);

		BBPSMerchantValidation merchantValidation = merchantRegisterRepo.findByMid(requestModel.getMid());
		BillerResponse responseModel = new BillerResponse();
		// if Start merchant validations
		if (Optional.ofNullable(merchantValidation).isPresent()) {
			// if Start merchant active check
			if (merchantValidation.isActive()) {

				LOGGER.info("mid Value: " + requestModel.getMid() + " secret Value: " + requestModel.getSecretKey()
						+ "txt Value: " + requestModel);
				// 2️⃣ Build API URL
				String fullUrl = String.format("%s%s?category=%s&page=%d&pagesize=%d", masterRegisterUrl,
						BBPSConstant.BILLER_URL, category, pageStart, pageEnd);

				LOGGER.info("Calling Master API: {}", fullUrl);
				HashMap<String, Object> response = httpClientApi.getRequestForPaymentStatus(fullUrl);

				LOGGER.info("BBPS bank response data: " + response.get("data") + " code: " + response.get("respCode"));
				// if Start merchant cehck response code

				if (response.get("respCode") != null && response.get("respCode").toString().contains("200")) {
					LOGGER.info("Response -: " + response.get("data"));
					String jsonData = response.get("data").toString();
					//responseModel = responseParser.billerResponse(jsonData);

					LOGGER.info("kkk" + responseModel.toString());
					// 5️⃣ Prepare API response model

				} else {
					LOGGER.warn("Unexpected response code: " + response.get("respCode"));

				}

			} else {
				LOGGER.info("Merchant Not Active for mid - " + requestModel.getMid());
				throw new AppException("Merchant Not Active", BBPSConstant.CODE_MERCHANT_INACTIVE);
			}
		} else {
			LOGGER.info("Merchant Not Valid for mid - " + requestModel.getMid());
			throw new AppException("Merchant Not Valid", BBPSConstant.CODE_MERCHANT_INVALID);
		}
		 return new ResponseModel();

	}

	@Override
	public ResponseModel getCustomerParamByBillerId(CustomParamRequest customerParamRequest) {
		String billerId = customerParamRequest.getBillerId();
	   String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMPARAM_URL+billerId;


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

		ObjectMapper objectMapper = new ObjectMapper();

		try {
			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});
			if (!dataMap.containsKey("generalResp")) {
				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);
			
			return responseModel;
		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			throw new CustomException("Invalid JSON received from API");
		}
		
	}

	@Override
	public ResponseModel getContactMaster(ContactMasterRequest contactMasterRequest) {
		
		return new ResponseModel();
	}
	@Override
	public ResponseModel getDispositionDetails() {
		String fullUrl=masterRegisterUrl+BBPSConstant.DISPOSTION_URL;
		Map<String, String> responseMap = httpService.getRequest(fullUrl);
		String responseData = responseMap.get("data");
		
		ObjectMapper objectMapper = new ObjectMapper();

		try {
			Map<String, Object> dataMap = objectMapper.readValue(responseData,
					new TypeReference<Map<String, Object>>() {
					});
			if (!dataMap.containsKey("generalResp")) {
				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);
			
			return responseModel;
		} catch (JsonProcessingException e) {
			log.error("Error parsing responseData JSON: {}", e.getMessage());
			throw new CustomException("Invalid JSON received from API");
		}
				
	}
}