import {
  OfflineProtocol,        // main class (also the default export)
  MeshServices,           // service discovery & RPC
  registerMeshWakeTask,   // Android process-restart hook
} from '@offline-protocol/mesh-sdk';

new OfflineProtocol(config: ProtocolConfig)

protocol.on('message_received', (event) => { /* ... */ });
protocol.on('all', (event) => console.log(event.type));

interface SendMessageParams {
  recipient: string;              // a peer's off1… address
  content: string;
  priority?: MessagePriority;     // default: Medium
  replyToMsg?: string;
  contentType?: ContentType;      // must not be `file_chunk`
  replyContext?: ReplyContext;    // sealed-only
  mediaMetadata?: MediaMetadata;  // sealed-only
  forwardInfo?: ForwardInfo;      // sealed-only
}

interface ForwardMessageParams {
  originalMessageJson: string;
  newRecipient: string;
  priority?: MessagePriority;
}

enum MessagePriority {
  Low = 0,
  Medium = 1,
  High = 2,
  Critical = 3,
}

interface SendConnectionRequestParams {
  recipient: string;
  senderName: string;
  keyPackage?: number[];
  initialMessage?: string;
}

interface AcceptConnectionRequestParams {
  recipient: string;
  accepterName: string;
  keyPackage?: number[];
}

interface RejectConnectionRequestParams { recipient: string }
interface CancelConnectionRequestParams { recipient: string }

interface SendMediaParams {
  recipient: string;
  fileData: string;              // base64
  fileName: string;
  contentType: ContentType;
  mediaMetadata?: MediaMetadata;
  caption?: string;              // sealed-only
  replyToMsg?: string;           // sealed-only
  replyContext?: ReplyContext;   // sealed-only
  forwardInfo?: ForwardInfo;     // sealed-only
  fileId?: string;               // caller-supplied; max 4096 bytes
}

enum ContentType {
  Text = 'text',
  Image = 'image',
  Video = 'video',
  Audio = 'audio',
  VoiceNote = 'voice_note',
  VideoNote = 'video_note',
  File = 'file',
  FileChunk = 'file_chunk',   // internal: rejected in SendMessageParams
  Poll = 'poll',
}

type TransportType = 'ble' | 'internet' | 'wifiDirect' | 'reticulum' | 'nostr';

interface BleDiagnostics {
  fragmentFallbacks: number;        // frames broadcast because the peer was not matched
  recipientNotAmongPeers: number;   // sends naming a peer connected under a different id
  undersizedMtuReports: number;     // peers with an MTU too small for a fragment header
}

type EstablishmentState =
  | 'NoKeyPackage'      // no key package received from the peer
  | 'HaveKeyPackage'    // key package available, session can be created
  | 'SessionPending'    // Welcome sent, awaiting confirmation
  | 'SessionConfirmed'; // session fully established

const group = await protocol.meshCreateGroup('Team Chat');

await protocol.meshInviteToGroup(group.groupId, 'off1q...');

const messageIds = await protocol.meshSendGroupMessage(
  group.groupId,
  'Hello team!',
  'high',
);

protocol.on('group_message_received', (event) => {
  console.log(`${event.sender}: ${event.content}`);
});

await protocol.meshSetMemberRole(group.groupId, 'off1q...', 'admin');

const unsubscribe = await protocol.installTelemetrySink(
  { mlsVerbosity: 'lifecycle', metricsCadenceMs: 5000 },
  (record) => console.log(record.category, record),
);

import { OfflineProtocol, MeshServices } from '@offline-protocol/mesh-sdk';

const protocol = new OfflineProtocol(config);
await protocol.start();

const services = new MeshServices();   // no arguments; requires a started protocol

await services.registerService('translate.v1', '1.0', {
  languages: 'en,es,fr,de',
  format: 'json',
});

protocol.on('service_request_received', async (event) => {
  if (event.service_id !== 'translate.v1') return;

  const { text, targetLang } = JSON.parse(event.body);
  const translated = await translateLocally(text, targetLang);

  await services.respondToServiceRequest(
    event.request_id,
    event.sender,
    event.service_id,
    'ok',
    JSON.stringify({ translated }),
  );
});

const queryId = await services.discoverServices('translate.v1');

protocol.on('service_discovered', (event) => {
  console.log(`Found ${event.service_id} v${event.version} at ${event.provider_peer_id}`);
  console.log(`${event.hop_count} hops away`, event.capabilities);

  services.sendServiceRequest(
    event.provider_peer_id,
    event.service_id,
    'translate',
    JSON.stringify({ text: 'Hello world', targetLang: 'es' }),
  );
});

protocol.on('service_response_received', (event) => {
  if (event.status === 'ok') {
    console.log(JSON.parse(event.body).translated);
  }
});

registerMeshWakeTask(task: (data: MeshWakeTaskData) => Promise<void>): void