import { ErebusClient, ErebusClientState } from "@erebus-sh/sdk/client";

// Create client
const client = ErebusClient.createClient({
  client: ErebusClientState.PubSub,
  authBaseUrl: "https://your-auth.com",
  wsBaseUrl: "wss://gateway.erebus.sh" // optional
});

// Connect
client.joinChannel("my-channel");
await client.connect();

// Disconnect
client.close();

await client.subscribe("topic", (msg) => {
  console.log(msg.payload);
});

// Without ack
await client.publish("topic", "Hello!");

// With ack
await client.publishWithAck(
  "topic",
  "Hello!",
  (ack) => console.log(ack.success ? "Success" : `Failed: ${ack.error?.message}`),
  3000 // timeout
);

client.unsubscribe("topic");

// Subscribe with ACK and options
client.subscribeWithCallback(
  "topic",
  (msg) => console.log(msg.payload),
  (response) => console.log("Subscribed:", response.success),
  10000,
  { streamOldMessages: true }
);

// Unsubscribe with ACK
client.unsubscribeWithCallback(
  "topic",
  (response) => console.log("Unsubscribed:", response.success)
);

const history = await client.getHistory("topic");
// Returns 50 newest messages by default

const page1 = await client.getHistory("topic", {
  limit: 20,
  direction: "backward"
});

const page2 = await client.getHistory("topic", {
  cursor: page1.nextCursor,
  limit: 20,
  direction: "backward"
});

const getNext = client.createHistoryIterator("topic", { limit: 50 });
const batch1 = await getNext(); // { items: [...], hasMore: true }
const batch2 = await getNext(); // { items: [...], hasMore: false }
const done = await getNext();   // null

let cursor = null;
const all = [];

do {
  const page = await client.getHistory("topic", {
    cursor,
    limit: 1000
  });
  all.push(...page.items);
  cursor = page.nextCursor;
} while (cursor);

await client.onPresence("topic", (presence) => {
  console.log(presence.clientId, presence.status);
  // status: "online" | "offline"
});

client.offPresence("topic", handler);
client.clearPresenceHandlers("topic"); // all handlers

import { ErebusPubSubSchemas } from "@erebus-sh/sdk/client";
import { z } from "zod";

const schemas = {
  chat: z.object({
    text: z.string(),
    username: z.string(),
  }),
};

const typed = new ErebusPubSubSchemas(client, schemas);

typed.publish("chat", "room-1", {
  text: "Hello!",
  username: "Alice"
});

await typed.subscribe("chat", "room-1", (msg) => {
  console.log(msg.payload.text);     // ✅ string
  console.log(msg.payload.username); // ✅ string
});

const history = await typed.getHistory("chat", "room-1");
history.items.forEach(msg => {
  console.log(msg.payload.text); // ✅ validated & typed
});

// Connection state checks
client.isConnected  // boolean - WebSocket connected
client.isReadable   // boolean - Can receive messages  
client.isWritable   // boolean - Can send messages

// Connection management
await client.connect(10000); // with timeout
client.close(); // graceful shutdown

// Monitor connection state
setInterval(() => {
  if (!client.isConnected) {
    console.log("Connection lost - SDK will reconnect automatically");
  }
}, 5000);

interface MessageBody {
  id: string;           // Unique message ID
  topic: string;        // Topic name
  senderId: string;     // Sender's client ID
  seq: string;          // Sequence (ULID)
  sentAt: Date;         // Timestamp
  payload: string;      // Message content
  clientMsgId?: string; // Optional correlation ID
}

async function connectWithRetry(maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      await client.connect();
      return;
    } catch (error) {
      await new Promise(r => setTimeout(r, 1000 * (i + 1)));
    }
  }
  throw new Error("Failed to connect");
}

const lastSeq = localStorage.getItem("lastSeq");
const missed = await client.getHistory("topic", {
  cursor: lastSeq || undefined,
  direction: "forward"
});

missed.items.forEach(msg => process(msg));

await client.subscribe("topic", (msg) => {
  process(msg);
  localStorage.setItem("lastSeq", msg.seq);
});

let cursor = null;

async function loadMore() {
  const history = await client.getHistory("topic", {
    cursor,
    limit: 20
  });
  
  history.items.forEach(msg => appendToUI(msg));
  cursor = history.nextCursor;
  
  if (!cursor) {
    hideLoadMoreButton();
  }
}

try {
  await client.connect();
} catch (error) {
  if (error.message.includes("Channel must be set")) {
    // Call joinChannel() first
  } else if (error.message.includes("timeout")) {
    // Connection timeout
  }
}