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

import request from 'supertest'

import { createApp } from '@app/createApp'

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

const app = createApp()

const db = buildPrisma()

const moment = new Date().toISOString()

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

beforeEach(() => cleanupTestDb(db))

async function seedTrigger(

  userId: number,

  overrides: { category?: string; comment?: string } = {}

) {

  return db.trigger.create({

    data: {

      userId,

      moment: new Date(),

      category: (overrides.category ?? 'WORK') as any,

      comment: overrides.comment,

    },

  })

}

describe('POST /triggers', () => {

  it('creates a trigger and returns it', async () => {

    const user = await createTestUser(db)

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

    const res = await request(app)

      .post('/triggers')

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

      .send({

        trigger: {

          moment,

          category: 'SOCIAL',

          comment: 'Reunião difícil',

        },

      })

    expect(res.status).toBe(201)

    expect(res.body.trigger.category).toBe('SOCIAL')

    expect(res.body.trigger.comment).toBe('Reunião difícil')

    const dbRecord = await db.trigger.findFirst({ where: { userId: user.id } })

    expect(dbRecord).not.toBeNull()

  })

  it('returns 400 for missing required fields', async () => {

    const user = await createTestUser(db)

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

    const res = await request(app)

      .post('/triggers')

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

      .send({ trigger: { comment: 'No category or moment' } })

    expect(res.status).toBe(400)

  })

  it('returns 401 without a token', async () => {

    const res = await request(app)

      .post('/triggers')

      .send({ trigger: { moment, category: 'WORK' } })

    expect(res.status).toBe(401)

  })

})

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

  it('returns only the authenticated user\'s triggers', async () => {

    const user = await createTestUser(db)

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

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

    await seedTrigger(user.id, { category: 'WORK' })

    await seedTrigger(user.id, { category: 'FAMILY' })

    await seedTrigger(other.id, { category: 'HEALTH' })

    const res = await request(app)

      .get('/triggers')

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

    expect(res.status).toBe(200)

    expect(res.body.entries).toHaveLength(2)

    expect(res.body.entries.every((t: any) => t.userId === user.id)).toBe(true)

  })

  it('returns an empty list when no triggers exist', async () => {

    const user = await createTestUser(db)

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

    const res = await request(app)

      .get('/triggers')

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

    expect(res.status).toBe(200)

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

    expect(res.body.total).toBe(0)

  })

})

describe('GET /triggers/:id', () => {

  it('returns a single trigger', async () => {

    const user = await createTestUser(db)

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

    const trigger = await seedTrigger(user.id, {

      category: 'INTERNAL', comment: 'Anxious'

    })

    const res = await request(app)

      .get(`/triggers/${trigger.id}`)

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

    expect(res.status).toBe(200)

    expect(res.body.id).toBe(trigger.id)

    expect(res.body.category).toBe('INTERNAL')

    expect(res.body.comment).toBe('Anxious')

  })

})

describe('PUT /triggers/:id', () => {

  it('updates trigger fields', async () => {

    const user = await createTestUser(db)

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

    const trigger = await seedTrigger(user.id, { category: 'WORK' })

    const res = await request(app)

      .put(`/triggers/${trigger.id}`)

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

      .send({ trigger: { category: 'FAMILY', comment: 'Updated' } })

    expect(res.status).toBe(200)

    expect(res.body.trigger.category).toBe('FAMILY')

    expect(res.body.trigger.comment).toBe('Updated')

  })

})

describe('DELETE /triggers/:id', () => {

  it('deletes a trigger', async () => {

    const user = await createTestUser(db)

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

    const trigger = await seedTrigger(user.id)

    const res = await request(app)

      .delete(`/triggers/${trigger.id}`)

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

    expect(res.status).toBe(200)

    const dbRecord = await db.trigger.findUnique({ where: { id: trigger.id } })

    expect(dbRecord).toBeNull()

  })

})

describe('POST /triggers/:triggerId/link-mood', () => {

  it('links a trigger to a mood', async () => {

    const user = await createTestUser(db)

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

    const trigger = await seedTrigger(user.id)

    const mood = await db.mood.create({

      data: {

        userId: user.id,

        selectedMood: 'SAD',

        anxietyLevel: 4,

        stressLevel: 4,

        energyLevel: 2,

        moment: new Date(),

        moodComponents: { create: [{ component: 'FEAR', intensity: 'HIGH' }] },

      },

    })

    const res = await request(app)

      .post(`/triggers/${trigger.id}/link-mood`)

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

      .send({ moodId: mood.id, perceivedImpact: 3 })

    expect(res.status).toBe(201)

    expect(res.body.link.triggerId).toBe(trigger.id)

    expect(res.body.link.moodId).toBe(mood.id)

    expect(res.body.link.perceivedImpact).toBe(3)

  })

  it('returns 400 for invalid perceivedImpact', async () => {

    const user = await createTestUser(db)

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

    const trigger = await seedTrigger(user.id)

    const res = await request(app)

      .post(`/triggers/${trigger.id}/link-mood`)

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

      .send({ moodId: 1, perceivedImpact: 10 })

    expect(res.status).toBe(400)

  })

})

describe('DELETE /triggers/:triggerId/link-mood/:moodId', () => {

  it('unlinks a trigger from a mood', async () => {

    const user = await createTestUser(db)

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

    const trigger = await seedTrigger(user.id)

    const mood = await db.mood.create({

      data: {

        userId: user.id,

        selectedMood: 'SAD',

        anxietyLevel: 3,

        stressLevel: 3,

        energyLevel: 3,

        moment: new Date(),

        moodComponents: { create: [] },

      },

    })

    await db.triggerMoodLink.create({

      data: { triggerId: trigger.id, moodId: mood.id, perceivedImpact: 2 },

    })

    const res = await request(app)

      .delete(`/triggers/${trigger.id}/link-mood/${mood.id}`)

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

    expect(res.status).toBe(200)

    const link = await db.triggerMoodLink.findFirst({

      where: { triggerId: trigger.id, moodId: mood.id },

    })

    expect(link).toBeNull()

  })

})