import { describe, it, expect, afterAll, beforeEach } from 'vitest'

import request from 'supertest'

import { NotificationKind } from '@prisma/client'

import { createApp } from '@app/createApp'

import { buildPrisma, cleanupTestDb, createTestUser, generateTestToken } from '../test-helper'

const app = createApp()

const db = buildPrisma()

afterAll(() => db.$disconnect())

beforeEach(() => cleanupTestDb(db))

async function seedNotification(

  userId: number,

  overrides: {

    kind?: NotificationKind

    title?: string

    body?: string

    scheduledFor?: Date

    regimenId?: number

  } = {},

) {

  return db.notification.create({

    data: {

      userId,

      kind: overrides.kind ?? NotificationKind.DAILY_REMINDER,

      title: overrides.title ?? 'Como você está?',

      body: overrides.body ?? 'Registre seu humor para acompanhar sua saúde.',

      scheduledFor: overrides.scheduledFor ?? new Date(),

      regimenId: overrides.regimenId ?? null,

    },

  })

}

describe('GET /notifications', () => {

  it('requires authentication', async () => {

    const res = await request(app).get('/notifications')

    expect(res.status).toBe(401)

  })

  it('returns an empty page when the user has none', async () => {

    const user = await createTestUser(db)

    const token = generateTestToken(user.id, user.email)

    const res = await request(app)

      .get('/notifications')

      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)

    expect(res.body.notifications).toEqual([])

    expect(res.body.nextCursor).toBeNull()

  })

  it("returns the user's notifications newest first", async () => {

    const user = await createTestUser(db)

    const token = generateTestToken(user.id, user.email)

    const first = await seedNotification(user.id, { title: 'Primeira' })

    const second = await seedNotification(user.id, { title: 'Segunda' })

    const third = await seedNotification(user.id, { title: 'Terceira' })

    const res = await request(app)

      .get('/notifications')

      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)

    expect(res.body.notifications.map((n: { id: number }) => n.id)).toEqual([

      third.id,

      second.id,

      first.id,

    ])

  })

  it("never returns another user's notifications", async () => {

    const user = await createTestUser(db)

    const other = await createTestUser(db, { email: 'other@example.com' })

    const token = generateTestToken(user.id, user.email)

    await seedNotification(user.id, { title: 'Minha' })

    await seedNotification(other.id, { title: 'Dele' })

    const res = await request(app)

      .get('/notifications')

      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)

    expect(res.body.notifications).toHaveLength(1)

    expect(res.body.notifications[0].title).toBe('Minha')

  })

  it('pages newest first with a cursor', async () => {

    const user = await createTestUser(db)

    const token = generateTestToken(user.id, user.email)

    const oldest = await seedNotification(user.id, { title: 'Mais antiga' })

    const middle = await seedNotification(user.id, { title: 'Do meio' })

    const newest = await seedNotification(user.id, { title: 'Mais nova' })

    const firstPage = await request(app)

      .get('/notifications?limit=2')

      .set('Authorization', `Bearer ${token}`)

    expect(firstPage.status).toBe(200)

    expect(firstPage.body.notifications.map((n: { id: number }) => n.id)).toEqual([

      newest.id,

      middle.id,

    ])

    expect(firstPage.body.nextCursor).toBe(middle.id)

    const secondPage = await request(app)

      .get(`/notifications?limit=2&cursor=${firstPage.body.nextCursor}`)

      .set('Authorization', `Bearer ${token}`)

    expect(secondPage.status).toBe(200)

    expect(secondPage.body.notifications.map((n: { id: number }) => n.id)).toEqual([

      oldest.id,

    ])

    expect(secondPage.body.nextCursor).toBeNull()

  })

  it('serializes only the fields the inbox needs', async () => {

    const user = await createTestUser(db)

    const token = generateTestToken(user.id, user.email)

    await seedNotification(user.id, { title: 'Como você está?' })

    const res = await request(app)

      .get('/notifications')

      .set('Authorization', `Bearer ${token}`)

    const [notification] = res.body.notifications

    expect(notification).toMatchObject({

      kind: 'DAILY_REMINDER',

      title: 'Como você está?',

      body: 'Registre seu humor para acompanhar sua saúde.',

      regimenId: null,

    })

    expect(notification).not.toHaveProperty('userId')

    expect(notification).not.toHaveProperty('pushedAt')

  })

  it('rejects an out-of-range limit', async () => {

    const user = await createTestUser(db)

    const token = generateTestToken(user.id, user.email)

    const res = await request(app)

      .get('/notifications?limit=0')

      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(400)

  })

})