import { describe, expect, test } from 'bun:test'
import {
  parseDirectMemberMessage,
  sendDirectMemberMessage,
} from '../directMemberMessage'

describe('parseDirectMemberMessage', () => {
  test("parses '@agent-name hello world'", () => {
    const result = parseDirectMemberMessage('@agent-name hello world')
    expect(result).toEqual({
      recipientName: 'agent-name',
      message: 'hello world',
    })
  })

  test("parses '@agent-name single-word'", () => {
    const result = parseDirectMemberMessage('@agent-name single-word')
    expect(result).toEqual({
      recipientName: 'agent-name',
      message: 'single-word',
    })
  })

  test('returns null for non-matching input', () => {
    expect(parseDirectMemberMessage('hello world')).toBeNull()
  })

  test('returns null for empty string', () => {
    expect(parseDirectMemberMessage('')).toBeNull()
  })

  test("returns null for '@name' without message", () => {
    expect(parseDirectMemberMessage('@name')).toBeNull()
  })

  test("handles hyphenated agent names like '@my-agent msg'", () => {
    const result = parseDirectMemberMessage('@my-agent msg')
    expect(result).toEqual({ recipientName: 'my-agent', message: 'msg' })
  })

  test('handles multiline message content', () => {
    const result = parseDirectMemberMessage('@agent line1\nline2')
    expect(result).toEqual({ recipientName: 'agent', message: 'line1\nline2' })
  })

  test('extracts correct recipientName and message', () => {
    const result = parseDirectMemberMessage('@alice please fix the bug')
    expect(result?.recipientName).toBe('alice')
    expect(result?.message).toBe('please fix the bug')
  })

  test('trims message whitespace', () => {
    const result = parseDirectMemberMessage('@agent   hello   ')
    expect(result?.message).toBe('hello')
  })
})

describe('sendDirectMemberMessage', () => {
  test('returns error when no team context', async () => {
    const result = await sendDirectMemberMessage('agent', 'hello', null as any)
    expect(result).toEqual({ success: false, error: 'no_team_context' })
  })

  test('returns error for unknown recipient', async () => {
    const teamContext = {
      teamName: 'team1',
      teammates: { alice: { name: 'alice' } },
    }
    const result = await sendDirectMemberMessage(
      'bob',
      'hello',
      teamContext as any,
      async () => {},
    )
    expect(result).toEqual({
      success: false,
      error: 'unknown_recipient',
      recipientName: 'bob',
    })
  })

  test('calls writeToMailbox with correct args for valid recipient', async () => {
    let mailboxArgs: any = null
    const teamContext = {
      teamName: 'team1',
      teammates: { alice: { name: 'alice' } },
    }
    const result = await sendDirectMemberMessage(
      'alice',
      'hello',
      teamContext as any,
      async (recipient, msg, team) => {
        mailboxArgs = { recipient, msg, team }
      },
    )
    expect(result).toEqual({ success: true, recipientName: 'alice' })
    expect(mailboxArgs.recipient).toBe('alice')
    expect(mailboxArgs.msg.text).toBe('hello')
    expect(mailboxArgs.msg.from).toBe('user')
    expect(mailboxArgs.team).toBe('team1')
  })

  test('returns success for valid message', async () => {
    const teamContext = {
      teamName: 'team1',
      teammates: { bob: { name: 'bob' } },
    }
    const result = await sendDirectMemberMessage(
      'bob',
      'test message',
      teamContext as any,
      async () => {},
    )
    expect(result.success).toBe(true)
    if (result.success) {
      expect(result.recipientName).toBe('bob')
    }
  })
})