Channel Interface

export interface Channel {
  name: string;
  connect(): Promise<void>;
  sendMessage(jid: string, text: string): Promise<void>;
  isConnected(): boolean;
  ownsJid(jid: string): boolean;
  disconnect(): Promise<void>;
  // Optional methods:
  setTyping?(jid: string, isTyping: boolean): Promise<void>;
  syncGroups?(force: boolean): Promise<void>;
}

export type OnInboundMessage = (chatJid: string, message: NewMessage) => void;

interface NewMessage {
  id: string;              // Unique message ID from platform
  chat_jid: string;        // Chat identifier
  sender: string;          // Sender identifier (phone number, user ID, etc.)
  sender_name: string;     // Display name of sender
  content: string;         // Message text
  timestamp: string;       // ISO timestamp
  is_from_me?: boolean;    // True if sent by the bot itself
  is_bot_message?: boolean; // True if sent by another bot
}

export type OnChatMetadata = (
  chatJid: string,
  timestamp: string,
  name?: string,
  channel?: string,
  isGroup?: boolean,
) => void;

import { Channel, OnInboundMessage, OnChatMetadata } from '../types.js';
import { ChannelOpts } from './registry.js';

export class ExampleChannel implements Channel {
  name = 'example';
  private client: any = null;
  private opts: ChannelOpts;

  constructor(opts: ChannelOpts) {
    this.opts = opts;
  }

  async connect(): Promise<void> {
    // Initialize client
    this.client = await createExampleClient();

    // Set up message handler
    this.client.on('message', (msg: any) => {
      this.opts.onMessage(msg.chatId, {
        id: msg.id,
        chat_jid: msg.chatId,
        sender: msg.from,
        sender_name: msg.fromName,
        content: msg.text,
        timestamp: new Date().toISOString(),
      });
    });

    // Connect to platform
    await this.client.connect();
  }

  async sendMessage(jid: string, text: string): Promise<void> {
    await this.client.send(jid, text);
  }

  isConnected(): boolean {
    return this.client?.connected ?? false;
  }

  ownsJid(jid: string): boolean {
    return jid.startsWith('example:');
  }

  async disconnect(): Promise<void> {
    await this.client?.disconnect();
    this.client = null;
  }

  // Optional: typing indicator
  async setTyping(jid: string, isTyping: boolean): Promise<void> {
    await this.client.setTyping(jid, isTyping);
  }

  // Optional: sync groups
  async syncGroups(force: boolean): Promise<void> {
    const chats = await this.client.getChats();
    for (const chat of chats) {
      this.opts.onChatMetadata(
        chat.id,
        new Date().toISOString(),
        chat.name,
        'example',
        chat.isGroup
      );
    }
  }
}