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

import request from 'supertest'

import { DeleteObjectCommand } from '@aws-sdk/client-s3'

import { createApp } from '@app/createApp'

import s3 from '@app/lib/s3'

import {

  buildPrisma,

  cleanupTestDb,

  createTestUser,

  generateTestToken,

  expectPublicUser,

} from '../test-helper'

import { resetAvatarMock, setUploadedFile } from '../mocks/avatar'

const app = createApp()

const db = buildPrisma()

const mockedSend = vi.mocked(s3.send)

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

beforeEach(async () => {

  await cleanupTestDb(db)

  resetAvatarMock()

  mockedSend.mockClear()

})

const uploadedFile = {

  location: 'https://cdn.example.com/avatars/new.png',

  key: 'avatars/new.png',

  originalname: 'new.png',

  size: 1234,

  mimetype: 'image/png',

}

describe('POST /users/me/avatar', () => {

  it('stores the uploaded file on the user', async () => {

    const user = await createTestUser(db)

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

    setUploadedFile(uploadedFile)

    const res = await request(app)

      .post('/users/me/avatar')

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

    expect(res.status).toBe(200)

    expect(res.body.key).toBe('avatars/new.png')

    expect(res.body.user.avatarURL).toBe(uploadedFile.location)

    expect(res.body.user.avatarKey).toBe('avatars/new.png')

    expectPublicUser(res.body.user)

    const dbUser = await db.user.findUnique({ where: { id: user.id } })

    expect(dbUser!.avatarURL).toBe(uploadedFile.location)

  })

  it('deletes the previous object when replacing an avatar', async () => {

    const user = await createTestUser(db)

    await db.user.update({

      where: { id: user.id },

      data: {

        avatarKey: 'avatars/old.png',

        avatarURL: 'https://cdn.example.com/avatars/old.png'

      },

    })

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

    setUploadedFile(uploadedFile)

    const res = await request(app)

      .post('/users/me/avatar')

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

    expect(res.status).toBe(200)

    expect(mockedSend).toHaveBeenCalledOnce()

    expect(mockedSend).toHaveBeenCalledWith(expect.any(DeleteObjectCommand))

  })

  it('returns 400 when no file is present', async () => {

    const user = await createTestUser(db)

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

    const res = await request(app)

      .post('/users/me/avatar')

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

    expect(res.status).toBe(400)

    expect(mockedSend).not.toHaveBeenCalled()

  })

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

    setUploadedFile(uploadedFile)

    const res = await request(app).post('/users/me/avatar')

    expect(res.status).toBe(401)

  })

})

describe('DELETE /users/me/avatar', () => {

  it('clears the stored avatar and deletes the object', async () => {

    const user = await createTestUser(db)

    await db.user.update({

      where: { id: user.id },

      data: {

        avatarKey: 'avatars/old.png',

        avatarURL: 'https://cdn.example.com/avatars/old.png'

      },

    })

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

    const res = await request(app)

      .delete('/users/me/avatar')

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

    expect(res.status).toBe(200)

    expect(res.body.user.avatarKey).toBeNull()

    expect(res.body.user.avatarURL).toBeNull()

    expectPublicUser(res.body.user)

    expect(mockedSend).toHaveBeenCalledOnce()

    const dbUser = await db.user.findUnique({ where: { id: user.id } })

    expect(dbUser!.avatarKey).toBeNull()

  })

  it('is a no-op when there is no avatar to remove', async () => {

    const user = await createTestUser(db)

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

    const res = await request(app)

      .delete('/users/me/avatar')

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

    expect(res.status).toBe(200)

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

    expect(mockedSend).not.toHaveBeenCalled()

  })

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

    const res = await request(app).delete('/users/me/avatar')

    expect(res.status).toBe(401)

  })

})