XuqmGroup-Server/im-sdk/src/main/java/com/xuqm/im/sdk/XuqmImServerSdk.java

package com.xuqm.im.sdk;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.xuqm.common.model.ApiResponse;
import com.xuqm.common.security.AppRequestSignatureUtil;

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.HexFormat;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.function.Supplier;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public final class XuqmImServerSdk {

    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;
    private final String baseUrl;
    private final String pushBaseUrl;
    private final String updateBaseUrl;
    private final String appKey;
    private final String appSecret;
    private final Supplier<String> bearerTokenSupplier;

    private XuqmImServerSdk(Builder builder) {
        this.httpClient = HttpClient.newHttpClient();
        this.objectMapper = new ObjectMapper()
                .registerModule(new JavaTimeModule())
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        this.baseUrl = trimTrailingSlash(builder.baseUrl);
        this.pushBaseUrl = trimTrailingSlash(builder.pushBaseUrl == null ? builder.baseUrl : builder.pushBaseUrl);
        this.updateBaseUrl = trimTrailingSlash(builder.updateBaseUrl == null ? builder.baseUrl : builder.updateBaseUrl);
        this.appKey = Objects.requireNonNull(builder.appKey, "appKey");
        this.appSecret = Objects.requireNonNull(builder.appSecret, "appSecret");
        this.bearerTokenSupplier = builder.bearerTokenSupplier;
    }

    public static Builder builder() {
        return new Builder();
    }

    public ImMessage sendMessage(SendMessageRequest request) {
        ApiResponse<ImMessage> response = request(
                "POST",
                buildUri("/api/im/messages/send", Map.of("appKey", appKey)),
                request,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public ImMessage revokeMessage(String messageId) {
        ApiResponse<ImMessage> response = request(
                "POST",
                buildUri("/api/im/messages/" + encode(messageId) + "/revoke", Map.of("appKey", appKey)),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public ImMessage editMessage(String messageId, String content) {
        ApiResponse<ImMessage> response = request(
                "PUT",
                buildUri("/api/im/messages/" + encode(messageId), Map.of("appKey", appKey)),
                Map.of("content", content),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public AccountView importAccount(String userId, String nickname, String avatar, String gender, String status) {
        ApiResponse<AccountView> response = request(
                "POST",
                buildUri("/api/im/accounts/import", appQuery()),
                new ImportAccountRequest(userId, nickname, avatar, gender, status),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<AccountView> importAccounts(List<ImportAccountRequest> accounts) {
        ApiResponse<List<AccountView>> response = request(
                "POST",
                buildUri("/api/im/accounts/import/batch", appQuery()),
                accounts,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void deleteAccount(String userId) {
        request(
                "DELETE",
                buildUri("/api/im/accounts/" + encode(userId), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public boolean checkAccount(String userId) {
        ApiResponse<Map<String, Object>> response = request(
                "GET",
                buildUri("/api/im/accounts/" + encode(userId) + "/exists", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        Object exists = response.data().get("exists");
        return exists instanceof Boolean b && b;
    }

    public List<ConversationView> listConversations(int size) {
        ApiResponse<List<ConversationView>> response = request(
                "GET",
                buildUri("/api/im/conversations", Map.of("appKey", appKey, "page", "0", "size", String.valueOf(size))),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public PageResult<ImMessage> fetchHistory(String toId, HistoryQuery query) {
        HistoryQuery effective = query == null ? new HistoryQuery() : query;
        ApiResponse<PageResult<ImMessage>> response = request(
                "GET",
                buildUri(
                        "/api/im/messages/history/" + encode(toId),
                        queryParams(
                                effective.msgType(),
                                effective.keyword(),
                                effective.startTime(),
                                effective.endTime(),
                                effective.page() == null ? 0 : effective.page(),
                                effective.size() == null ? 20 : effective.size()
                        )
                ),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public PageResult<ImMessage> fetchGroupHistory(String groupId, HistoryQuery query) {
        HistoryQuery effective = query == null ? new HistoryQuery() : query;
        ApiResponse<PageResult<ImMessage>> response = request(
                "GET",
                buildUri(
                        "/api/im/messages/group-history/" + encode(groupId),
                        queryParams(
                                effective.msgType(),
                                effective.keyword(),
                                effective.startTime(),
                                effective.endTime(),
                                effective.page() == null ? 0 : effective.page(),
                                effective.size() == null ? 20 : effective.size()
                        )
                ),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public PageResult<ImMessage> searchMessages(MessageSearchQuery query) {
        MessageSearchQuery effective = query == null ? new MessageSearchQuery() : query;
        ApiResponse<PageResult<ImMessage>> response = request(
                "GET",
                buildUri(
                        "/api/im/messages/search",
                        messageSearchQuery(
                                effective.chatType(),
                                effective.msgType(),
                                effective.keyword(),
                                effective.startTime(),
                                effective.endTime(),
                                effective.page() == null ? 0 : effective.page(),
                                effective.size() == null ? 20 : effective.size()
                        )
                ),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<WebhookConfigView> listWebhooks() {
        ApiResponse<List<WebhookConfigView>> response = request(
                "GET",
                buildUri("/api/im/admin/webhooks", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public WebhookConfigView createWebhook(WebhookConfigRequest request) {
        ApiResponse<WebhookConfigView> response = request(
                "POST",
                buildUri("/api/im/admin/webhooks", appQuery()),
                request,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public WebhookConfigView updateWebhook(String id, WebhookConfigRequest request) {
        ApiResponse<WebhookConfigView> response = request(
                "PUT",
                buildUri("/api/im/admin/webhooks/" + encode(id), appQuery()),
                request,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void deleteWebhook(String id) {
        request(
                "DELETE",
                buildUri("/api/im/admin/webhooks/" + encode(id), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public List<ConversationView> listConversations() {
        return listConversations(20);
    }

    public AccountView getProfile(String userId) {
        ApiResponse<AccountView> response = request(
                "GET",
                buildUri("/api/im/accounts/" + encode(userId), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public AccountView updateProfile(String userId, String nickname, String avatar, String gender) {
        Map<String, String> query = appQuery();
        if (nickname != null) {
            query.put("nickname", nickname);
        }
        if (avatar != null) {
            query.put("avatar", avatar);
        }
        if (gender != null) {
            query.put("gender", gender);
        }
        ApiResponse<AccountView> response = request(
                "PUT",
                buildUri("/api/im/accounts/" + encode(userId), query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<AccountView> searchAccounts(String keyword, int size) {
        ApiResponse<List<AccountView>> response = request(
                "GET",
                buildUri("/api/im/accounts/search", queryWithSize("keyword", keyword, size)),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public boolean verifyCallbackSignature(String timestamp, String nonce, String body, String signature) {
        long ts;
        try {
            ts = Long.parseLong(timestamp);
        } catch (NumberFormatException e) {
            return false;
        }
        long now = System.currentTimeMillis();
        if (Math.abs(now - ts) > 5 * 60 * 1000L) {
            return false;
        }
        String payload = appKey + "\n" + timestamp + "\n" + normalize(nonce) + "\n" + sha256Hex(body);
        String expected = hmacSha256Hex(appSecret, payload);
        return MessageDigest.isEqual(
                expected.getBytes(StandardCharsets.UTF_8),
                normalize(signature).getBytes(StandardCharsets.UTF_8)
        );
    }

    public WebhookCallbackEnvelope parseCallbackEnvelope(String body) {
        try {
            JsonNode root = objectMapper.readTree(body);
            return new WebhookCallbackEnvelope(
                    text(root, "callbackId"),
                    text(root, "callbackType"),
                    text(root, "callbackEvent"),
                    longValue(root, "requestTime"),
                    root.get("payload"),
                    text(root, "signature"),
                    text(root, "appKey")
            );
        } catch (JsonProcessingException e) {
            throw new ImSdkException("Invalid callback body", e);
        }
    }

    public ImMessage parseMessageCallbackPayload(String body) {
        return parseMessageCallbackPayload(parseCallbackEnvelope(body));
    }

    public ImMessage parseMessageCallbackPayload(WebhookCallbackEnvelope envelope) {
        if (!envelope.isMessageEvent()
                || !(envelope.isMessageSentEvent()
                || envelope.isMessageEditedEvent()
                || envelope.isMessageRevokedEvent())) {
            throw new ImSdkException("Callback event is not a message event");
        }
        return readPayload(envelope, ImMessage.class);
    }

    public ImMessage parseMessageSentCallbackPayload(String body) {
        return parseMessageSentCallbackPayload(parseCallbackEnvelope(body));
    }

    public ImMessage parseMessageSentCallbackPayload(WebhookCallbackEnvelope envelope) {
        requireMessageEvent(envelope, "message.sent");
        return readPayload(envelope, ImMessage.class);
    }

    public ImMessage parseMessageEditedCallbackPayload(String body) {
        return parseMessageEditedCallbackPayload(parseCallbackEnvelope(body));
    }

    public ImMessage parseMessageEditedCallbackPayload(WebhookCallbackEnvelope envelope) {
        requireMessageEvent(envelope, "message.edited");
        return readPayload(envelope, ImMessage.class);
    }

    public ImMessage parseMessageRevokedCallbackPayload(String body) {
        return parseMessageRevokedCallbackPayload(parseCallbackEnvelope(body));
    }

    public ImMessage parseMessageRevokedCallbackPayload(WebhookCallbackEnvelope envelope) {
        requireMessageEvent(envelope, "message.revoked");
        return readPayload(envelope, ImMessage.class);
    }

    public MessageReadCallbackPayload parseMessageReadCallbackPayload(String body) {
        return parseMessageReadCallbackPayload(parseCallbackEnvelope(body));
    }

    public MessageReadCallbackPayload parseMessageReadCallbackPayload(WebhookCallbackEnvelope envelope) {
        if (!envelope.isReadReceiptEvent()) {
            throw new ImSdkException("Callback event is not a message.read event");
        }
        return readPayload(envelope, MessageReadCallbackPayload.class);
    }

    public void registerPushToken(String userId, String vendor, String token) {
        request(
                "POST",
                buildUri(pushBaseUrl, "/api/push/register", Map.of(
                        "appKey", appKey,
                        "userId", userId,
                        "vendor", vendor,
                        "token", token
                )),
                null,
                publicHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void sendPush(String userId, String title, String body, String payload) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        query.put("userId", userId);
        query.put("title", title);
        query.put("body", body);
        if (payload != null) {
            query.put("payload", payload);
        }
        request(
                "POST",
                buildUri(pushBaseUrl, "/api/push/send", query),
                null,
                publicHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public Map<String, Object> checkAppUpdate(String platform, int currentVersionCode) {
        ApiResponse<Map<String, Object>> response = request(
                "GET",
                buildUri(updateBaseUrl, "/api/v1/updates/app/check", Map.of(
                        "appKey", appKey,
                        "platform", platform,
                        "currentVersionCode", String.valueOf(currentVersionCode)
                )),
                null,
                publicHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public AppVersionView uploadAppVersion(
            String platform,
            String versionName,
            int versionCode,
            String changeLog,
            boolean forceUpdate,
            Path apkFile) {
        Map<String, String> form = new LinkedHashMap<>();
        form.put("appKey", appKey);
        form.put("platform", platform);
        form.put("versionName", versionName);
        form.put("versionCode", String.valueOf(versionCode));
        if (changeLog != null) {
            form.put("changeLog", changeLog);
        }
        form.put("forceUpdate", String.valueOf(forceUpdate));
        ApiResponse<AppVersionView> response = multipartRequest(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/updates/app/upload", Map.of()),
                form,
                "apkFile",
                apkFile,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public UnifiedReleaseResult uploadUnifiedRelease(UnifiedReleaseManifest manifest, Map<String, Path> files) {
        Map<String, String> form = new LinkedHashMap<>();
        form.put("appKey", appKey);
        try {
            form.put("manifest", objectMapper.writeValueAsString(manifest));
        } catch (JsonProcessingException e) {
            throw new ImSdkException("Failed to serialize unified release manifest", e);
        }
        ApiResponse<UnifiedReleaseResult> response = multipartRequest(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/updates/unified/upload", Map.of()),
                form,
                files,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public AppVersionView publishAppVersion(String id) {
        ApiResponse<AppVersionView> response = request(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/updates/app/" + encode(id) + "/publish", Map.of()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public AppVersionView unpublishAppVersion(String id) {
        ApiResponse<AppVersionView> response = request(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/updates/app/" + encode(id) + "/unpublish", Map.of()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public AppVersionView grayAppVersion(String id, boolean enabled, int percent) {
        Map<String, Object> body = new LinkedHashMap<>();
        body.put("enabled", enabled);
        body.put("percent", percent);
        ApiResponse<AppVersionView> response = request(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/updates/app/" + encode(id) + "/gray", Map.of()),
                body,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<AppVersionView> listAppVersions(String platform) {
        ApiResponse<List<AppVersionView>> response = request(
                "GET",
                buildUri(updateBaseUrl, "/api/v1/updates/app/list", Map.of("appKey", appKey, "platform", platform)),
                null,
                publicHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public RnBundleView checkRnUpdate(String moduleId, String platform, String currentVersion) {
        ApiResponse<RnBundleView> response = request(
                "GET",
                buildUri(updateBaseUrl, "/api/v1/rn/update/check", Map.of(
                        "appKey", appKey,
                        "moduleId", moduleId,
                        "platform", platform,
                        "currentVersion", currentVersion
                )),
                null,
                publicHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public RnBundleView uploadRnBundle(
            String moduleId,
            String platform,
            String version,
            String minCommonVersion,
            String note,
            Path bundle) {
        Map<String, String> form = new LinkedHashMap<>();
        form.put("appKey", appKey);
        form.put("moduleId", moduleId);
        form.put("platform", platform);
        form.put("version", version);
        if (minCommonVersion != null) {
            form.put("minCommonVersion", minCommonVersion);
        }
        if (note != null) {
            form.put("note", note);
        }
        ApiResponse<RnBundleView> response = multipartRequest(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/rn/upload", Map.of()),
                form,
                "bundle",
                bundle,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public RnBundleView publishRnBundle(String id) {
        ApiResponse<RnBundleView> response = request(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/rn/" + encode(id) + "/publish", Map.of()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public RnBundleView unpublishRnBundle(String id) {
        ApiResponse<RnBundleView> response = request(
                "POST",
                buildUri(updateBaseUrl, "/api/v1/rn/" + encode(id) + "/unpublish", Map.of()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<RnBundleView> listRnBundles(String moduleId, String platform) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        if (moduleId != null) {
            query.put("moduleId", moduleId);
        }
        if (platform != null) {
            query.put("platform", platform);
        }
        ApiResponse<List<RnBundleView>> response = request(
                "GET",
                buildUri(updateBaseUrl, "/api/v1/rn/list", query),
                null,
                publicHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<String> listFriends() {
        ApiResponse<List<String>> response = request(
                "GET",
                buildUri("/api/im/friends", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public FriendLinkView addFriend(String friendId) {
        Map<String, String> query = appQuery();
        query.put("friendId", friendId);
        ApiResponse<FriendLinkView> response = request(
                "POST",
                buildUri("/api/im/friends", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<FriendLinkView> addFriends(List<String> friendIds) {
        ApiResponse<List<FriendLinkView>> response = request(
                "POST",
                buildUri("/api/im/friends/batch", appQuery()),
                new FriendBatchRequest(friendIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void removeFriend(String friendId) {
        Map<String, String> query = appQuery();
        query.put("friendId", friendId);
        request(
                "DELETE",
                buildUri("/api/im/friends/" + encode(friendId), query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void removeFriends(List<String> friendIds) {
        request(
                "POST",
                buildUri("/api/im/friends/batch/remove", appQuery()),
                new FriendBatchRequest(friendIds),
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void removeAllFriends() {
        request(
                "DELETE",
                buildUri("/api/im/friends", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public FriendLinkView setFriendGroup(String friendId, String groupName) {
        Map<String, String> query = appQuery();
        if (groupName != null) {
            query.put("groupName", groupName);
        }
        ApiResponse<FriendLinkView> response = request(
                "PUT",
                buildUri("/api/im/friends/" + encode(friendId) + "/group", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<String> listFriendGroups() {
        ApiResponse<List<String>> response = request(
                "GET",
                buildUri("/api/im/friends/groups", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<String> listFriendsByGroup(String groupName) {
        ApiResponse<List<String>> response = request(
                "GET",
                buildUri("/api/im/friends/groups/" + encode(groupName), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<FriendRequestView> listFriendRequests(String direction) {
        Map<String, String> query = appQuery();
        if (direction != null) {
            query.put("direction", direction);
        }
        ApiResponse<List<FriendRequestView>> response = request(
                "GET",
                buildUri("/api/im/friend-requests", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public FriendRequestView sendFriendRequest(String toUserId, String remark) {
        Map<String, String> query = appQuery();
        query.put("toUserId", toUserId);
        if (remark != null) {
            query.put("remark", remark);
        }
        ApiResponse<FriendRequestView> response = request(
                "POST",
                buildUri("/api/im/friend-requests", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public FriendRequestView acceptFriendRequest(String requestId) {
        ApiResponse<FriendRequestView> response = request(
                "POST",
                buildUri("/api/im/friend-requests/" + encode(requestId) + "/accept", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public FriendRequestView rejectFriendRequest(String requestId) {
        ApiResponse<FriendRequestView> response = request(
                "POST",
                buildUri("/api/im/friend-requests/" + encode(requestId) + "/reject", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<FriendRequestView> acceptFriendRequests(List<String> requestIds) {
        ApiResponse<List<FriendRequestView>> response = request(
                "POST",
                buildUri("/api/im/friend-requests/batch/accept", appQuery()),
                new RequestBatch(requestIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<FriendRequestView> rejectFriendRequests(List<String> requestIds) {
        ApiResponse<List<FriendRequestView>> response = request(
                "POST",
                buildUri("/api/im/friend-requests/batch/reject", appQuery()),
                new RequestBatch(requestIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<BlacklistView> listBlacklist() {
        ApiResponse<List<BlacklistView>> response = request(
                "GET",
                buildUri("/api/im/blacklist", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public BlacklistView addBlacklist(String blockedUserId) {
        Map<String, String> query = appQuery();
        query.put("blockedUserId", blockedUserId);
        ApiResponse<BlacklistView> response = request(
                "POST",
                buildUri("/api/im/blacklist", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void removeBlacklist(String blockedUserId) {
        Map<String, String> query = appQuery();
        query.put("blockedUserId", blockedUserId);
        request(
                "DELETE",
                buildUri("/api/im/blacklist", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public BlacklistCheckResult checkBlacklist(String targetUserId) {
        Map<String, String> query = appQuery();
        query.put("targetUserId", targetUserId);
        ApiResponse<BlacklistCheckResult> response = request(
                "GET",
                buildUri("/api/im/blacklist/check", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupView> listGroups() {
        ApiResponse<List<GroupView>> response = request(
                "GET",
                buildUri("/api/im/groups", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupView> listPublicGroups(String keyword) {
        Map<String, String> query = appQuery();
        if (keyword != null) {
            query.put("keyword", keyword);
        }
        ApiResponse<List<GroupView>> response = request(
                "GET",
                buildUri("/api/im/groups/public", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupView> searchGroups(String keyword, int size) {
        ApiResponse<List<GroupView>> response = request(
                "GET",
                buildUri("/api/im/groups/search", queryWithSize("keyword", keyword, size)),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView getGroup(String groupId) {
        ApiResponse<GroupView> response = request(
                "GET",
                buildUri("/api/im/groups/" + encode(groupId), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<AccountView> listGroupMembers(String groupId) {
        ApiResponse<List<AccountView>> response = request(
                "GET",
                buildUri("/api/im/groups/" + encode(groupId) + "/members", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<AccountView> searchGroupMembers(String groupId, String keyword, int size) {
        ApiResponse<List<AccountView>> response = request(
                "GET",
                buildUri("/api/im/groups/" + encode(groupId) + "/members/search", queryWithSize("keyword", keyword, size)),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView createGroup(String name, List<String> memberIds, String groupType) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups", appQuery()),
                new CreateGroupRequest(name, memberIds, groupType),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView updateGroup(String groupId, String name, String announcement) {
        ApiResponse<GroupView> response = request(
                "PUT",
                buildUri("/api/im/groups/" + encode(groupId), appQuery()),
                new UpdateGroupRequest(name, announcement),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView addGroupMember(String groupId, String userId) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/members", appQuery()),
                new MemberRequest(userId),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView addGroupMembers(String groupId, List<String> userIds) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/members/batch", appQuery()),
                new MemberBatchRequest(userIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView removeGroupMember(String groupId, String targetUserId) {
        ApiResponse<GroupView> response = request(
                "DELETE",
                buildUri("/api/im/groups/" + encode(groupId) + "/members/" + encode(targetUserId), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView removeGroupMembers(String groupId, List<String> userIds) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/members/batch/remove", appQuery()),
                new MemberBatchRequest(userIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView setGroupRole(String groupId, String userId, String role) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/roles", appQuery()),
                new SetRoleRequest(userId, role),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView transferGroupOwner(String groupId, String newOwnerId) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/owner", appQuery()),
                new TransferOwnerRequest(newOwnerId),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void leaveGroup(String groupId) {
        request(
                "DELETE",
                buildUri("/api/im/groups/" + encode(groupId) + "/members/me", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public GroupView updateGroupAttributes(String groupId, Map<String, Object> attributes) {
        ApiResponse<GroupView> response = request(
                "PUT",
                buildUri("/api/im/groups/" + encode(groupId) + "/attributes", appQuery()),
                attributes == null ? Map.of() : attributes,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView removeGroupAttributes(String groupId, List<String> keys) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/attributes/delete", appQuery()),
                new AttributeKeysRequest(keys),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView muteGroupMember(String groupId, String userId, long minutes) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/mute", appQuery()),
                new MuteMemberRequest(userId, minutes),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void dismissGroup(String groupId) {
        request(
                "DELETE",
                buildUri("/api/im/groups/" + encode(groupId), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public GroupJoinRequestView sendGroupJoinRequest(String groupId, String remark) {
        Map<String, String> query = appQuery();
        if (remark != null) {
            query.put("remark", remark);
        }
        ApiResponse<GroupJoinRequestView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/join-requests", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupJoinRequestView> listGroupJoinRequests(String groupId) {
        ApiResponse<List<GroupJoinRequestView>> response = request(
                "GET",
                buildUri("/api/im/groups/" + encode(groupId) + "/join-requests", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupJoinRequestView acceptGroupJoinRequest(String groupId, String requestId) {
        ApiResponse<GroupJoinRequestView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/join-requests/" + encode(requestId) + "/accept", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupJoinRequestView rejectGroupJoinRequest(String groupId, String requestId) {
        ApiResponse<GroupJoinRequestView> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/join-requests/" + encode(requestId) + "/reject", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupJoinRequestView> acceptGroupJoinRequests(String groupId, List<String> requestIds) {
        ApiResponse<List<GroupJoinRequestView>> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/join-requests/batch/accept", appQuery()),
                new RequestBatch(requestIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupJoinRequestView> rejectGroupJoinRequests(String groupId, List<String> requestIds) {
        ApiResponse<List<GroupJoinRequestView>> response = request(
                "POST",
                buildUri("/api/im/groups/" + encode(groupId) + "/join-requests/batch/reject", appQuery()),
                new RequestBatch(requestIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public Map<String, Boolean> queryUserState(List<String> userIds) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("userIds", String.join(",", userIds));
        ApiResponse<Map<String, Boolean>> response = request(
                "GET",
                buildUri("/api/im/admin/users/state", query),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void kickUsers(String appKey, List<String> userIds) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        request(
                "POST",
                buildUri("/api/im/admin/users/kick", query),
                Map.of("userIds", userIds),
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public List<ImMessage> batchSendMessage(String appKey, List<String> toIds, String msgType, String content) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        ApiResponse<List<ImMessage>> response = request(
                "POST",
                buildUri("/api/im/admin/messages/batch-send", query),
                Map.of("toIds", toIds, "msgType", msgType, "content", content),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void adminSetMsgRead(String appKey, String userId) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        request(
                "POST",
                buildUri("/api/im/admin/messages/read", query),
                Map.of("userId", userId),
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public List<ImMessage> importMessages(String appKey, List<ImportMessageRequest> requests) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        ApiResponse<List<ImMessage>> response = request(
                "POST",
                buildUri("/api/im/admin/messages/import", query),
                requests,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<FriendCheckResult> checkFriends(String appKey, List<String> friendIds) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        ApiResponse<List<FriendCheckResult>> response = request(
                "POST",
                buildUri("/api/im/friends/check", query),
                Map.of("friendIds", friendIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView modifyGroupMemberInfo(String groupId, String userId, String nickName, String role) {
        Map<String, String> body = new LinkedHashMap<>();
        if (nickName != null) {
            body.put("nickName", nickName);
        }
        if (role != null) {
            body.put("role", role);
        }
        ApiResponse<GroupView> response = request(
                "PUT",
                buildUri("/api/im/groups/" + encode(groupId) + "/members/" + encode(userId) + "/info", appQuery()),
                body,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView adminTransferGroupOwner(String groupId, String newOwnerId) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/admin/groups/" + encode(groupId) + "/owner", appQuery()),
                new TransferOwnerRequest(newOwnerId),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView adminUpdateGroupAttributes(String groupId, Map<String, Object> attributes) {
        ApiResponse<GroupView> response = request(
                "PUT",
                buildUri("/api/im/admin/groups/" + encode(groupId) + "/attributes", appQuery()),
                attributes == null ? Map.of() : attributes,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public GroupView adminRemoveGroupAttributes(String groupId, List<String> keys) {
        ApiResponse<GroupView> response = request(
                "POST",
                buildUri("/api/im/admin/groups/" + encode(groupId) + "/attributes/delete", appQuery()),
                new AttributeKeysRequest(keys),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<GroupReadReceiptSummary> adminGroupReadReceipts(String groupId, List<String> messageIds) {
        ApiResponse<List<GroupReadReceiptSummary>> response = request(
                "POST",
                buildUri("/api/im/admin/groups/" + encode(groupId) + "/read-receipts", appQuery()),
                new GroupReadReceiptRequest(messageIds),
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void setConversationPinned(String targetId, String chatType, boolean pinned) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        query.put("pinned", String.valueOf(pinned));
        request(
                "PUT",
                buildUri("/api/im/conversations/" + encode(targetId) + "/pinned", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void setConversationMuted(String targetId, String chatType, boolean muted) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        query.put("muted", String.valueOf(muted));
        request(
                "PUT",
                buildUri("/api/im/conversations/" + encode(targetId) + "/muted", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void markRead(String targetId, String chatType) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        request(
                "PUT",
                buildUri("/api/im/conversations/" + encode(targetId) + "/read", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void setDraft(String targetId, String chatType, String draft) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        if (draft != null) {
            query.put("draft", draft);
        }
        request(
                "PUT",
                buildUri("/api/im/conversations/" + encode(targetId) + "/draft", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void setConversationHidden(String targetId, String chatType, boolean hidden) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        query.put("hidden", String.valueOf(hidden));
        request(
                "PUT",
                buildUri("/api/im/conversations/" + encode(targetId) + "/hidden", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public void setConversationGroup(String targetId, String chatType, String groupName) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        if (groupName != null) {
            query.put("groupName", groupName);
        }
        request(
                "PUT",
                buildUri("/api/im/conversations/" + encode(targetId) + "/group", query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    public List<String> listConversationGroups() {
        ApiResponse<List<String>> response = request(
                "GET",
                buildUri("/api/im/conversation-groups", appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public List<ConversationGroupItem> listConversationGroupItems(String groupName) {
        ApiResponse<List<ConversationGroupItem>> response = request(
                "GET",
                buildUri("/api/im/conversation-groups/" + encode(groupName), appQuery()),
                null,
                authorizedHeaders(),
                new TypeReference<>() {}
        );
        return response.data();
    }

    public void deleteConversation(String targetId, String chatType) {
        Map<String, String> query = appQuery();
        query.put("chatType", chatType);
        request(
                "DELETE",
                buildUri("/api/im/conversations/" + encode(targetId), query),
                null,
                authorizedHeaders(),
                new TypeReference<ApiResponse<Void>>() {}
        );
    }

    private static String sha256Hex(String value) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(normalize(value).getBytes(StandardCharsets.UTF_8));
            return HexFormat.of().formatHex(hash);
        } catch (Exception e) {
            throw new ImSdkException("Failed to hash callback body", e);
        }
    }

    private static String hmacSha256Hex(String secret, String payload) {
        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
            byte[] hash = mac.doFinal(payload.getBytes(StandardCharsets.UTF_8));
            return HexFormat.of().formatHex(hash);
        } catch (Exception e) {
            throw new ImSdkException("Failed to verify callback signature", e);
        }
    }

    private static String normalize(String value) {
        return value == null ? "" : value;
    }

    private <T> T readPayload(WebhookCallbackEnvelope envelope, Class<T> payloadType) {
        try {
            return objectMapper.treeToValue(envelope.payload(), payloadType);
        } catch (JsonProcessingException e) {
            throw new ImSdkException("Failed to parse callback payload", e);
        }
    }

    private void requireMessageEvent(WebhookCallbackEnvelope envelope, String event) {
        if (!envelope.isMessageEvent() || !envelope.isEvent(event)) {
            throw new ImSdkException("Callback event is not a " + event + " event");
        }
    }

    private static String text(JsonNode node, String field) {
        JsonNode value = node == null ? null : node.get(field);
        return value == null || value.isNull() ? null : value.asText();
    }

    private static long longValue(JsonNode node, String field) {
        JsonNode value = node == null ? null : node.get(field);
        if (value == null || value.isNull()) {
            return 0L;
        }
        return value.asLong();
    }

    private Map<String, String> authorizedHeaders() {
        String token = bearerTokenSupplier == null ? null : bearerTokenSupplier.get();
        if (token == null || token.isBlank()) {
            throw new ImSdkException("Bearer token is required for this call");
        }
        return Map.of("Authorization", "Bearer " + token);
    }

    private Map<String, String> publicHeaders() {
        return Map.of();
    }

    private <T> ApiResponse<T> request(
            String method,
            URI uri,
            Object body,
            Map<String, String> headers,
            TypeReference<ApiResponse<T>> responseType
    ) {
        try {
            HttpRequest.Builder builder = HttpRequest.newBuilder(uri)
                    .header("Content-Type", "application/json")
                    .headers(flatten(headers));
            if (body != null) {
                builder.method(method, HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(body)));
            } else if ("GET".equalsIgnoreCase(method) || "DELETE".equalsIgnoreCase(method)) {
                builder.method(method, HttpRequest.BodyPublishers.noBody());
            } else {
                builder.method(method, HttpRequest.BodyPublishers.noBody());
            }
            HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() >= 400) {
                throw new ImSdkException("HTTP " + response.statusCode() + ": " + response.body());
            }
            ApiResponse<T> apiResponse = objectMapper.readValue(response.body(), responseType);
            if (apiResponse.code() != 200) {
                throw new ImSdkException(apiResponse.message());
            }
            return apiResponse;
        } catch (IOException e) {
            throw new ImSdkException("Request failed: " + e.getMessage(), e);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new ImSdkException("Request interrupted", e);
        }
    }

    private <T> ApiResponse<T> multipartRequest(
            String method,
            URI uri,
            Map<String, String> formFields,
            String fileFieldName,
            Path file,
            Map<String, String> headers,
            TypeReference<ApiResponse<T>> responseType
    ) {
        String boundary = "----XuqmBoundary" + UUID.randomUUID().toString().replace("-", "");
        try {
            HttpRequest.BodyPublisher bodyPublisher = ofMultipartData(boundary, formFields, fileFieldName, file);
            Map<String, String> mergedHeaders = new LinkedHashMap<>(headers);
            mergedHeaders.put("Content-Type", "multipart/form-data; boundary=" + boundary);
            HttpRequest.Builder builder = HttpRequest.newBuilder(uri)
                    .headers(flatten(mergedHeaders))
                    .method(method, bodyPublisher);
            HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() >= 400) {
                throw new ImSdkException("HTTP " + response.statusCode() + ": " + response.body());
            }
            ApiResponse<T> apiResponse = objectMapper.readValue(response.body(), responseType);
            if (apiResponse.code() != 200) {
                throw new ImSdkException(apiResponse.message());
            }
            return apiResponse;
        } catch (IOException e) {
            throw new ImSdkException("Request failed: " + e.getMessage(), e);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new ImSdkException("Request interrupted", e);
        }
    }

    private <T> ApiResponse<T> multipartRequest(
            String method,
            URI uri,
            Map<String, String> formFields,
            Map<String, Path> files,
            Map<String, String> headers,
            TypeReference<ApiResponse<T>> responseType
    ) {
        String boundary = "----XuqmBoundary" + UUID.randomUUID().toString().replace("-", "");
        try {
            HttpRequest.BodyPublisher bodyPublisher = ofMultipartData(boundary, formFields, files);
            Map<String, String> mergedHeaders = new LinkedHashMap<>(headers);
            mergedHeaders.put("Content-Type", "multipart/form-data; boundary=" + boundary);
            HttpRequest.Builder builder = HttpRequest.newBuilder(uri)
                    .headers(flatten(mergedHeaders))
                    .method(method, bodyPublisher);
            HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() >= 400) {
                throw new ImSdkException("HTTP " + response.statusCode() + ": " + response.body());
            }
            ApiResponse<T> apiResponse = objectMapper.readValue(response.body(), responseType);
            if (apiResponse.code() != 200) {
                throw new ImSdkException(apiResponse.message());
            }
            return apiResponse;
        } catch (IOException e) {
            throw new ImSdkException("Request failed: " + e.getMessage(), e);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new ImSdkException("Request interrupted", e);
        }
    }

    private HttpRequest.BodyPublisher ofMultipartData(
            String boundary,
            Map<String, String> formFields,
            String fileFieldName,
            Path file
    ) throws IOException {
        var byteArrays = new ArrayList<byte[]>();
        Charset charset = StandardCharsets.UTF_8;

        for (Map.Entry<String, String> entry : formFields.entrySet()) {
            byteArrays.add(("--" + boundary + "\r\n").getBytes(charset));
            byteArrays.add(("Content-Disposition: form-data; name=\"" + entry.getKey() + "\"\r\n\r\n").getBytes(charset));
            byteArrays.add(entry.getValue().getBytes(charset));
            byteArrays.add("\r\n".getBytes(charset));
        }

        byteArrays.add(("--" + boundary + "\r\n").getBytes(charset));
        byteArrays.add(("Content-Disposition: form-data; name=\"" + fileFieldName + "\"; filename=\"" + file.getFileName() + "\"\r\n").getBytes(charset));
        byteArrays.add(("Content-Type: application/octet-stream\r\n\r\n").getBytes(charset));
        byteArrays.add(Files.readAllBytes(file));
        byteArrays.add("\r\n".getBytes(charset));
        byteArrays.add(("--" + boundary + "--\r\n").getBytes(charset));

        return HttpRequest.BodyPublishers.ofByteArrays(byteArrays);
    }

    private HttpRequest.BodyPublisher ofMultipartData(
            String boundary,
            Map<String, String> formFields,
            Map<String, Path> files
    ) throws IOException {
        var byteArrays = new ArrayList<byte[]>();
        Charset charset = StandardCharsets.UTF_8;

        for (Map.Entry<String, String> entry : formFields.entrySet()) {
            byteArrays.add(("--" + boundary + "\r\n").getBytes(charset));
            byteArrays.add(("Content-Disposition: form-data; name=\"" + entry.getKey() + "\"\r\n\r\n").getBytes(charset));
            byteArrays.add(entry.getValue().getBytes(charset));
            byteArrays.add("\r\n".getBytes(charset));
        }

        for (Map.Entry<String, Path> entry : files.entrySet()) {
            Path file = entry.getValue();
            byteArrays.add(("--" + boundary + "\r\n").getBytes(charset));
            byteArrays.add(("Content-Disposition: form-data; name=\"" + entry.getKey() + "\"; filename=\"" + file.getFileName() + "\"\r\n").getBytes(charset));
            byteArrays.add(("Content-Type: application/octet-stream\r\n\r\n").getBytes(charset));
            byteArrays.add(Files.readAllBytes(file));
            byteArrays.add("\r\n".getBytes(charset));
        }

        byteArrays.add(("--" + boundary + "--\r\n").getBytes(charset));
        return HttpRequest.BodyPublishers.ofByteArrays(byteArrays);
    }

    private URI buildUri(String path, Map<String, String> query) {
        StringBuilder builder = new StringBuilder(baseUrl).append(path);
        if (query != null && !query.isEmpty()) {
            builder.append('?');
            boolean first = true;
            for (Map.Entry<String, String> entry : query.entrySet()) {
                String value = entry.getValue();
                if (value == null) {
                    continue;
                }
                if (!first) {
                    builder.append('&');
                }
                builder.append(encode(entry.getKey())).append('=').append(encode(value));
                first = false;
            }
        }
        return URI.create(builder.toString());
    }

    private URI buildUri(String base, String path, Map<String, String> query) {
        StringBuilder builder = new StringBuilder(trimTrailingSlash(base)).append(path);
        if (query != null && !query.isEmpty()) {
            builder.append('?');
            boolean first = true;
            for (Map.Entry<String, String> entry : query.entrySet()) {
                String value = entry.getValue();
                if (value == null) {
                    continue;
                }
                if (!first) {
                    builder.append('&');
                }
                builder.append(encode(entry.getKey())).append('=').append(encode(value));
                first = false;
            }
        }
        return URI.create(builder.toString());
    }

    private Map<String, String> appQuery() {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        return query;
    }

    private Map<String, String> queryWithPage(int page, int size) {
        Map<String, String> query = appQuery();
        query.put("page", String.valueOf(page));
        query.put("size", String.valueOf(size));
        return query;
    }

    private Map<String, String> queryWithSize(String key, String value, int size) {
        Map<String, String> query = appQuery();
        query.put(key, value);
        query.put("size", String.valueOf(size));
        return query;
    }

    private Map<String, String> queryParams(String msgType, String keyword, LocalDateTime startTime, LocalDateTime endTime, int page, int size) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        if (msgType != null && !msgType.isBlank()) {
            query.put("msgType", msgType);
        }
        if (keyword != null && !keyword.isBlank()) {
            query.put("keyword", keyword);
        }
        if (startTime != null) {
            query.put("startTime", startTime.toInstant(ZoneOffset.UTC).toString());
        }
        if (endTime != null) {
            query.put("endTime", endTime.toInstant(ZoneOffset.UTC).toString());
        }
        query.put("page", String.valueOf(page));
        query.put("size", String.valueOf(size));
        return query;
    }

    private Map<String, String> messageSearchQuery(
            String chatType,
            String msgType,
            String keyword,
            LocalDateTime startTime,
            LocalDateTime endTime,
            int page,
            int size
    ) {
        Map<String, String> query = new LinkedHashMap<>();
        query.put("appKey", appKey);
        if (chatType != null && !chatType.isBlank()) {
            query.put("chatType", chatType);
        }
        if (msgType != null && !msgType.isBlank()) {
            query.put("msgType", msgType);
        }
        if (keyword != null && !keyword.isBlank()) {
            query.put("keyword", keyword);
        }
        if (startTime != null) {
            query.put("startTime", startTime.toInstant(ZoneOffset.UTC).toString());
        }
        if (endTime != null) {
            query.put("endTime", endTime.toInstant(ZoneOffset.UTC).toString());
        }
        query.put("page", String.valueOf(page));
        query.put("size", String.valueOf(size));
        return query;
    }

    private String[] flatten(Map<String, String> headers) {
        String[] pairs = new String[headers.size() * 2];
        int index = 0;
        for (Map.Entry<String, String> entry : headers.entrySet()) {
            pairs[index++] = entry.getKey();
            pairs[index++] = entry.getValue();
        }
        return pairs;
    }

    private String encode(String value) {
        return URLEncoder.encode(value, StandardCharsets.UTF_8);
    }

    private String trimTrailingSlash(String value) {
        return value.endsWith("/") ? value.substring(0, value.length() - 1) : value;
    }

    private static final String DEFAULT_BASE_URL = "https://dev.xuqinmin.com";

    public static final class Builder {
        private String baseUrl = DEFAULT_BASE_URL;
        private String pushBaseUrl;
        private String updateBaseUrl;
        private String appKey;
        private String appSecret;
        private Supplier<String> bearerTokenSupplier;

        private Builder() {}

        public Builder baseUrl(String baseUrl) {
            this.baseUrl = baseUrl;
            return this;
        }

        public Builder pushBaseUrl(String pushBaseUrl) {
            this.pushBaseUrl = pushBaseUrl;
            return this;
        }

        public Builder updateBaseUrl(String updateBaseUrl) {
            this.updateBaseUrl = updateBaseUrl;
            return this;
        }

        public Builder appKey(String appKey) {
            this.appKey = appKey;
            return this;
        }

        public Builder appSecret(String appSecret) {
            this.appSecret = appSecret;
            return this;
        }

        public Builder bearerTokenSupplier(Supplier<String> bearerTokenSupplier) {
            this.bearerTokenSupplier = bearerTokenSupplier;
            return this;
        }

        public XuqmImServerSdk build() {
            Objects.requireNonNull(this.appKey, "appKey is required");
            Objects.requireNonNull(this.appSecret, "appSecret is required");
            return new XuqmImServerSdk(this);
        }
    }

    public record LoginResponse(String token) {}

    public record ConversationView(
            String targetId,
            String chatType,
            String lastMsgContent,
            String lastMsgType,
            Long lastMsgTime,
            int unreadCount,
            boolean isMuted,
            boolean isPinned,
            String conversationGroup
    ) {}

    public record ConversationGroupItem(
            String targetId,
            String chatType,
            String groupName
    ) {}

    public record AccountView(
            String id,
            String appKey,
            String userId,
            String nickname,
            String gender,
            String avatar,
            String status,
            LocalDateTime createdAt
    ) {}

    public record ImportAccountRequest(
            String userId,
            String nickname,
            String avatar,
            String gender,
            String status
    ) {}

    public record FriendLinkView(
            Long id,
            String appKey,
            String userId,
            String friendId,
            String friendGroup,
            Instant createdAt
    ) {}

    public record FriendBatchRequest(List<String> friendIds) {}

    public record FriendRequestView(
            String id,
            String appKey,
            String fromUserId,
            String toUserId,
            String remark,
            String status,
            LocalDateTime createdAt,
            LocalDateTime reviewedAt
    ) {}

    public record BlacklistView(
            String id,
            String appKey,
            String userId,
            String blockedUserId,
            LocalDateTime createdAt
    ) {}

    public record BlacklistCheckResult(
            String targetUserId,
            boolean blockedByMe,
            boolean blockedByTarget,
            boolean eitherBlocked
    ) {}

    public record GroupView(
            String id,
            String appKey,
            String name,
            String groupType,
            String creatorId,
            String memberIds,
            String adminIds,
            String announcement,
            String memberInfo,
            String extAttributes,
            LocalDateTime createdAt
    ) {
        public List<String> memberIdList() {
            return parseJsonStringList(memberIds);
        }

        public List<String> adminIdList() {
            return parseJsonStringList(adminIds);
        }
    }

    public record GroupReadReceiptSummary(
            String messageId,
            String groupId,
            int memberCount,
            int readCount,
            int unreadCount
    ) {}

    public record GroupJoinRequestView(
            String id,
            String appKey,
            String groupId,
            String requesterId,
            String remark,
            String status,
            LocalDateTime createdAt,
            LocalDateTime reviewedAt
    ) {}

    public record WebhookCallbackEnvelope(
            String callbackId,
            String callbackType,
            String callbackEvent,
            long requestTime,
            JsonNode payload,
            String signature,
            String appKey
    ) {
        public boolean isType(String type) {
            return type != null && callbackType != null && callbackType.equalsIgnoreCase(type);
        }

        public boolean isEvent(String event) {
            return event != null && callbackEvent != null && callbackEvent.equalsIgnoreCase(event);
        }

        public boolean isMessageEvent() {
            return isType("message");
        }

        public boolean isMessageSentEvent() {
            return isEvent("message.sent");
        }

        public boolean isMessageEditedEvent() {
            return isEvent("message.edited");
        }

        public boolean isMessageRevokedEvent() {
            return isEvent("message.revoked");
        }

        public boolean isReadReceiptEvent() {
            return isEvent("message.read");
        }
    }

    public record AppVersionView(
            String id,
            String appKey,
            String platform,
            String versionName,
            int versionCode,
            String downloadUrl,
            String changeLog,
            boolean forceUpdate,
            String publishStatus,
            String appStoreUrl,
            String marketUrl,
            boolean grayEnabled,
            int grayPercent,
            Long createdAt
    ) {}

    public record RnBundleView(
            String id,
            String appKey,
            String moduleId,
            String platform,
            String version,
            String bundleUrl,
            String md5,
            String minCommonVersion,
            String note,
            String publishStatus,
            boolean grayEnabled,
            int grayPercent,
            Long createdAt
    ) {}

    public record HistoryQuery(
            String msgType,
            String keyword,
            LocalDateTime startTime,
            LocalDateTime endTime,
            Integer page,
            Integer size
    ) {
        public HistoryQuery() {
            this(null, null, null, null, null, null);
        }
    }

    public record MessageSearchQuery(
            String chatType,
            String msgType,
            String keyword,
            LocalDateTime startTime,
            LocalDateTime endTime,
            Integer page,
            Integer size
    ) {
        public MessageSearchQuery() {
            this(null, null, null, null, null, null, null);
        }
    }

    public record PageResult<T>(
            List<T> content,
            long totalElements,
            int totalPages,
            int size,
            int number,
            int numberOfElements,
            boolean first,
            boolean last,
            boolean empty
    ) {}

    public record ImMessage(
            String id,
            String appKey,
            String fromUserId,
            String toId,
            String chatType,
            String msgType,
            String content,
            String status,
            String mentionedUserIds,
            Integer groupReadCount,
            Long createdAt,
            Long editedAt
    ) {}

    public record SendMessageRequest(
            String messageId,
            String toId,
            String chatType,
            String msgType,
            String content,
            String mentionedUserIds
    ) {}

    public record WebhookConfigRequest(
            String url,
            String secret,
            Boolean enabled
    ) {}

    public record WebhookConfigView(
            String id,
            String appKey,
            String url,
            String secret,
            boolean enabled,
            LocalDateTime createdAt
    ) {}

    public record KeywordFilterRequest(
            String pattern,
            String replacement,
            String action,
            Boolean enabled
    ) {}

    public record AppVersionUploadRequest(
            String appKey,
            String platform,
            String versionName,
            int versionCode,
            String changeLog,
            boolean forceUpdate
    ) {}

    public record RnBundleUploadRequest(
            String appKey,
            String moduleId,
            String platform,
            String version,
            String minCommonVersion,
            String note
    ) {}

    public record MessageReadCallbackPayload(
            String appKey,
            String readerId,
            String peerId,
            String groupId,
            String chatType,
            long readAt,
            List<String> messageIds
    ) {}

    public record UnifiedReleaseManifest(
            List<AppUploadItem> appVersions,
            List<RnBundleUploadItem> rnBundles
    ) {}

    public record AppUploadItem(
            String fileKey,
            String platform,
            String versionName,
            int versionCode,
            String changeLog,
            boolean forceUpdate,
            String appStoreUrl,
            String marketUrl
    ) {}

    public record RnBundleUploadItem(
            String fileKey,
            String moduleId,
            String platform,
            String version,
            String minCommonVersion,
            String note
    ) {}

    public record UnifiedReleaseResult(
            List<AppVersionView> appVersions,
            List<RnBundleView> rnBundles
    ) {}

    public record CreateGroupRequest(
            String name,
            List<String> memberIds,
            String groupType
    ) {}

    public record UpdateGroupRequest(
            String name,
            String announcement
    ) {}

    public record MemberRequest(String userId) {}

    public record MemberBatchRequest(List<String> userIds) {}

    public record SetRoleRequest(String userId, String role) {}

    public record TransferOwnerRequest(String newOwnerId) {}

    public record AttributeKeysRequest(List<String> keys) {}

    public record MuteMemberRequest(String userId, long minutes) {}

    public record GroupReadReceiptRequest(List<String> messageIds) {}

    public record RequestBatch(List<String> requestIds) {}

    public record FriendCheckResult(String userId, boolean isFriend) {}

    public record ImportMessageRequest(
            String messageId,
            String fromUserId,
            String toId,
            String chatType,
            String msgType,
            String content,
            String status,
            String createdAt
    ) {}

    public static final class ImSdkException extends RuntimeException {
        public ImSdkException(String message) {
            super(message);
        }

        public ImSdkException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    private static List<String> parseJsonStringList(String value) {
        if (value == null || value.isBlank()) {
            return List.of();
        }
        String trimmed = value.trim();
        if (!trimmed.startsWith("[")) {
            return trimmed.isEmpty() ? List.of() : List.of(trimmed.split(","));
        }
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(trimmed, new TypeReference<List<String>>() {});
        } catch (IOException e) {
            return new ArrayList<>(List.of(trimmed));
        }
    }
}