const request = require('supertest')
const app = require('../src/app')
const User = require('../src/models/user')

const {
    userOne,
    userOneId,
    setupDatabase
} = require('./fixtures/db')

beforeEach(setupDatabase)

test("Should signup a new user", async () => {
    const newUser = {
        name: "Me",
        email: "me@example.com",
        password: "red12345!"
    }

    const response = await request(app).post('/users')
        .send(newUser)
        .expect(201)

    // Assert user was correctly stored in the database.
    const user = await User.findById(response.body.user._id)
    expect(user).not.toBeNull()

    // assertions about the resonse.
    expect(response.body).toMatchObject({
        user: {
            name: newUser.name,
            email: newUser.email
        },
        token: user.tokens[ 0 ].token
    })

    // Check user password hashing.
    expect(user.password).not.toBe(newUser.password)
})

test("Should log in existing user", async () => {
    const response = await request(app).post('/users/login')
        .send({
            email: userOne.email,
            password: userOne.password
        })
        .expect(200)

    // Fetch the user from the database.
    const user = await User.findById(userOneId)
    expect(user).not.toBeNull()
    expect(user.tokens.length).toBe(2)
    expect(response.body.token).toBe(user.tokens[ 1 ].token)
    // expect(response.body.token).toBe(user.tokens[user.tokens.length - 1].token)
})

test("Should not log in nonexistent user", async () => {
    await request(app).post('/users/login')
        .send({
            email: userOne.email,
            password: userOne.password + "XXX"
        })
        .expect(400)
})

test("Should get profile for user", async () => {
    await request(app).get('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[ 0 ].token}`)
        .send()
        .expect(200)
})

test("Should not get profile for non authenticated user", async () => {
    await request(app).get('/users/me')
        .send()
        .expect(401)
})

test("Should delete account for user", async () => {
    const response = await request(app).delete('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[ 0 ].token}`)
        .send()
        .expect(200)

    // Assert user was deleted.
    expect(userOneId.toString()).toBe(response.body._id)
    const user = await User.findById(userOneId)
    expect(user).toBeNull()
})

test("Should not not delete account for non authenticated user", async () => {
    await request(app).delete('/users/me')
        .send()
        .expect(401)
})

test("Should upload avatar image", async () => {
    await request(app).post('/users/me/avatar')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .attach('avatar', 'tests/fixtures/profile-pic.jpg')
        .expect(200)
    const user = await User.findById(userOneId)
    expect(user).not.toBeNull()
    expect(user.avatar).toEqual(expect.any(Buffer))
})

test("Should update valid user fields", async () => {
    const newName = "New Name"
    await request(app).patch('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .send({ name: newName })
        .expect(200)
    const user = await User.findById(userOneId)
    expect(user).not.toBeNull()
    expect(user.name).toBe(newName)
})

test("Should not update invalid user fields", async () => {
    await request(app).patch('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .send({ location: "New location" })
        .expect(400)
})

//
// User Test Ideas
//
// Should not signup user with invalid name/email/password
// Should not update user if unauthenticated
// Should not update user with invalid name/email/password
// Should not delete user if unauthenticated

test("Should not signup user with invalid name/email/password", async () => {
    const emptyName = { name: "", email: "me@example.com", password: "red12345!" }
    const missingName = { email: "me@example.com", password: "red12345!" }
    const missingEmail = { name: "Me", password: "red12345!" }
    const missingPass = { name: "Me", email: "me@example.com" }
    const shortPass = { name: "Me", email: "me@example.com", password: "123"}
    const hasPass = { name: "Me", email: "me@example.com", password: "Apasswords"}

    await request(app).post('/users').send(emptyName).expect(400)
    await request(app).post('/users').send(missingName).expect(400)
    await request(app).post('/users').send(missingEmail).expect(400)
    await request(app).post('/users').send(missingPass).expect(400)
    await request(app).post('/users').send(shortPass).expect(400)
    await request(app).post('/users').send(hasPass).expect(400)
})

test("Should not update user if unauthenticated", async () => {
    await request(app).patch('/users/me')
        .send({ name: "Should Not Update" })
        .expect(401)
})

test("Should not signup user with invalid name/email/password", async () => {
    const emptyName = { name: "" }
    const emptyEmail = { email: "" }
    const shortPass = { password: "123"}
    const hasPass = { password: "Apasswords"}

    await request(app).patch('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .send(emptyName)
        .expect(400)
    await request(app).patch('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .send(emptyEmail)
        .expect(400)
    await request(app).patch('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .send(shortPass)
        .expect(400)
    await request(app).patch('/users/me')
        .set('Authorization', `Bearer ${userOne.tokens[0].token}`)
        .send(hasPass)
        .expect(400)
})

test("Should not delete user if unauthenticated", async () => {
    const response = await request(app).delete('/users/me')
        .send()
        .expect(401)

    // Assert user was not deleted.
    const user = await User.findById(userOneId)
    expect(user).not.toBeNull()
})