// @vitest-environment node
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { db } from '@/lib/db'
import { visibleChannelWhere, visibleMessageWhere } from '@/lib/access/chatFilter'
import { adoptAsEntry, listMessages, sendMessage } from '@/lib/chat/service'
import { resolveCasePreviews } from '@/lib/chat/preview'
import { AccessError } from '@/lib/errors'
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'

/**
 * Der Chat erbt die Sichtbarkeit seines Ortes. Der heikelste Teil ist die
 * Vorschaukarte: ein Aktenzeichen im Text darf einem zu niedrig eingestuften
 * Leser nichts über die Akte verraten — auch nicht, ob es sie gibt.
 */
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
const suite = url ? describe : describe.skip

const marke = `chat-${Date.now()}`

function perms(
  userId: string,
  clearanceLevel: number,
  options: { isAdmin?: boolean; permissions?: Permission[] } = {},
): EffectivePermissions {
  return {
    userId,
    clearanceLevel,
    permissions: new Set<Permission>(options.permissions ?? []),
    isAdmin: options.isAdmin ?? false,
    hasMembership: true,
  }
}

suite('Aktenchat und Kanäle', () => {
  const nutzer = { stufe1: `${marke}-stufe1`, stufe4: `${marke}-stufe4` }
  let offenNummer = ''
  let geheimNummer = ''
  let offenId = ''
  let geheimId = ''
  let kanalOffen = ''
  let kanalGeheim = ''

  beforeAll(async () => {
    const vorlage = await db.documentTemplate.create({
      data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
    })
    for (const id of Object.values(nutzer)) {
      await db.user.create({ data: { id, username: id, displayName: id } })
    }

    const gemeinsam = {
      templateId: vorlage.id,
      templateKey: vorlage.key,
      createdById: nutzer.stufe4,
    }
    const offen = await db.case.create({
      data: {
        ...gemeinsam,
        caseNumber: `Chat-2026-${String(Date.now()).slice(-4)}`,
        title: 'Offener Vorgang',
        classification: 1,
        status: 'OPEN',
      },
    })
    const geheim = await db.case.create({
      data: {
        ...gemeinsam,
        caseNumber: `Gehm-2026-${String(Date.now()).slice(-4)}`,
        title: 'Streng vertraulich',
        classification: 4,
        status: 'OPEN',
      },
    })
    offenNummer = offen.caseNumber
    geheimNummer = geheim.caseNumber
    offenId = offen.id
    geheimId = geheim.id

    const k1 = await db.channel.create({
      data: {
        key: `${marke}-allgemein`.slice(0, 40),
        name: 'Allgemein',
        minClearance: 0,
        createdById: nutzer.stufe4,
      },
    })
    const k2 = await db.channel.create({
      data: {
        key: `${marke}-leitung`.slice(0, 40),
        name: 'Leitung',
        minClearance: 4,
        createdById: nutzer.stufe4,
      },
    })
    kanalOffen = k1.key
    kanalGeheim = k2.key
  })

  afterAll(async () => {
    await db.$disconnect()
  })

  it('verbirgt den Chat einer zu hoch eingestuften Akte', async () => {
    await sendMessage(perms(nutzer.stufe4, 4), {
      id: `${marke}-geheim-1`,
      scope: { kind: 'case', caseNumber: geheimNummer },
      body: 'Interner Stand',
    })

    // Nicht "leere Liste", sondern: es gibt den Ort für ihn nicht.
    await expect(
      listMessages(perms(nutzer.stufe1, 1), { kind: 'case', caseNumber: geheimNummer }),
    ).rejects.toThrow(AccessError)

    const sichtbar = await db.chatMessage.findMany({
      where: { AND: [visibleMessageWhere(perms(nutzer.stufe1, 1)), { caseId: geheimId }] },
      select: { id: true },
    })
    expect(sichtbar).toHaveLength(0)
  })

  it('verbirgt einen Kanal über der eigenen Stufe', async () => {
    const kanaele = await db.channel.findMany({
      where: {
        AND: [
          visibleChannelWhere(perms(nutzer.stufe1, 1)),
          { key: { in: [kanalOffen, kanalGeheim] } },
        ],
      },
      select: { key: true },
    })
    expect(kanaele.map((k) => k.key)).toEqual([kanalOffen])
  })

  it('verrät über die Vorschaukarte nichts über eine verborgene Akte', async () => {
    const fuerStufe1 = await resolveCasePreviews(perms(nutzer.stufe1, 1), [
      offenNummer,
      geheimNummer,
      'AfiS-1999-0001',
    ])

    // Sichtbar: mit Titel. Verborgen: ohne alles — und genauso wie eine Akte,
    // die es gar nicht gibt.
    expect(fuerStufe1.get(offenNummer)).toMatchObject({ visible: true, title: 'Offener Vorgang' })
    expect(fuerStufe1.get(geheimNummer)).toEqual({ caseNumber: geheimNummer, visible: false })
    expect(fuerStufe1.get('AfiS-1999-0001')).toEqual({
      caseNumber: 'AfiS-1999-0001',
      visible: false,
    })

    const fuerStufe4 = await resolveCasePreviews(perms(nutzer.stufe4, 4), [geheimNummer])
    expect(fuerStufe4.get(geheimNummer)).toMatchObject({ visible: true })
  })

  it('behandelt dieselbe Kennung zweimal gesendet als eine Nachricht', async () => {
    const id = `${marke}-doppelt`
    const scope = { kind: 'case' as const, caseNumber: offenNummer }

    await sendMessage(perms(nutzer.stufe1, 1), { id, scope, body: 'Einmal' })
    await sendMessage(perms(nutzer.stufe1, 1), { id, scope, body: 'Nochmal' })

    const treffer = await db.chatMessage.findMany({ where: { id }, select: { body: true } })
    expect(treffer).toHaveLength(1)
    // Der erste Text bleibt: das zweite Absenden war ein Wiederholungsversuch,
    // keine Änderung.
    expect(treffer[0]?.body).toBe('Einmal')
  })

  it('löst Erwähnungen serverseitig auf', async () => {
    const id = `${marke}-erwaehnung`
    await sendMessage(perms(nutzer.stufe4, 4), {
      id,
      scope: { kind: 'case', caseNumber: offenNummer },
      // Der zweite Name gibt es nicht — er darf nicht in mentions landen.
      body: `Bitte schauen @${nutzer.stufe1} und @niemand`,
    })

    const nachricht = await db.chatMessage.findUniqueOrThrow({
      where: { id },
      select: { mentions: true },
    })
    expect(nachricht.mentions).toEqual([nutzer.stufe1])
  })

  it('macht aus einer Nachricht einen Vermerk und lässt sie stehen', async () => {
    const id = `${marke}-uebernahme`
    const p = perms(nutzer.stufe4, 4, { permissions: ['entry.create', 'case.edit'] })
    await sendMessage(p, {
      id,
      scope: { kind: 'case', caseNumber: offenNummer },
      body: 'Der Zeuge widerruft seine Aussage.',
    })

    const { entryId } = await adoptAsEntry(p, id)

    const eintrag = await db.caseEntry.findUniqueOrThrow({ where: { id: entryId } })
    expect(eintrag.body).toBe('Der Zeuge widerruft seine Aussage.')
    // Der Vermerk gehört dem Verfasser, nicht dem, der ihn übernommen hat.
    expect(eintrag.authorId).toBe(nutzer.stufe4)
    expect(eintrag.type).toBe('NOTE')

    const nachricht = await db.chatMessage.findUniqueOrThrow({ where: { id } })
    expect(nachricht.adoptedEntryId).toBe(entryId)

    // Ein Systemeintrag nennt den Ursprung, damit später niemand denkt, der
    // Wortlaut sei für die Akte geschrieben worden.
    const hinweis = await db.caseEntry.findFirst({
      where: { caseId: offenId, type: 'SYSTEM', body: { contains: 'Aktenchat' } },
      select: { id: true },
    })
    expect(hinweis).not.toBeNull()

    // Zweimal übernehmen erzeugt keinen zweiten Vermerk.
    expect((await adoptAsEntry(p, id)).entryId).toBe(entryId)
  })

  it('macht aus einer Kanalnachricht keinen Vermerk', async () => {
    const id = `${marke}-kanal`
    const p = perms(nutzer.stufe4, 4, { permissions: ['entry.create', 'case.edit'] })
    await sendMessage(p, { id, scope: { kind: 'channel', key: kanalOffen }, body: 'Absprache' })

    // Ein Vermerk gehört in eine Akte. Ein Kanal hat keine.
    await expect(adoptAsEntry(p, id)).rejects.toThrow(AccessError)
  })
})