import { expect, test } from '@playwright/test'
import { PrismaClient } from '@prisma/client'
import { anmelden } from './hilfen'

/**
 * Der Rückkaufswert am Vertrag — gegen die echte Anwendung.
 *
 * Die Zusage, die hier geprüft wird: Der Wert steht dort, wo man ihn
 * braucht, sein Stichtag steht daneben, ein alter Wert ist als alt
 * erkennbar — und es ist derselbe Wert, den das Vermögensverzeichnis
 * ausweist, nicht ein zweiter danebengelegter.
 */

const KENNUNG = 'Prüfhausen Wert'

async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
  const db = new PrismaClient()
  try {
    return await arbeit(db)
  } finally {
    await db.$disconnect()
  }
}

async function aufraeumen(): Promise<void> {
  await mitDb(async (db) => {
    await db.vermoegensposten.deleteMany({ where: { bezeichnung: { contains: KENNUNG } } })
    await db.vertrag.deleteMany({ where: { bezeichnung: { contains: KENNUNG } } })
  })
}

/** Tag vor N Tagen, als reines Datum. */
function vorTagen(tage: number): Date {
  const heute = new Date()
  const ziel = new Date(Date.UTC(heute.getFullYear(), heute.getMonth(), heute.getDate()))
  ziel.setUTCDate(ziel.getUTCDate() - tage)
  return ziel
}

test.describe('Rückkaufswert am Vertrag', () => {
  test.beforeAll(async () => {
    await aufraeumen()
    await mitDb(async (db) => {
      const betreute = await db.betreute.findMany({
        where: { geloeschtAm: null },
        select: { id: true },
      })
      for (const person of betreute) {
        // Ein Vertrag mit frischem Wert, einer mit einem zwei Jahre alten,
        // einer ohne jeden Wert.
        const frisch = await db.vertrag.create({
          data: {
            betreuteId: person.id,
            bezeichnung: `${KENNUNG} Frisch`,
            gesellschaft: `${KENNUNG} Leben AG`,
            art: 'LEBENSVERSICHERUNG',
            status: 'AKTIV',
          },
        })
        const alt = await db.vertrag.create({
          data: {
            betreuteId: person.id,
            bezeichnung: `${KENNUNG} Alt`,
            gesellschaft: `${KENNUNG} Sterbekasse`,
            art: 'STERBEGELDVERSICHERUNG',
            status: 'AKTIV',
          },
        })
        await db.vertrag.create({
          data: {
            betreuteId: person.id,
            bezeichnung: `${KENNUNG} Ohne`,
            gesellschaft: `${KENNUNG} Renten AG`,
            art: 'RENTENVERSICHERUNG_PRIVAT',
            status: 'AKTIV',
          },
        })

        await db.vermoegensposten.create({
          data: {
            betreuteId: person.id,
            vertragId: frisch.id,
            art: 'VERSICHERUNG',
            bezeichnung: `${KENNUNG} Frisch`,
            wertstaende: {
              create: [
                {
                  stichtag: vorTagen(30),
                  wertCent: 521055n,
                  wertquelle: 'Rückkaufswertmitteilung',
                },
                { stichtag: vorTagen(400), wertCent: 480000n, wertquelle: 'Jahresmitteilung' },
              ],
            },
          },
        })

        // Bewusst als „Sonstiges" verknüpft: Die Zuordnung zum Vertrag
        // hängt an der Verknüpfung, nicht an der Art des Postens.
        await db.vermoegensposten.create({
          data: {
            betreuteId: person.id,
            vertragId: alt.id,
            art: 'SONSTIGES',
            bezeichnung: `${KENNUNG} Alt`,
            wertstaende: {
              create: [
                { stichtag: vorTagen(800), wertCent: 310000n, wertquelle: 'Jahresmitteilung' },
              ],
            },
          },
        })
      }
    })
  })

  test.afterAll(async () => {
    await aufraeumen()
  })

  test('zeigt Wert und Stichtag in der Vertragsübersicht', async ({ page }) => {
    await anmelden(page)
    await page.goto('/vertraege')

    const inhalt = await page.locator('body').innerText()
    expect(inhalt).toContain('5.210,55')
    // Ohne Wert bleibt die Zelle nicht leer, sondern sagt es.
    expect(inhalt).toContain('noch nicht erfasst')
  })

  test('kennzeichnet einen über ein Jahr alten Wert', async ({ page }) => {
    await anmelden(page)
    await page.goto('/vertraege')

    // Der 800 Tage alte Wert des „Alt"-Vertrags trägt das Abzeichen …
    await expect(page.getByText('über ein Jahr alt').first()).toBeVisible()

    // … und er wird trotz Posten-Art „Sonstiges" überhaupt gefunden.
    expect(await page.locator('body').innerText()).toContain('3.100,00')
  })

  test('zeigt am Vertrag den letzten Wert und die Historie', async ({ page }) => {
    await anmelden(page)
    await page.goto('/vertraege')
    await page.getByRole('link', { name: `${KENNUNG} Frisch` }).click()
    await page.waitForURL(/\/vertraege\/[a-z0-9]+$/)
    await expect(page.getByText('Zuletzt mitgeteilt')).toBeVisible()

    const inhalt = await page.locator('body').innerText()
    expect(inhalt).toContain('Zuletzt mitgeteilt')
    expect(inhalt).toContain('5.210,55')
    // Der frühere Wert bleibt abrufbar — die Entwicklung ist die Aussage.
    expect(inhalt).toContain('4.800,00')
  })

  test('trägt einen neuen Wert am Vertrag ein — sichtbar auch im Vermögensverzeichnis', async ({
    page,
  }) => {
    await anmelden(page)
    await page.goto('/vertraege')
    await page.getByRole('link', { name: `${KENNUNG} Ohne` }).click()
    await page.waitForURL(/\/vertraege\/[a-z0-9]+$/)

    await page.getByRole('button', { name: 'Mitgeteilten Wert eintragen' }).click()
    await page.locator('input[name="stichtag"]').last().fill('2026-08-01')
    await page.locator('input[name="wert"]').fill('1.234,56')
    await page.getByRole('button', { name: 'Wert aufnehmen' }).click()

    await expect(page.getByText('Rückkaufswert in die Historie aufgenommen.')).toBeVisible()
    expect(await page.locator('body').innerText()).toContain('1.234,56')

    // Dieselbe Zahl, eine Quelle: Das Vermögensverzeichnis kennt sie auch.
    await page.goto('/finanzen/vermoegen?stichtag=2026-08-31')
    expect(await page.locator('body').innerText()).toContain('1.234,56')
  })
})