캡챠

@Component
public class StoveCaptchaClient {

    private static final String HOST_LIVE    = "https://api.onstove.com";
    private static final String HOST_SANDBOX = "https://api.gate8.com";

    private final RestClient restClient;

    @Value("${stove.api.access-token}") private String apiAccessToken;
    @Value("${stove.caller-id}")        private String callerId;
    @Value("${stove.profile:live}")     private String profile;

    public StoveCaptchaClient(RestClient.Builder builder) {
        this.restClient = builder.build();
    }

    /** 캡챠 리소스 요청. 차단 IP는 BlockedIpException, 토큰 오류는 TokenAuthException으로 throw. */
    public CaptchaResource requestCaptcha(int level, String clientIp, String callerDetail) {
        String host = "sandbox".equalsIgnoreCase(profile) ? HOST_SANDBOX : HOST_LIVE;

        CaptchaResponse res = restClient.get()
                .uri(host + "/blockchecker/v1.0/server/captcha?captcha_level={lvl}&client_ip={ip}",
                     level, clientIp)
                .header(HttpHeaders.AUTHORIZATION, "Bearer " + apiAccessToken)
                .header("Caller-ID", callerId)
                .header("Caller-Detail", callerDetail)
                .retrieve()
                .onStatus(HttpStatusCode::is4xxClientError, (req, r) -> {
                    // 40101~40104 → HTTP 401 토큰 오류
                    throw new TokenAuthException("HTTP " + r.getStatusCode());
                })
                .body(CaptchaResponse.class);

        if (res == null) throw new IllegalStateException("empty captcha response");
        switch (res.code) {
            case 0:     return res.value;
            case 49500: throw new BlockedIpException("49500");                                         // 차단 IP
            case 49318: throw new TokenAuthException("code=" + res.code + ", message=" + res.message); // 토큰 오류 (본문 응답)
            case 49106:                                                                                 // 서버 내부 오류
                // log.error("STOVE captcha server error: code={}, message={}", res.code, res.message);
                throw new IllegalStateException("server internal: code=" + res.code + ", message=" + res.message);
            case 49240: case 49241: case 49713:                                                         // 파라미터 오류
                // log.error("STOVE captcha param error: code={}, message={}", res.code, res.message);
                throw new IllegalStateException("param error: code=" + res.code + ", message=" + res.message);
            default:
                // log.error("STOVE captcha unknown error: code={}, message={}", res.code, res.message);
                throw new IllegalStateException("captcha request failed: code=" + res.code + ", message=" + res.message);
        }
    }

    public static class BlockedIpException extends RuntimeException {
        public BlockedIpException(String code) { super("blocked IP, code=" + code); }
    }

    public static class TokenAuthException extends RuntimeException {
        public TokenAuthException(String detail) { super("captcha token error: " + detail); }
    }

    @Getter @Setter
    public static class CaptchaResponse {
        public int code;
        public String message;
        public CaptchaResource value;
    }

    @Getter @Setter
    public static class CaptchaResource {
        @JsonProperty("captcha_key")  public String captchaKey;
        @JsonProperty("captcha_type") public String captchaType;
        public Resource resource;
    }

    @Getter @Setter
    public static class Resource {
        @JsonProperty("image_url") public String imageUrl;
    }
}

public VerifyResult verifyCaptcha(int level, String key, String value, String clientIp, String callerDetail) {
    String host = "sandbox".equalsIgnoreCase(profile) ? HOST_SANDBOX : HOST_LIVE;

    Map<String, Object> body = Map.of(
        "captcha_level", level,
        "captcha_key",   key,
        "captcha_value", value,
        "client_ip",     clientIp
    );

    VerifyResponse res = restClient.post()
            .uri(host + "/blockchecker/v1.0/server/verify")
            .header(HttpHeaders.AUTHORIZATION, "Bearer " + apiAccessToken)
            .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
            .header("Caller-ID", callerId)
            .header("Caller-Detail", callerDetail)
            .body(body)
            .retrieve()
            .onStatus(HttpStatusCode::is4xxClientError, (req, r) -> {
                // 40101~40104 → HTTP 401 토큰 오류
                throw new TokenAuthException("HTTP " + r.getStatusCode());
            })
            .body(VerifyResponse.class);

    if (res == null) throw new IllegalStateException("empty verify response");
    switch (res.code) {
        case 0:     return VerifyResult.PASS;          // 검증 성공 → 원래 액션 진행
        case 49702: return VerifyResult.RETRY;         // 값 불일치 → 동일 키로 재입력
        case 49701: return VerifyResult.NEW_RESOURCE;  // Key 무효/만료 → 새 리소스 요청
        case 49500: throw new BlockedIpException("49500");                                         // 차단 IP
        case 49318: throw new TokenAuthException("code=" + res.code + ", message=" + res.message); // 토큰 오류 (본문 응답)
        case 49200: case 49240: case 49241: case 49700: case 49713:                                 // 파라미터 오류
            // log.error("STOVE captcha verify param error: code={}, message={}", res.code, res.message);
            throw new IllegalStateException("param error: code=" + res.code + ", message=" + res.message);
        default:
            // log.error("STOVE captcha verify unknown error: code={}, message={}", res.code, res.message);
            throw new IllegalStateException("verify failed: code=" + res.code + ", message=" + res.message);
    }
}

public enum VerifyResult { PASS, RETRY, NEW_RESOURCE }

@Getter @Setter
public static class VerifyResponse {
    public int code;
    public String message;
}

@Service
public class GameServerCaptchaFlow {
    private final StoveCaptchaClient captchaClient;
    private final CaptchaSessionStore sessionStore;   // 게임사 자체 운영툴·세션 관리

    /** 노출 조건 충족 시 캡챠 발급 후 클라이언트에 전달 */
    public CaptchaIssued issueCaptcha(String userId, String clientIp) {
        int level = sessionStore.resolveLevel(userId);
        CaptchaResource res = captchaClient.requestCaptcha(level, clientIp, userId);
        sessionStore.bindKey(userId, res.captchaKey, level);          // 사용자-키 매핑 저장
        return new CaptchaIssued(res.captchaKey, res.captchaType, res.resource.imageUrl);
        // 차단 IP는 BlockedIpException으로 throw되므로 컨트롤러에서 차단 UI 응답 처리
    }

    /** 클라이언트가 입력값 전달 시 검증 후 후속 처리 */
    public VerifyResult verify(String userId, String userInput, String clientIp) {
        CaptchaSessionStore.Binding binding = sessionStore.lookup(userId)
            .orElseThrow(() -> new IllegalStateException("no captcha issued"));

        VerifyResult result = captchaClient.verifyCaptcha(
            binding.level, binding.captchaKey, userInput, clientIp, userId
        );

        if (result == VerifyResult.PASS) {
            sessionStore.markPassed(userId);   // 통과 시각 갱신
            sessionStore.clear(userId);
        } else if (result == VerifyResult.NEW_RESOURCE) {
            sessionStore.clear(userId);        // 키 만료 → 새 리소스 요청 유도
        }
        return result;
        // 차단 IP/토큰 오류는 컨트롤러에서 try-catch로 일괄 처리 권장
    }

    public record CaptchaIssued(String captchaKey, String captchaType, String imageUrl) {}
}