import test from "ava";

import request from "supertest";

import { createApp } from "../../src/create-app.js";

import { setupTestDb, cleanupTestDb } from "../test-helper.js";

let app;

let db;

let userId;

test.before(() => {

  db = setupTestDb();

  app = createApp(db);

});

let testEmail;

test.serial.beforeEach(async () => {

  cleanupTestDb();

  // Create a test user with unique email

  testEmail = `perfil_${Date.now()}_${Math.random()}@example.com`;

  const res = await request(app)

    .post("/users")

    .send({

      email: testEmail,

      password: "senha123",

      first_name: "Perfil",

      last_name: "Teste",

      timezone: "America/Sao_Paulo"

    });

  if (res.status !== 201) {

    throw new Error(`Failed to create test user: ${JSON.stringify(res.body)}`);

  }

  userId = res.body.id;

});

test.serial("Obter perfil de usuário existente", async (t) => {

  const res = await request(app).get(`/users/${userId}`);

  t.is(res.status, 200);

  t.is(Number(res.body.id), Number(userId));

  t.is(res.body.email, testEmail);

  t.is(res.body.first_name, "Perfil");

  t.is(res.body.last_name, "Teste");

  t.is(res.body.timezone, "America/Sao_Paulo");

  t.truthy(res.body.created_at);

  t.truthy(res.body.updated_at);

  t.is(typeof res.body.total_moods, 'number');

  t.falsy(res.body.password); // Should not include password

});

test.serial("Perfil deve incluir contagem de registros de humor", async (t) => {

  // Add some moods

  const now = new Date().toISOString();

  await db.prepare(`

    INSERT INTO mood (user_id, rating, stress_level, anxiety_level, energy_level, recorded_at)

    VALUES (?, ?, ?, ?, ?, ?)

  `).run(userId, 7, 3, 4, 8, now);

  await db.prepare(`

    INSERT INTO mood (user_id, rating, stress_level, anxiety_level, energy_level, recorded_at)

    VALUES (?, ?, ?, ?, ?, ?)

  `).run(userId, 5, 6, 7, 4, now);

  const res = await request(app).get(`/users/${userId}`);

  t.is(res.status, 200);

  t.is(res.body.total_moods, 2);

});

test.serial("Falha ao obter perfil de usuário inexistente", async (t) => {

  const res = await request(app).get("/users/99999");

  t.is(res.status, 404);

  t.is(res.body.error, "Usuário não encontrado");

});

test.serial("Atualizar email do usuário", async (t) => {

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({

      email: "novoemail@example.com"

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify update

  const user = db.prepare("SELECT email FROM users WHERE id = ?").get(userId);

  t.is(user.email, "novoemail@example.com");

});

test.serial("Atualizar senha do usuário", async (t) => {

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({

      password: "novasenha123"

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify can login with new password

  const loginRes = await request(app)

    .post("/users/login")

    .send({

      email: testEmail,

      password: "novasenha123"

    });

  t.is(loginRes.status, 200);

});

test.serial("Atualizar múltiplos campos do usuário", async (t) => {

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({

      first_name: "NovoNome",

      last_name: "NovoSobrenome",

      timezone: "Europe/London"

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify updates

  const user = db.prepare("SELECT * FROM users WHERE id = ?").get(userId);

  t.is(user.first_name, "NovoNome");

  t.is(user.last_name, "NovoSobrenome");

  t.is(user.timezone, "Europe/London");

});

test.serial("Falha ao atualizar com email inválido", async (t) => {

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({

      email: "emailinvalido"

    });

  t.is(res.status, 400);

  t.is(res.body.error, "Email inválido");

});

test.serial("Falha ao atualizar com senha muito curta", async (t) => {

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({

      password: "123"

    });

  t.is(res.status, 400);

  t.is(res.body.error, "Senha deve ter pelo menos 6 caracteres");

});

test.serial("Falha ao atualizar email para um já existente", async (t) => {

  // Create another user

  await request(app)

    .post("/users")

    .send({

      email: "outro@example.com",

      password: "senha123",

      first_name: "Outro",

      last_name: "Usuario"

    });

  // Try to update to existing email

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({

      email: "outro@example.com"

    });

  t.is(res.status, 400);

  t.is(res.body.error, "Email já está em uso");

});

test.serial("Falha ao atualizar usuário inexistente", async (t) => {

  const res = await request(app)

    .put("/users/99999")

    .send({

      first_name: "Novo"

    });

  t.is(res.status, 404);

  t.is(res.body.error, "Usuário não encontrado");

});

test.serial("Falha ao atualizar sem campos", async (t) => {

  const res = await request(app)

    .put(`/users/${userId}`)

    .send({});

  t.is(res.status, 400);

  t.is(res.body.error, "Nenhum campo para atualizar");

});

test.serial("Deletar usuário existente", async (t) => {

  const res = await request(app).delete(`/users/${userId}`);

  t.is(res.status, 200);

  t.true(res.body.success);

  t.is(Number(res.body.deleted), Number(userId));

  // Verify user is deleted

  const user = db.prepare("SELECT * FROM users WHERE id = ?").get(userId);

  t.falsy(user);

});

test.serial("Deletar usuário deve deletar seus registros de humores (em cascata)", async (t) => {

  // Add a mood

  const now = new Date().toISOString();

  const moodResult = db.prepare(`

    INSERT INTO mood (user_id, rating, stress_level, anxiety_level, energy_level, recorded_at)

    VALUES (?, ?, ?, ?, ?, ?)

  `).run(userId, 7, 3, 4, 8, now);

  const moodId = moodResult.lastInsertRowid;

  // Add mood components

  db.prepare(`

    INSERT INTO mood_components (mood_id, emotion, intensity)

    VALUES (?, ?, ?)

  `).run(moodId, 'joy', 8);

  // Delete user

  const res = await request(app).delete(`/users/${userId}`);

  t.is(res.status, 200);

  // Verify moods are deleted

  const mood = db.prepare("SELECT * FROM mood WHERE user_id = ?").get(userId);

  t.falsy(mood);

  // Verify mood components are deleted

  const component = db.prepare("SELECT * FROM mood_components WHERE mood_id = ?").get(moodId);

  t.falsy(component);

});

test.serial("Falha ao deletar usuário inexistente", async (t) => {

  const res = await request(app).delete("/users/99999");

  t.is(res.status, 404);

  t.is(res.body.error, "Usuário não encontrado");

});