// 最简示例
XIM.init({ appId: 'your_app_id' });
await XIM.login('user_001', 'token');
await XIM.sendText('user_002', 'Hello!');

<script src="/dist/xim-sdk.js"></script>
<script>
  const XIM = xSpace.XIM;
</script>

import { XIM } from '@xim/sdk';

XIM.init({
  appId: 'your_app_id',   // 必填，应用 ID
  platform: 'web',        // 可选，平台标识
});

await XIM.login('user_001', 'token_string');

XIM.logout();

// 监听
XIM.on('message', (msg) => { ... });

// 取消监听
XIM.off('message', handler);

const msg = await XIM.sendText('user_002', '你好', 1);

const msg = await XIM.sendImage('user_002', file, 1);
// 小程序传 tempFilePath 字符串

{ "url": "https://...", "w": 640, "h": 480, "size": 102400 }

const msg = await XIM.sendFile('user_002', file, 1);

{ "url": "https://...", "name": "report.pdf", "size": 204800 }

const payload = new Uint8Array([1, 2, 3]);
const msg = await XIM.sendData('user_002', payload, 1);

XIM.on('message', (msg) => {
  if (msg.type === 1) {
    console.log(msg.content);           // 文本
  } else if (msg.type === 2) {
    const { url, w, h } = JSON.parse(msg.content);  // 图片
  } else if (msg.type === 4) {
    const { url, name, size } = JSON.parse(msg.content); // 文件
  } else if (msg.type === 5) {
    console.log(msg.payload);           // 二进制
  }
});

const { messages, hasMore } = await XIM.getHistory('user_002', 1, beforeTime, 20);

// 下拉加载更多
let minTime = 0;
let hasMore = true;

async function loadOlder() {
  if (!hasMore) return;
  const result = await XIM.getHistory('user_002', 1, minTime, 20);
  if (result.messages.length > 0) minTime = result.messages[0].timestamp;
  hasMore = result.hasMore;
}

const convs = XIM.getConversations(); // 纯本地，无网络请求

XIM.markRead('user_002', 1);   // 标记已读
XIM.markUnread('user_002', 1); // 标记未读

await XIM.recallMessage(msgId); // 撤回消息

const group = await XIM.createGroup('我的群', ['user_002', 'user_003']);
await XIM.joinGroup('g_xxxxxxxx');
await XIM.leaveGroup('g_xxxxxxxx');

const info = await XIM.channelJoin('room_001');
XIM.channelSendText('room_001', '你好大家');

XIM.on('channel_text', ({ channelId, senderId, text }) => {
  console.log(`${senderId}: ${text}`);
});

await XIM.channelLeave('room_001');

await XIM.setMyProfile({ nickname: '张三', avatarUrl: '...' });
const profiles = await XIM.getUserProfiles(['user_001', 'user_002']);
const cached = XIM.getCachedProfile('user_001');

interface Message {
  id: string;
  convId: string;
  targetId: string;
  senderId: string;
  type: number;       // 1=文本, 2=图片, 3=语音, 4=文件, 5=二进制
  content: string;
  timestamp: number;
  status: number;     // 0=发送中, 1=已发送
  seq: number;
  payload?: Uint8Array;
  flags?: number;
  extra?: string;
}

interface Conversation {
  id: string;
  type: number;       // 1=单聊, 2=群聊
  targetId: string;
  name: string;
  unreadCount: number;
  lastMsg?: Message;
}

interface InitConfig {
  appId: string;
  server?: string;
  platform?: string;
  deviceId?: string;
  appVersion?: string;
  appName?: string;
  nickname?: string;
  avatarUrl?: string;
}

// 在脚本顶部引入命名空间
using xSpace;

using XSpace;

XIM.Init("your_app_id");

XIM.Init(
    appId: "your_app_id",
    server: "wss://your-server.com",  // 可选，自定义服务器地址
    autoDownload: true                 // 可选，是否自动下载语音/图片文件
);

Result result = await XIM.LoginAsync("user_001", "token");
if (result.Success) {
    Debug.Log("登录成功");
}

await XIM.LogoutAsync();

ConnState state = XIM.ConnectionState;
// ConnState.Connected / Connecting / Disconnected

// 连接事件
XIM.OnConnected += () => Debug.Log("已连接");
XIM.OnDisconnected += (code, reason) => Debug.Log($"断开: {reason}");
XIM.OnKickedOffline += () => Debug.Log("被踢下线");

// 消息事件
XIM.OnNewMessage += (msg) => Debug.Log($"新消息: {msg.Content}");
XIM.OnMessageRecalled += (msgId) => Debug.Log($"撤回: {msgId}");

// 会话事件
XIM.OnConversationUpdated += (conv) => Debug.Log($"会话更新: {conv.TargetId}");

// 群组事件
XIM.OnGroupMemberJoined += (groupId, userId) => { };
XIM.OnGroupMemberLeft += (groupId, userId) => { };

// 频道事件
XIM.OnChannelText += (channelId, senderId, text, seqNum, timestamp) => { };
XIM.OnChannelData += (channelId, senderId, seqNum, data, contentType) => { };

Message msg = await XIM.SendTextAsync("user_002", "你好");

Message msg = await XIM.SendImageAsync("user_002", "/path/to/image.png");

Message msg = await XIM.SendVoiceAsync("user_002", "/path/to/voice.wav", durationSec: 5);

byte[] data = Encoding.UTF8.GetBytes("custom payload");
Message msg = await XIM.SendDataAsync("user_002", data, 0, data.Length, convType: 1, flags: 0);

Result result = await XIM.RecallAsync(msg.MsgId);

XIM.OnNewMessage += (Message msg) => {
    Debug.Log($"收到消息: {msg.Content} 来自 {msg.SenderId}");
};

XIM.OnMessageRecalled += (string msgId) => {
    Debug.Log($"消息被撤回: {msgId}");
};

XIM.OnBinaryMessage += (string msgId, string convId, string senderId, byte[] payload, uint flags) => {
    Debug.Log($"收到二进制消息: {payload.Length} bytes");
};

HistoryResult history = await XIM.GetHistoryAsync(
    targetId: "user_002",
    convType: 1,
    beforeTime: DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
    count: 20
);

foreach (Message msg in history.Messages) {
    Debug.Log($"{msg.SenderId}: {msg.Content}");
}

// 获取会话列表
List<Conversation> convs = await XIM.GetConversationsAsync();

// 删除会话
await XIM.DeleteConversationAsync("user_002", convType: 1);

// 标记会话已读
XIM.MarkRead("user_002", convType: 1);

XIM.OnConversationUpdated += (Conversation conv) => {
    Debug.Log($"会话更新: {conv.TargetId} 未读: {conv.UnreadCount}");
};

// 创建群组
GroupInfo group = await XIM.CreateGroupAsync("我的群", new List<string> { "user_002", "user_003" });

// 加入群组
await XIM.JoinGroupAsync("group_001");

// 退出群组
await XIM.LeaveGroupAsync("group_001");

XIM.OnGroupMemberJoined += (string groupId, string userId) => { };
XIM.OnGroupMemberLeft += (string groupId, string userId) => { };
XIM.OnGroupDismissed += (string groupId) => { };

// 加入频道
ChannelInfo channel = await XIM.ChannelJoinAsync("room_001");

// 发送二进制数据
byte[] payload = ...;
XIM.ChannelSend("room_001", payload, 0, payload.Length, reliable: true, contentType: 0);

// 发送文本
XIM.ChannelSendText("room_001", "Hello everyone!");

// 离开频道
await XIM.ChannelLeaveAsync("room_001");

XIM.OnChannelData += (string channelId, string senderId, uint seqNum, byte[] data, uint contentType) => { };
XIM.OnChannelText += (string channelId, string senderId, string text) => { };
XIM.OnChannelMemberJoined += (string channelId, string userId) => { };
XIM.OnChannelMemberLeft += (string channelId, string userId) => { };
XIM.OnChannelDestroyed += (string channelId, string reason) => { };

// 设置自己的资料
UserProfile myProfile = await XIM.SetMyProfileAsync(new UserProfile {
    Nickname = "小明",
    AvatarUrl = "https://example.com/avatar.png"
});

// 批量获取用户资料
List<UserProfile> profiles = await XIM.GetUserProfilesAsync(
    new List<string> { "user_001", "user_002" }
);

// 获取缓存的资料（不发起网络请求）
UserProfile cached = XIM.GetCachedProfile("user_001");

// 获取缓存根目录
string cacheRoot = XIM.CacheDir;

// 获取指定类型缓存目录
string imageDir = XIM.CacheDirForType(CacheType.Image);

// 获取已缓存文件的本地路径（未缓存返回 null）
string path = XIM.GetCachedPath("https://example.com/file.png", CacheType.Image);

// 手动下载文件
string localPath = await XIM.DownloadFileAsync("https://example.com/file.png", CacheType.Image);

// 清除所有缓存
XIM.ClearCache();

// 清除指定类型缓存
XIM.ClearCache(CacheType.Voice);

// 操作结果
public class Result {
    public bool Success;
    public int Code;       // 错误码，0 = 成功
    public string Error;   // 错误信息
}

// 消息
public class Message {
    public string MsgId;
    public string ConvId;
    public string SenderId;
    public int Type;          // 1=文本 2=图片 3=语音 5=二进制
    public string Content;    // 文本内容
    public string FilePath;   // 本地文件路径
    public string FileUrl;    // 远程文件 URL
    public int Duration;      // 语音时长（秒）
    public long Timestamp;    // 服务端时间戳（毫秒）
}

// 会话
public class Conversation {
    public string TargetId;
    public int ConvType;      // 1=单聊 2=群聊
    public Message LastMessage;
    public int UnreadCount;
    public long UpdatedAt;
}

// 群组信息
public class GroupInfo {
    public string GroupId;
    public string Name;
    public string OwnerId;
    public List<string> MemberIds;
}

// 用户资料
public class UserProfile {
    public string Uid;
    public string Nickname;
    public string AvatarUrl;
}

// 频道信息
public class ChannelInfo {
    public string ChannelId;
    public List<string> Members;
}

// 历史消息结果
public class HistoryResult {
    public List<Message> Messages;
    public bool HasMore;
}

// 连接状态
public enum ConnState {
    Disconnected,
    Connecting,
    Connected
}

// 缓存类型
public enum CacheType {
    Image,
    Voice,
    File
}

#include <xim/XIM.h>
using namespace xspace;

target_include_directories(your_target PRIVATE path/to/xim-sdk/include)
target_link_libraries(your_target xim_core)

xspace::Config cfg;
cfg.appId   = "your_app_id";     // 必填
cfg.server  = "ws://x.x.x.x:9090/ws";  // 可选，私有部署时填写
cfg.dataDir = "/path/to/data";   // 可选，本地数据库/缓存目录
cfg.logLevel = xspace::LogLevel::Info;
cfg.autoDownload = true;         // 收到图片/语音自动下载

XIM::init(cfg);

// Cocos2d-x update 回调中
void GameScene::update(float dt) {
    XIM::poll();
}

ConnState state = XIM::connState();
// Disconnected / Connecting / Connected

XIM::login("user_001", "token", [](int code, const std::string& msg) {
    if (code == 0) {
        // 登录成功，自动拉取离线消息
    } else {
        // 登录失败，msg 为错误描述
    }
}, "张三", "https://example.com/avatar.png");

XIM::logout([](int code, const std::string& msg) {
    // 登出完成
});

XIM::on(Event::NewMessages, [](Event evt, const void* data) {
    auto* d = static_cast<const NewMessagesData*>(data);
    for (auto& msg : d->messages) {
        // 处理新消息
    }
});

XIM::on(Event::Connected, [](Event evt, const void* data) {
    // 连接已建立
});

XIM::on(Event::Disconnected, [](Event evt, const void* data) {
    auto* d = static_cast<const DisconnectedData*>(data);
    // d->code, d->reason
});

// 取消监听
XIM::off(Event::NewMessages);

XIM::sendText("user_002", "你好", 1, [](int code, const std::string& err, const Message& msg) {
    if (code == 0) {
        // msg.id 为服务端分配的消息 ID
    }
});

XIM::sendImage("user_002", "/path/to/image.png", 1,
    [](int code, const std::string& err, const Message& msg) {
        // SDK 自动上传图片、获取宽高、封装 content JSON
    });

XIM::sendVoice("user_002", "/path/to/voice.aac", 5, 1,
    [](int code, const std::string& err, const Message& msg) {
        // durationSec=5 表示语音时长 5 秒
    });

uint8_t payload[] = {0x01, 0x02, 0x03};
XIM::sendData("user_002", payload, sizeof(payload), 1, 0,
    [](int code, const std::string& err, const Message& msg) {
        // flags=0 正常持久化; flags=1 不持久化(skip_persist)
    });

XIM::recall("msg_id_xxx", [](int code, const std::string& msg) {
    // 撤回成功后，对方收到 Event::MessageRecalled
});

XIM::markRead("user_002", 1); // convType: 1=单聊 2=群聊

XIM::on(Event::NewMessages, [](Event evt, const void* data) {
    auto* d = static_cast<const NewMessagesData*>(data);
    for (auto& msg : d->messages) {
        if (msg.type == 1) {
            // 文本消息: msg.content
        } else if (msg.type == 2) {
            // 图片消息: msg.content 为 JSON {"url":"...","w":640,"h":480}
        } else if (msg.type == 3) {
            // 语音消息: msg.content 为 JSON {"url":"...","duration":5}
        }
    }
});

// 二进制消息单独事件
XIM::on(Event::BinaryMessage, [](Event evt, const void* data) {
    auto* d = static_cast<const BinaryMessageData*>(data);
    // d->payload, d->payloadLen, d->senderId, d->convId
});

// 消息撤回事件
XIM::on(Event::MessageRecalled, [](Event evt, const void* data) {
    auto* d = static_cast<const MessageIdData*>(data);
    // d->msgId
});

bool AppDelegate::applicationDidFinishLaunching() {
    auto scene = Scene::create();
    scene->scheduleUpdate();  // 开启 update
    // ...
}

void MyScene::update(float dt) {
    XIM::poll();  // 每帧调用，驱动所有回调和事件
}

XIM::getHistory("user_002", 1, 0, 20, [](int code, HistoryResult result) {
    if (code == 0) {
        for (auto& msg : result.messages) {
            // 处理历史消息
        }
        if (result.hasMore) {
            // 还有更多历史消息，可继续拉取
        }
    }
});

int64_t minTime = 0;
bool hasMore = true;

void loadOlder() {
    if (!hasMore) return;
    XIM::getHistory("user_002", 1, minTime, 20, [&](int code, HistoryResult result) {
        if (code == 0 && !result.messages.empty()) {
            minTime = result.messages.front().timestamp;
        }
        hasMore = result.hasMore;
    });
}

// 获取会话列表
XIM::getConversations([](int code, std::vector<Conversation> convs) {
    for (auto& conv : convs) {
        // conv.targetId, conv.name, conv.unreadCount, conv.lastMsg
    }
});

// 删除会话
XIM::deleteConversation("user_002", 1, [](int code, const std::string& msg) {
    // 删除完成
});

// 标记已读
XIM::markRead("user_002", 1);

XIM::on(Event::ConversationUpdated, [](Event evt, const void* data) {
    auto* d = static_cast<const ConversationData*>(data);
    // d->conversation.targetId, d->conversation.unreadCount
});

// 创建群组
XIM::createGroup("我的群", {"user_002", "user_003"}, [](int code, GroupInfo info) {
    if (code == 0) {
        // info.id, info.name, info.memberCount
    }
});

// 加入群组
XIM::joinGroup("g_xxxxxxxx", [](int code, const std::string& msg) {});

// 离开群组
XIM::leaveGroup("g_xxxxxxxx", [](int code, const std::string& msg) {});

XIM::on(Event::GroupMemberJoined, [](Event evt, const void* data) {
    auto* d = static_cast<const GroupEventData*>(data);
    // d->groupId, d->userId
});
XIM::on(Event::GroupMemberLeft, [](Event evt, const void* data) { ... });
XIM::on(Event::GroupDismissed, [](Event evt, const void* data) { ... });

// 加入频道
XIM::channelJoin("room_001", [](int code, ChannelInfo info) {
    // info.channelId, info.memberUids, info.members, info.recentMessages
});

// 发送文本消息（自动 UTF-8 编码，reliable=true）
XIM::channelSendText("room_001", "你好大家");

// 发送二进制数据
uint8_t data[] = {0x01, 0x02};
XIM::channelSend("room_001", data, sizeof(data), false, 0);
// reliable=false 不保证到达；contentType 自定义

// 离开频道
XIM::channelLeave("room_001");

XIM::on(Event::ChannelText, [](Event evt, const void* data) {
    auto* d = static_cast<const ChannelTextEvent*>(data);
    // d->channelId, d->senderId, d->text, d->seqNum, d->timestamp
});

XIM::on(Event::ChannelData, [](Event evt, const void* data) {
    auto* d = static_cast<const ChannelDataEvent*>(data);
    // d->channelId, d->senderId, d->data, d->dataLen, d->contentType
});

XIM::on(Event::ChannelMemberJoined, [](Event evt, const void* data) {
    auto* d = static_cast<const ChannelMemberEvent*>(data);
    // d->channelId, d->userId, d->nickname
});

XIM::on(Event::ChannelMemberLeft, [](Event evt, const void* data) { ... });
XIM::on(Event::ChannelDestroyed, [](Event evt, const void* data) { ... });

// 设置自己的资料
UserProfile profile;
profile.nickname  = "张三";
profile.avatarUrl = "https://example.com/avatar.png";
profile.gender    = 1;  // 0=未知 1=男 2=女
profile.signature = "这是签名";
XIM::setMyProfile(profile, [](int code, const std::string& msg) {});

// 批量获取用户资料
XIM::getUserProfiles({"user_001", "user_002"},
    [](int code, std::vector<UserProfile> profiles) {
        for (auto& p : profiles) {
            // p.uid, p.nickname, p.avatarUrl, p.gender, p.signature, p.moreInfo
        }
    });

// 获取缓存的用户资料（纯本地，无网络请求）
UserProfile cached = XIM::getCachedProfile("user_001");

// 获取缓存根目录
std::string dir = XIM::cacheDir();

// 获取指定类型的缓存目录
std::string imgDir = XIM::cacheDirForType(CacheType::Image);

// 获取某个 URL 的本地缓存路径（未下载时为空字符串）
std::string localPath = XIM::cachedPath("https://oss.example.com/a.jpg", CacheType::Image);

// 手动下载文件到缓存
XIM::downloadFile("https://oss.example.com/a.jpg", CacheType::Image,
    [](int code, const std::string& localPath) {
        if (code == 0) {
            // localPath 为本地文件路径
        }
    });

// 清除所有缓存
XIM::clearCache();

// 清除指定类型缓存
XIM::clearCache(CacheType::Voice);

// 删除单个缓存文件
bool ok = XIM::removeCache("https://oss.example.com/a.jpg", CacheType::Image);

namespace xspace {

// ─── 回调类型 ───
using Callback = std::function<void(int code, const std::string& msg)>;
using SendCallback = std::function<void(int code, const std::string& errMsg,
                                        const Message& msg)>;
using EventHandler = std::function<void(Event evt, const void* data)>;

// ─── 枚举 ───
enum class LogLevel  { Debug, Info, Warn, Error };
enum class ConnState { Disconnected, Connecting, Connected };
enum class CacheType { Image = 0, Voice = 1, File = 2 };

enum class Event {
    Connecting, Connected, Disconnected, KickedOffline,
    NewMessages, MessageRecalled, MessageUpdated,
    ConversationUpdated,
    GroupMemberJoined, GroupMemberLeft, GroupDismissed,
    OnRemoteTalkStart, OnRemoteTalkStop, VoiceData,
    BinaryMessage,
    ChannelData, ChannelMemberJoined, ChannelMemberLeft,
    ChannelDestroyed, ChannelFrameAck, ChannelText,
};

// ─── 配置 ───
struct Config {
    std::string appId;
    std::string server;
    std::string dataDir;
    LogLevel logLevel = LogLevel::Warn;
    bool autoDownload = true;
};

// ─── 数据模型 ───
struct Message {
    std::string id;
    std::string convId;
    std::string targetId;
    std::string senderId;
    int type = 0;             // 1=文本 2=图片 3=语音 4=自定义 5=二进制
    std::string content;
    int64_t timestamp = 0;
    int status = 0;           // 0=发送中 1=成功 2=失败 3=已读
    int64_t seq = 0;
    std::vector<uint8_t> payload;
    uint32_t flags = 0;       // bit0: skip_persist
    std::string extra;        // 开发者自定义扩展 JSON
};

struct Conversation {
    std::string id;
    std::string targetId;
    int type = 0;             // 1=单聊 2=群聊 3=聊天室
    std::string name;
    Message lastMsg;
    int unreadCount = 0;
};

struct GroupInfo {
    std::string id;
    std::string name;
    std::string ownerId;
    int memberCount = 0;
};

struct UserProfile {
    std::string uid;
    std::string nickname;
    std::string avatarUrl;
    int gender = 0;           // 0=未知 1=男 2=女
    std::string signature;
    std::string moreInfo;
};

struct ChannelInfo {
    std::string channelId;
    std::vector<std::string> memberUids;
    std::vector<ChannelMember> members;
    std::string metadata;
    std::vector<ChannelMessage> recentMessages;
};

struct HistoryResult {
    std::vector<Message> messages;
    bool hasMore = false;
};

// ─── 事件数据结构 ───
struct DisconnectedData   { int code; std::string reason; };
struct NewMessagesData    { std::vector<Message> messages; };
struct MessageIdData      { std::string msgId; };
struct ConversationData   { Conversation conversation; };
struct GroupEventData     { std::string groupId; std::string userId; };

struct BinaryMessageData {
    std::string msgId, convId, senderId;
    const uint8_t* payload; size_t payloadLen; uint32_t flags;
};

struct ChannelDataEvent {
    std::string channelId, senderId;
    uint32_t seqNum;
    const uint8_t* data; size_t dataLen;
    bool reliable; int64_t timestamp; uint32_t contentType;
};

struct ChannelTextEvent {
    std::string channelId, senderId, text;
    uint32_t seqNum; int64_t timestamp;
};

struct ChannelMemberEvent {
    std::string channelId, userId, nickname, avatarUrl;
};

struct ChannelDestroyedEvent { std::string channelId, reason; };
struct ChannelFrameAckEvent  { std::string channelId; uint32_t seqNum; };

} // namespace xspace