interface RelayAdapter {
  readonly id: string;
  readonly subjectPrefix: string | readonly string[];
  readonly displayName: string;

  start(relay: RelayPublisher): Promise<void>;
  stop(): Promise<void>;
  deliver(subject: string, envelope: RelayEnvelope, context?: AdapterContext): Promise<DeliveryResult>;
  getStatus(): AdapterStatus;
}

await this.relay.publish(
  'relay.human.slack.U12345',   // subject
  {                              // payload
    content: 'Deploy the backend',
    senderName: 'alice',
    channelType: 'dm',
    responseContext: {
      platform: 'slack',
      maxLength: 4000,
      supportedFormats: ['text', 'markdown'],
      instructions: 'Format responses as Slack markdown.',
    },
  },
  { from: 'relay.human.slack.bot' }  // options
);

async deliver(
  subject: string,
  envelope: RelayEnvelope,
  context?: AdapterContext,
): Promise<DeliveryResult> {
  const start = Date.now();
  const userId = subject.slice(this.subjectPrefix.length + 1);

  if (!userId) {
    return { success: false, error: 'Cannot extract user ID from subject' };
  }

  const content = typeof envelope.payload === 'string'
    ? envelope.payload
    : (envelope.payload as any)?.content ?? JSON.stringify(envelope.payload);

  try {
    await this.client.sendMessage(userId, content);
    this.status.messageCount.outbound++;
    return { success: true, durationMs: Date.now() - start };
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    this.recordError(err);
    return { success: false, error: message, durationMs: Date.now() - start };
  }
}

{
  "adapters": [
    {
      "id": "my-slack-bot",
      "type": "plugin",
      "enabled": true,
      "plugin": {
        "package": "dorkos-slack-adapter"
      },
      "config": {
        "token": "xoxb-...",
        "signingSecret": "abc123..."
      }
    }
  ]
}

import type {
  RelayAdapter,
  RelayPublisher,
  AdapterStatus,
  AdapterContext,
  DeliveryResult,
} from '@dorkos/relay';
import type { RelayEnvelope } from '@dorkos/shared/relay-schemas';

interface SlackConfig {
  token: string;
  signingSecret: string;
  maxMessageLength?: number;
}

const SUBJECT_PREFIX = 'relay.human.slack';
const DEFAULT_MAX_LENGTH = 4000;

export class SlackAdapter implements RelayAdapter {
  readonly id: string;
  readonly subjectPrefix = SUBJECT_PREFIX;
  readonly displayName: string;

  private readonly config: SlackConfig;
  private relay: RelayPublisher | null = null;
  private client: any = null;
  private signalUnsub: (() => void) | null = null;
  private status: AdapterStatus = {
    state: 'disconnected',
    messageCount: { inbound: 0, outbound: 0 },
    errorCount: 0,
  };

  constructor(id: string, config: SlackConfig) {
    this.id = id;
    this.config = config;
    this.displayName = `Slack (${id})`;
  }

  // ---- Lifecycle ----

  async start(relay: RelayPublisher): Promise<void> {
    if (this.client !== null) return; // Already running — idempotent

    this.relay = relay;
    this.status = { ...this.status, state: 'starting' };

    // Dynamic import keeps Slack SDK optional
    const { App } = await import('@slack/bolt');
    this.client = new App({
      token: this.config.token,
      signingSecret: this.config.signingSecret,
    });

    // Handle inbound messages
    this.client.message(async ({ message }: any) => {
      if (!message.text || message.subtype) return;
      await this.handleInbound(message);
    });

    // Subscribe to Relay signals (typing indicators, etc.)
    this.signalUnsub = relay.onSignal(
      `${SUBJECT_PREFIX}.>`,
      (subject, signal) => {
        if (signal.type === 'typing') {
          const userId = subject.slice(SUBJECT_PREFIX.length + 1);
          // Slack does not support typing indicators via API,
          // so this is a no-op. Included for pattern completeness.
        }
      },
    );

    await this.client.start();

    this.status = {
      ...this.status,
      state: 'connected',
      startedAt: new Date().toISOString(),
    };
  }

  async stop(): Promise<void> {
    if (this.client === null) return; // Already stopped — idempotent

    this.status = { ...this.status, state: 'stopping' };

    // Unsubscribe from signals first
    if (this.signalUnsub) {
      this.signalUnsub();
      this.signalUnsub = null;
    }

    try {
      await this.client.stop();
    } catch (err) {
      // Log but do not throw — stop must not fail
      this.recordError(err);
    } finally {
      this.client = null;
      this.relay = null;
      this.status = { ...this.status, state: 'disconnected' };
    }
  }

  // ---- Outbound delivery ----

  async deliver(
    subject: string,
    envelope: RelayEnvelope,
    _context?: AdapterContext,
  ): Promise<DeliveryResult> {
    if (!this.client) {
      return { success: false, error: 'Adapter not started' };
    }

    const start = Date.now();
    const userId = this.extractUserId(subject);
    if (!userId) {
      return {
        success: false,
        error: `Cannot extract user ID from subject: ${subject}`,
      };
    }

    const content = this.extractContent(envelope.payload);
    const maxLen = this.config.maxMessageLength ?? DEFAULT_MAX_LENGTH;
    const truncated = content.length > maxLen
      ? content.slice(0, maxLen - 3) + '...'
      : content;

    try {
      await this.client.client.chat.postMessage({
        channel: userId,
        text: truncated,
      });
      this.status.messageCount.outbound++;
      return { success: true, durationMs: Date.now() - start };
    } catch (err) {
      this.recordError(err);
      const message = err instanceof Error ? err.message : String(err);
      return {
        success: false,
        error: message,
        durationMs: Date.now() - start,
      };
    }
  }

  // ---- Status ----

  getStatus(): AdapterStatus {
    return { ...this.status };
  }

  // ---- Inbound handling ----

  private async handleInbound(message: any): Promise<void> {
    if (!this.relay) return;

    const subject = `${SUBJECT_PREFIX}.${message.user}`;
    const payload = {
      content: message.text,
      senderName: message.user,
      channelType: 'dm' as const,
      responseContext: {
        platform: 'slack',
        maxLength: this.config.maxMessageLength ?? DEFAULT_MAX_LENGTH,
        supportedFormats: ['text', 'markdown'],
        instructions: 'Format responses as Slack mrkdwn syntax.',
      },
      platformData: {
        channelId: message.channel,
        messageTs: message.ts,
        userId: message.user,
      },
    };

    try {
      await this.relay.publish(subject, payload, {
        from: `${SUBJECT_PREFIX}.bot`,
      });
      this.status.messageCount.inbound++;
    } catch (err) {
      this.recordError(err);
    }
  }

  // ---- Helpers ----

  private extractUserId(subject: string): string | null {
    if (!subject.startsWith(SUBJECT_PREFIX)) return null;
    const rest = subject.slice(SUBJECT_PREFIX.length + 1);
    return rest || null;
  }

  private extractContent(payload: unknown): string {
    if (typeof payload === 'string') return payload;
    if (payload && typeof payload === 'object' && 'content' in payload) {
      const content = (payload as Record<string, unknown>).content;
      if (typeof content === 'string') return content;
    }
    return JSON.stringify(payload);
  }

  private recordError(err: unknown): void {
    const message = err instanceof Error ? err.message : String(err);
    this.status = {
      ...this.status,
      state: 'error',
      errorCount: this.status.errorCount + 1,
      lastError: message,
      lastErrorAt: new Date().toISOString(),
    };
  }
}

{
  "adapters": [
    {
      "id": "slack-team",
      "type": "plugin",
      "enabled": true,
      "plugin": { "package": "dorkos-slack-adapter" },
      "config": {
        "token": "xoxb-your-bot-token",
        "signingSecret": "your-signing-secret"
      }
    }
  ]
}