bbps-backend/src/main/java/com/billpaymentservice/bbps/serviceImpl/HttpService.java

package com.billpaymentservice.bbps.serviceImpl;


import java.util.HashMap;
import java.net.ConnectException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.RestClient;
import org.springframework.web.client.ResourceAccessException;

import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.AllArgsConstructor;

@Service
@AllArgsConstructor
public class HttpService {
    private static final Logger log = LoggerFactory.getLogger(HttpService.class);
    private final RestClient restClient;
    private final ObjectMapper objectMapper = new ObjectMapper();

    // Helper to produce server-down/timeout style responses
    private HashMap<String, String> buildServerDownResponse(String code, String message, Exception e) {
        HashMap<String, String> response = new HashMap<>();
        response.put("respCode", code);
        response.put("data", message);
        log.error("❌ {} - {}", code, message, e);
        return response;
    }

    

    public HashMap<String, String> postRequest(String url, String payload, HttpHeaders customHeaders) {
        HashMap<String, String> response = new HashMap<>();
        try {
            HttpHeaders headers = new HttpHeaders();
            
            if (customHeaders != null) {
                customHeaders.forEach((key, value) -> {
                    if (!key.equalsIgnoreCase(HttpHeaders.CONTENT_TYPE)) {
                        headers.addAll(key, value);
                    }
                });
            }
            
            headers.setContentType(MediaType.APPLICATION_JSON);
               
            // ✅ MAKE THE REQUEST
            ResponseEntity<String> restResponse = restClient.post()
                    .uri(url)
                    .headers(h -> h.addAll(headers))
                    .body(payload)
                    .retrieve()
                    .toEntity(String.class);

            response.put("respCode", String.valueOf(restResponse.getStatusCode().value()));
            response.put("data", restResponse.getBody());
            
            log.info("✅ HttpService Response Status: {}", restResponse.getStatusCode());

        } catch (HttpClientErrorException.Forbidden e) {
            // ✅ SPECIAL 403 HANDLING
            log.error("🚫 HttpService: 403 FORBIDDEN");
            response.put("respCode", "403");
            response.put("data", "FORBIDDEN - Check credentials in HttpService");
            
        } catch (ResourceAccessException e) {
            // This often wraps timeouts or connection refused
            Throwable cause = e.getCause();
            if (cause instanceof ConnectException) {
                return buildServerDownResponse("503", "Server unavailable - connection refused", e);
            } else {
                return buildServerDownResponse("503", "Server unreachable: " + e.getMessage(), e);
            }

        } catch (Exception e) {
            log.error("❌ HttpService Exception: {}", e.getMessage());
            response.put("respCode", "500");
            response.put("data", "HttpService Error: " + e.getMessage());
        }
        
        return response;
    }

    public HashMap<String, String> getRequest(String url, HttpHeaders customHeaders) {
        HashMap<String, String> response = new HashMap<>();

        try {
            HttpHeaders headers = new HttpHeaders();

            if (customHeaders != null) {
                headers.addAll(customHeaders);
            }

            log.info("🌐 Sending GET request to: {}", url);
            log.info("📦 Headers: {}", headers);

            ResponseEntity<String> restResponse = restClient.get()
                    .uri(url)
                    .headers(h -> h.addAll(headers))
                    .retrieve()
                    .toEntity(String.class);

            response.put("respCode", String.valueOf(restResponse.getStatusCode().value()));
            response.put("data", restResponse.getBody());

            log.info("✅ GET Response: {}", restResponse.getStatusCode());

        } catch (HttpClientErrorException | HttpServerErrorException httpException) {
            log.error("❌ HTTP Error: {}", httpException.getMessage(), httpException);
            response.put("respCode", String.valueOf(httpException.getStatusCode().value()));
            response.put("data", httpException.getResponseBodyAsString());
        } catch (ResourceAccessException e) {
            Throwable cause = e.getCause();
            if (cause instanceof ConnectException) {
                return buildServerDownResponse("503", "Server unavailable - connection refused", e);
            } else {
                return buildServerDownResponse("503", "Server unreachable: " + e.getMessage(), e);
            }
        } catch (Exception e) {
            log.error("❌ Exception during GET call: {}", e.getMessage(), e);
            response.put("respCode", "500");
            response.put("data", "Exception: " + e.getMessage());
        }

        // 🟢 You missed this line earlier
        return response;
    }
    
    public HashMap<String, String> getRequest(String url) {
        HashMap<String, String> response = new HashMap<>();

        try {
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);

//            log.info("🌐 Sending GET request to: {}", url);
//            log.info("📦 Headers: {}", headers);

            ResponseEntity<String> restResponse = restClient.get()
                    .uri(url)
                    .headers(h -> h.addAll(headers))
                    .retrieve()
                    .toEntity(String.class);
            

            response.put("respCode", String.valueOf(restResponse.getStatusCode().value()));
            response.put("data", restResponse.getBody());

          //  log.info("✅ GET Response: {}", restResponse.getBody());

        } catch (HttpClientErrorException | HttpServerErrorException httpException) {
            log.error("❌ HTTP Error: {}", httpException.getMessage(), httpException);
            response.put("respCode", String.valueOf(httpException.getStatusCode().value()));
            response.put("data", httpException.getResponseBodyAsString());
        } catch (ResourceAccessException e) {
            Throwable cause = e.getCause();
            if (cause instanceof ConnectException) {
                return buildServerDownResponse("503", "Server unavailable - connection refused", e);
            } else {
                return buildServerDownResponse("503", "Server unreachable: " + e.getMessage(), e);
            }
        } catch (Exception e) {
            log.error("❌ Exception during GET call: {}", e.getMessage(), e);
            response.put("respCode", "500");
            response.put("data", "Exception: " + e.getMessage());
        }

        return response;
    }
    public HashMap<String, String> postFormRequest(String url, String formBody) {
        HashMap<String, String> response = new HashMap<>();
        
        try {
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

            log.info("🌐 Sending FORM POST to: {}", url);
            log.info("📦 Payload: {}", formBody);

            ResponseEntity<String> restResponse = restClient.post()
                    .uri(url)
                    .headers(h -> h.addAll(headers))
                    .body(formBody)
                    .retrieve()
                    .toEntity(String.class);

            response.put("respCode", String.valueOf(restResponse.getStatusCode().value()));

            // HTML RESPONSE directly stored
            response.put("data", restResponse.getBody());

            log.info("✅ FORM POST Response Status: {}", restResponse.getStatusCode());

        } catch (HttpClientErrorException e) {
            log.error("❌ FORM POST Error: {} - {}", e.getStatusCode(), e.getMessage());
            
            response.put("respCode", String.valueOf(e.getStatusCode().value()));
            response.put("data", e.getResponseBodyAsString()); // still HTML or error string
            
        } catch (ResourceAccessException e) {
            Throwable cause = e.getCause();
            if (cause instanceof ConnectException) {
                return buildServerDownResponse("503", "Server unavailable - connection refused", e);
            } else {
                return buildServerDownResponse("503", "Server unreachable: " + e.getMessage(), e);
            }
        } catch (Exception e) {
            log.error("❌ FORM POST Exception: {}", e.getMessage(), e);
            
            response.put("respCode", "500");
            response.put("data", "HttpService FORM Error: " + e.getMessage());
        }

        return response;
    }

}