import { describe, it, expect, afterAll, beforeEach } from 'vitest'
import request from 'supertest'
import { format } from 'date-fns'
import { tz } from '@date-fns/tz'
import { createApp } from '@app/createApp'
import { InsightPeriod, InsightType } from '@prisma/client'
import { appDayWindow } from '@app/lib/queue/processors/insights/utils'
import {
  buildPrisma,
  cleanupTestDb,
  createTestUser,
  generateTestToken,
} from '../test-helper'

const app = createApp()
const db = buildPrisma()
const SP = tz('America/Sao_Paulo')

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

// The YYYY-MM-DD key the read endpoint expects for the app day containing date
function appDayKey(date: Date) {
  return format(date, 'yyyy-MM-dd', { in: SP })
}

let seedCounter = 0
// The schema is unique on (userId, type, periodStart), so give every seeded
// row a distinct periodStart unless the test asks for a specific one
function uniquePeriodStart() {
  seedCounter += 1
  return new Date(Date.UTC(2026, 0, 1) + seedCounter * 60 * 1000)
}

async function seedInsight(
  userId: number,
  overrides: {
    type?: InsightType
    period?: InsightPeriod
    periodStart?: Date
    generatedAt?: Date
    title?: string
  } = {}
) {
  seedCounter += 1

  return db.insight.create({
    data: {
      userId,
      type: overrides.type ?? InsightType.MOOD_TREND,
      period: overrides.period ?? InsightPeriod.WEEKLY,
      title: overrides.title ?? `Insight ${seedCounter}`,
      body: 'Generated by the insight worker',
      periodStart: overrides.periodStart ?? uniquePeriodStart(),
      periodEnd: new Date(),
      generatedAt: overrides.generatedAt,
    },
  })
}

describe('GET /insights', () => {
  it('returns only the authenticated user\'s insights, newest first', async () => {
    const user = await createTestUser(db)
    const other = await createTestUser(db, { email: 'other@example.com' })
    const token = generateTestToken(user.id, user.email)

    await seedInsight(user.id, { title: 'oldest', generatedAt: new Date('2026-01-01') })
    await seedInsight(user.id, { title: 'newest', generatedAt: new Date('2026-03-01') })
    await seedInsight(user.id, { title: 'middle', generatedAt: new Date('2026-02-01') })
    await seedInsight(other.id, { title: 'not-mine' })

    const res = await request(app)
      .get('/insights')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toHaveLength(3)
    expect(res.body.insights.every((i: any) => i.userId === user.id)).toBe(true)
    expect(res.body.insights.map((i: any) => i.title)).toEqual([
      'newest',
      'middle',
      'oldest',
    ])
  })

  it('returns an empty list when the user has no insights', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    const res = await request(app)
      .get('/insights')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toEqual([])
  })

  it('filters by type', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    await seedInsight(user.id, { type: InsightType.MOOD_TREND })
    await seedInsight(user.id, { type: InsightType.STREAK })
    await seedInsight(user.id, { type: InsightType.STREAK })

    const res = await request(app)
      .get('/insights?type=STREAK')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toHaveLength(2)
    expect(res.body.insights.every((i: any) => i.type === 'STREAK')).toBe(true)
  })

  it('filters by period', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    await seedInsight(user.id, { period: InsightPeriod.DAILY })
    await seedInsight(user.id, { period: InsightPeriod.MONTHLY })
    await seedInsight(user.id, { period: InsightPeriod.MONTHLY })

    const res = await request(app)
      .get('/insights?period=MONTHLY')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toHaveLength(2)
    expect(res.body.insights.every((i: any) => i.period === 'MONTHLY')).toBe(true)
  })

  it('caps the result set at the requested limit', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    await seedInsight(user.id)
    await seedInsight(user.id)
    await seedInsight(user.id)

    const res = await request(app)
      .get('/insights?limit=2')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toHaveLength(2)
  })

  it('returns 400 for an unknown type', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    const res = await request(app)
      .get('/insights?type=NOPE')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(400)
    expect(res.body.fields).toBeTruthy()
  })

  it('returns 400 for a non-positive limit', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    const res = await request(app)
      .get('/insights?limit=0')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(400)
  })

  it('returns 401 without a token', async () => {
    const res = await request(app).get('/insights')
    expect(res.status).toBe(401)
  })

  it('resolves an unqualified daily request to today', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)
    const { start: today } = appDayWindow()
    const { start: yesterday } = appDayWindow(new Date(today.getTime() - 1))

    await seedInsight(user.id, {
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      periodStart: yesterday,
      title: 'energy-yesterday',
    })
    await seedInsight(user.id, {
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      periodStart: today,
      title: 'energy-today',
    })
    await seedInsight(user.id, {
      type: InsightType.DAILY_SLEEP,
      period: InsightPeriod.DAILY,
      periodStart: yesterday,
      title: 'sleep-yesterday',
    })
    await seedInsight(user.id, {
      type: InsightType.DAILY_SLEEP,
      period: InsightPeriod.DAILY,
      periodStart: today,
      title: 'sleep-today',
    })

    const energy = await request(app)
      .get('/insights?type=DAILY_ENERGY')
      .set('Authorization', `Bearer ${token}`)
    const sleep = await request(app)
      .get('/insights?type=DAILY_SLEEP')
      .set('Authorization', `Bearer ${token}`)

    expect(energy.status).toBe(200)
    expect(energy.body.insights.map((i: any) => i.title)).toEqual([
      'energy-today',
    ])
    expect(sleep.status).toBe(200)
    expect(sleep.body.insights.map((i: any) => i.title)).toEqual(['sleep-today'])
  })

  it('filters the insight to an explicit day', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)
    const { start: today } = appDayWindow()
    const { start: yesterday } = appDayWindow(new Date(today.getTime() - 1))

    await seedInsight(user.id, {
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      periodStart: yesterday,
      title: 'energy-yesterday',
    })
    await seedInsight(user.id, {
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      periodStart: today,
      title: 'energy-today',
    })

    const res = await request(app)
      .get(`/insights?type=DAILY_ENERGY&day=${appDayKey(yesterday)}`)
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights.map((i: any) => i.title)).toEqual([
      'energy-yesterday',
    ])
  })

  it('returns an empty list for a day with no generated insight', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)
    const { start: today } = appDayWindow()
    const { start: yesterday } = appDayWindow(new Date(today.getTime() - 1))

    await seedInsight(user.id, {
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      periodStart: today,
      title: 'energy-today',
    })

    const res = await request(app)
      .get(`/insights?type=DAILY_ENERGY&day=${appDayKey(yesterday)}`)
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toEqual([])
  })

  it('returns an empty list when today has no daily insight', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)
    const { start: today } = appDayWindow()
    const { start: yesterday } = appDayWindow(new Date(today.getTime() - 1))

    await seedInsight(user.id, {
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      periodStart: yesterday,
      title: 'energy-yesterday',
    })

    const res = await request(app)
      .get('/insights?type=DAILY_ENERGY')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)
    expect(res.body.insights).toEqual([])
  })

  it('returns 400 for a malformed day', async () => {
    const user = await createTestUser(db)
    const token = generateTestToken(user.id, user.email)

    const res = await request(app)
      .get('/insights?day=2026-13-40')
      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(400)
    expect(res.body.fields).toBeTruthy()
  })
})