Ödeme sağlayıcıları: tekrar eden kodu toparla, üçüncüsünü ekle

// ===== application.yml =====
// payment:
//   providers:
//     iyzico: { base-url: https://api.iyzico.example/v2, api-key: ${IYZICO_API_KEY}, timeout: 3s }
//     paytr:  { base-url: https://api.paytr.example,     api-key: ${PAYTR_API_KEY},  timeout: 3s }
//     papara: { base-url: https://api.papara.example,    api-key: ${PAPARA_API_KEY}, timeout: 3s }

// ===== PaymentProperties.java =====
@ConfigurationProperties(prefix = "payment")
public record PaymentProperties(Map<String, Provider> providers) {
    public record Provider(URI baseUrl, String apiKey, Duration timeout) {}

    public Provider get(String name) {
        Provider p = providers.get(name);
        if (p == null) throw new UnsupportedProviderException(name);
        return p;
    }
}

// ===== PaymentGateway.java =====
public interface PaymentGateway {
    String provider();                              // "iyzico", "paytr", "papara"
    PaymentResponse authorize(PaymentRequest request);
    PaymentResponse refund(RefundRequest request);
    RedirectUrlResponse redirectUrl(PaymentRequest request);
}

// ===== ProviderClient.java: tekrar eden HTTP kodu burada =====
public final class ProviderClient {
    private final String provider;
    private final RestClient restClient;

    public ProviderClient(String provider, PaymentProperties.Provider props, RestClient.Builder builder) {
        this.provider = provider;
        var factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout((int) props.timeout().toMillis());
        factory.setReadTimeout((int) props.timeout().toMillis());
        this.restClient = builder.clone()
                .baseUrl(props.baseUrl().toString())
                .requestFactory(factory)
                .defaultHeader(HttpHeaders.AUTHORIZATION, "Bearer " + props.apiKey())
                .build();
    }

    public <T> T post(String path, Object body, Class<T> responseType) {
        try {
            return restClient.post().uri(path)
                    .contentType(MediaType.APPLICATION_JSON)
                    .body(body)
                    .retrieve()
                    .body(responseType);
        } catch (RestClientResponseException e) {
            throw new ProviderException(provider, e.getStatusCode().value(), e.getResponseBodyAsString());
        } catch (ResourceAccessException e) {      // timeout, bağlantı hatası
            throw new ProviderUnavailableException(provider, e);
        }
    }
}

// ===== PaparaGateway.java (Iyzico ve PayTR de aynı kalıpta) =====
@Component
class PaparaGateway implements PaymentGateway {
    private final ProviderClient client;

    PaparaGateway(PaymentProperties properties, RestClient.Builder builder) {
        this.client = new ProviderClient(provider(), properties.get(provider()), builder);
    }

    @Override public String provider() { return "papara"; }

    @Override public PaymentResponse authorize(PaymentRequest r) { return client.post("/payments", PaparaMapper.toAuth(r), PaymentResponse.class); }
    @Override public PaymentResponse refund(RefundRequest r)     { return client.post("/refunds", PaparaMapper.toRefund(r), PaymentResponse.class); }
    @Override public RedirectUrlResponse redirectUrl(PaymentRequest r) { return client.post("/checkout-sessions", PaparaMapper.toSession(r), RedirectUrlResponse.class); }
}

// ===== PaymentGatewayRegistry.java =====
@Component
public class PaymentGatewayRegistry {
    private final Map<String, PaymentGateway> gateways;

    public PaymentGatewayRegistry(List<PaymentGateway> gateways) {
        this.gateways = gateways.stream()
                .collect(Collectors.toUnmodifiableMap(PaymentGateway::provider, Function.identity()));
    }

    public PaymentGateway get(String provider) {
        PaymentGateway gateway = gateways.get(provider.toLowerCase(Locale.ROOT));
        if (gateway == null) throw new UnsupportedProviderException(provider);
        return gateway;
    }
}

// ===== PaymentController.java =====
@RestController
@RequestMapping("/api/v1/payments/{provider}")
public class PaymentController {
    private final PaymentGatewayRegistry registry;

    public PaymentController(PaymentGatewayRegistry registry) { this.registry = registry; }

    @PostMapping("/authorize")
    public PaymentResponse authorize(@PathVariable String provider, @Valid @RequestBody PaymentRequest request) {
        return registry.get(provider).authorize(request);
    }

    @PostMapping("/refund")
    public PaymentResponse refund(@PathVariable String provider, @Valid @RequestBody RefundRequest request) {
        return registry.get(provider).refund(request);
    }

    @PostMapping("/redirect-url")
    public RedirectUrlResponse redirectUrl(@PathVariable String provider, @Valid @RequestBody PaymentRequest request) {
        return registry.get(provider).redirectUrl(request);
    }
}

// ===== Exceptions =====
public abstract class BusinessException extends RuntimeException {
    private final String errorCode;
    private final HttpStatus status;
    protected BusinessException(String errorCode, HttpStatus status, String message) {
        super(message); this.errorCode = errorCode; this.status = status;
    }
    public String errorCode() { return errorCode; }
    public HttpStatus status() { return status; }
}
public class UnsupportedProviderException extends BusinessException {
    public UnsupportedProviderException(String p) { super("PAYMENT_PROVIDER_NOT_SUPPORTED", HttpStatus.NOT_FOUND, "Unsupported provider: " + p); }
}
public class ProviderException extends BusinessException {
    public ProviderException(String p, int upstream, String body) { super("PAYMENT_PROVIDER_ERROR", HttpStatus.BAD_GATEWAY, p + " returned " + upstream); }
}

// ===== GlobalExceptionHandler.java =====
@RestControllerAdvice
class GlobalExceptionHandler {
    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(BusinessException.class)
    ResponseEntity<ProblemDetail> business(BusinessException e) {
        ProblemDetail pd = ProblemDetail.forStatusAndDetail(e.status(), e.getMessage());
        pd.setProperty("errorCode", e.errorCode());
        return ResponseEntity.status(e.status()).body(pd);
    }

    @ExceptionHandler(Exception.class)
    ProblemDetail unexpected(Exception e) {
        log.error("Unexpected error", e);                       // detay log'da, kullanıcıya değil
        return ProblemDetail.forStatusAndDetail(HttpStatus.INTERNAL_SERVER_ERROR, "Unexpected error");
    }
}

// ===== PaymentGatewayRegistryTest.java =====
class PaymentGatewayRegistryTest {
    @Test
    void resolvesProviderCaseInsensitively() {
        PaymentGateway papara = mock(PaymentGateway.class);
        when(papara.provider()).thenReturn("papara");
        var registry = new PaymentGatewayRegistry(List.of(papara));

        assertThat(registry.get("Papara")).isSameAs(papara);
    }

    @Test
    void rejectsUnknownProvider() {
        var registry = new PaymentGatewayRegistry(List.of());
        assertThatThrownBy(() -> registry.get("stripe")).isInstanceOf(UnsupportedProviderException.class);
    }
}