import { instantMessaging, encryption } from "@kynesyslabs/demosdk"

const { L2PSMessagingPeer } = instantMessaging
const unifiedCrypto = encryption.ucrypto

// Pseudocode — replace with your own ed25519 signer.
// Must return a hex-encoded ed25519 signature of `message`.
const signFn = async (message: string): Promise<string> => {
    // e.g. delegate to your wallet, KMS, or a local @noble/curves signer
    return await myEd25519.signHex(message)
}

const myEd25519PublicKeyHex = await myEd25519.getPublicKeyHex()

const peer = new L2PSMessagingPeer({
    serverUrl: "ws://your-demos-node:3006",
    publicKey: myEd25519PublicKeyHex,
    l2psUid: "your-l2ps-network-uid",
    signFn,
})

const registered = await peer.connect()
// registered: { success, publicKey, l2psUid, onlinePeers }
console.log("Online peers in this L2PS network:", registered.onlinePeers)

peer.onMessage(payload => {
    // payload: { from, encrypted: SerializedEncryptedMessage, messageHash, offline? }
    console.log("Got message from", payload.from, "offline?", payload.offline)
    // Decrypt payload.encrypted with your ML-KEM private key here.
})

peer.onError(err => {
    // err: { code: ErrorCode, message: string, details?: string }
    console.error("L2PS error:", err.code, err.message)
})

peer.onPeerJoined(publicKey => console.log("peer joined:", publicKey))
peer.onPeerLeft(publicKey => console.log("peer left:", publicKey))
peer.onConnectionStateChange(state => console.log("state:", state))

import type { SerializedEncryptedMessage } from "@kynesyslabs/demosdk" // re-exported from instantMessaging

// Minimal example — ciphertext and nonce are base64.
const encrypted: SerializedEncryptedMessage = {
    ciphertext: "<base64 ciphertext from your ml-kem-aes encrypt step>",
    nonce: "<base64 AES-GCM nonce>",
    // ephemeralKey: "<hex>" // only when using X25519 ephemeral DH
}

const messageHash = "<sha256 hex of plaintext or canonical envelope>"

const result = await peer.send(recipientPublicKeyHex, encrypted, messageHash)
// result is either:
//   { messageHash, l2psStatus: "submitted" | "failed" }   // message_sent
//   { messageHash, status: "queued" }                     // message_queued (recipient offline)

const page = await peer.history(recipientPublicKeyHex, {
    before: Date.now(), // optional: paginate backward from this ms timestamp
    limit: 50,          // optional
})
// page: { messages: StoredMessage[], hasMore: boolean }

const peers = await peer.discover()              // string[] of online peer public keys
const pk = await peer.requestPublicKey("alice")  // string | null

peer.disconnect()

import { instantMessaging, encryption } from "@kynesyslabs/demosdk"
const unifiedCrypto = encryption.ucrypto

await unifiedCrypto.generateAllIdentities(masterSeed)
const mlKemAes = await unifiedCrypto.getIdentity("ml-kem-aes")

const peer = new instantMessaging.MessagingPeer({
    serverUrl: "ws://your-signaling-server:3005",
    clientId: "user-" + Date.now(),
    publicKey: mlKemAes.publicKey,
})

await peer.connect()
peer.onMessage((message, fromId) => console.log(`Message from ${fromId}:`, message))
const peers = await peer.discoverPeers()
await peer.sendMessage(peers[0], "Hello!")