interface ProtocolConfig {
  appId: string;
  profile: string;
  transports?: TransportsConfig;
  binaryWireEnabled?: boolean;   // default: true
  encryption?: EncryptionConfig;
  group?: GroupConfig;
  dors?: DorsConfig;
  relay?: RelayConfig;
  network?: NetworkConfig;
  reliability?: ReliabilityConfig;
  fileTransfer?: FileTransferConfig;
  path?: PathConfig;
}

interface TransportsConfig {
  ble?: BleTransportConfig;
  internet?: InternetTransportConfig;
  wifiDirect?: WifiDirectTransportConfig;   // Android only
  reticulum?: ReticulumTransportConfig;
  nostr?: NostrTransportConfig;
}

interface BleTransportConfig {
  enabled: boolean;             // required
}

interface InternetTransportConfig {
  enabled: boolean;             // required
  serverAddress?: string;       // WebSocket URL
  autoReconnect?: boolean;
  reconnectDelay?: number;      // ms
  authToken?: string;           // falls back to deviceId
}

interface WifiDirectTransportConfig {
  enabled: boolean;             // required
  deviceName?: string;
  autoAccept?: boolean;
  groupOwnerIntent?: number;    // 0-15, higher = more likely group owner
}

interface ReticulumTransportConfig {
  enabled: boolean;             // required
  daemonAddress?: string;       // default: "localhost:4242"
  autoReconnect?: boolean;      // default: true
  maxReconnectAttempts?: number; // default: 0 (infinite)
}

interface NostrTransportConfig {
  enabled: boolean;             // required
  relayUrls?: string[];         // e.g. ["wss://relay.damus.io"]
  connectionTimeout?: number;   // seconds, default: 30
  autoReconnect?: boolean;      // default: true
  reconnectDelay?: number;      // ms, default: 1000
  maxReconnectAttempts?: number; // default: 0 (infinite)
  sealingEnabled?: boolean;     // default: true
  coldContactEnabled?: boolean; // default: true
}

interface EncryptionConfig {
  enabled?: boolean;                 // default: true
  autoKeyExchange?: boolean;         // default: follows `enabled`
  storePending?: boolean;            // default: follows `enabled`
  requireEncryption?: boolean;       // default: follows `enabled`
  compactEnvelopeEnabled?: boolean;  // default: true
  richPayloadEnabled?: boolean;      // default: true
  cryptoRecoveryEnabled?: boolean;   // default: true
  pendingQueue?: PendingQueueConfig;
}

interface PendingQueueConfig {
  maxPendingPerPeer?: number;  // default: 64
  maxPendingGlobal?: number;   // default: 4096
  pendingTtlMs?: number;       // default: 1800000 (30 minutes)
  overflowPolicy?: 'drop_oldest' | 'drop_newest';  // default: 'drop_oldest'
}

interface GroupConfig {
  maxGroupMembers?: number;        // default: 256
  relayEnabled?: boolean;          // default: true
  relayBroadcastEnabled?: boolean; // default: true
  enforceAdminCommits?: boolean;   // default: false
}

interface DorsConfig {
  preferOnline?: boolean;              // default: false
  switchHysteresis?: number;           // default: 15.0
  switchCooldownSecs?: number;         // default: 20
  bleToWifiRetryThreshold?: number;    // default: 2
  minSuccessRateBeforeEscalation?: number; // default: 0.3
  minBleSamplesBeforeSuccessRateEscalation?: number; // default: 5
  rssiSwitchThreshold?: number;        // default: -85 dBm
  congestionQueueThreshold?: number;   // default: 50
  stabilityWindowSecs?: number;        // default: 8
  poorSignalDurationSecs?: number;     // default: 10
  ttlEscalationThreshold?: number;     // default: 2
  congestionDurationSecs?: number;     // default: 10
  ttlEscalationHoldSecs?: number;      // default: 20
  historyWindowSize?: number;          // default: 10 (clamped to 1-100)
  queueRecoveryRatio?: number;         // default: 0.5 (clamped to 0-1)
}

interface RelayConfig {
  allowRelay?: boolean;          // Allow device to act as relay
  minBatteryForRelay?: number;   // Minimum battery for relaying
  relayThreshold?: number;       // Connection threshold for relay promotion
  relayPriority?: 'never' | 'auto' | 'always';
}

interface NetworkConfig {
  initialTtl?: number;  // default: 8
}

interface ReliabilityConfig {
  ack?: AckConfig;
  retry?: RetryConfig;
  dedup?: DedupConfig;
}

interface AckConfig {
  defaultTimeoutMs?: number;   // default: 5000
  maxPendingAcks?: number;     // default: 1000
}

interface RetryConfig {
  maxRetries?: number;              // default: 5
  initialDelayMs?: number;          // default: 1000
  maxDelayMs?: number;              // default: 30000
  backoffMultiplier?: number;       // default: 2.0
  outboxMaxLifetimeMs?: number;     // default: 604800000 (7 days)
  pendingMessageMaxLifetimeMs?: number; // default: 7 days
}

interface DedupConfig {
  maxTrackedMessages?: number; // default: 10000
  retentionTimeSecs?: number;  // default: 3600
}

interface PathConfig {
  forwardToTopK?: number;        // default: 3
  maxCongestionLevel?: number;   // default: 0.8
}

interface FileTransferConfig {
  chunkSize?: number;    // default: 32768 (32KB)
  maxFileSize?: number;  // default: 104857600 (100MB)
}

interface TelemetryConfig {
  scrubIds?: boolean;          // default: true
  mlsVerbosity?: 'off' | 'lifecycle' | 'diagnostic';  // default: 'lifecycle'
  metricsCadenceMs?: number;   // default: 5000
  routingDiagnostic?: boolean; // default: false
  enablePollQueue?: boolean;   // default: true
  mlsSamplingBypass?: boolean; // default: false
}

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

const protocol = new OfflineProtocol({
  appId: 'my-app',
  profile: 'default',
  transports: {
    ble: { enabled: true },
    internet: {
      enabled: true,
      serverAddress: 'wss://relay.example.com',
      autoReconnect: true,
      authToken: 'your-auth-token',
    },
    nostr: {
      enabled: true,
      relayUrls: ['wss://relay.damus.io'],
    },
  },
  encryption: {
    enabled: true,
    autoKeyExchange: true,
    storePending: true,
    requireEncryption: true,
    pendingQueue: {
      maxPendingPerPeer: 64,
      maxPendingGlobal: 4096,
      pendingTtlMs: 1_800_000,
      overflowPolicy: 'drop_oldest',
    },
  },
  group: {
    maxGroupMembers: 256,
    relayEnabled: true,
  },
  relay: {
    allowRelay: true,
    minBatteryForRelay: 30,
    relayPriority: 'auto',
  },
});