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;

let moodId;

test.before(() => {

  db = setupTestDb();

  app = createApp(db);

});

test.beforeEach(async () => {

  cleanupTestDb();

  // Create a test user with unique email

  const uniqueEmail = `mood_${Date.now()}_${Math.random()}@example.com`;

  const userRes = await request(app)

    .post("/users")

    .send({

      email: uniqueEmail,

      password: "senha123",

      first_name: "Mood",

      last_name: "Tester"

    });

  if (userRes.status !== 201) {

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

  }

  userId = userRes.body.id;

  // Create a mood to update

  const moodRes = await request(app)

    .post("/mood")

    .send({

      user_id: userId,

      rating: 5,

      stress_level: 4,

      anxiety_level: 3,

      energy_level: 7,

      title: "Original mood",

      description: "Original description",

      recorded_at: new Date().toISOString(),

      mood_components: [

        { emotion: "joy", intensity: 6 },

        { emotion: "trust", intensity: 7 }

      ]

    });

  moodId = moodRes.body.id;

});

test.serial("Atualizar rating do mood", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      rating: 8

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify update

  const mood = db.prepare("SELECT rating FROM mood WHERE id = ?").get(moodId);

  t.is(mood.rating, 8);

});

test.serial("Atualizar múltiplos níveis do mood", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      stress_level: 2,

      anxiety_level: 1,

      energy_level: 9

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify updates

  const mood = db.prepare("SELECT stress_level, anxiety_level, energy_level FROM mood WHERE id = ?").get(moodId);

  t.is(mood.stress_level, 2);

  t.is(mood.anxiety_level, 1);

  t.is(mood.energy_level, 9);

});

test.serial("Atualizar título e descrição do mood", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      title: "Novo título",

      description: "Nova descrição detalhada"

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify updates

  const mood = db.prepare("SELECT title, description FROM mood WHERE id = ?").get(moodId);

  t.is(mood.title, "Novo título");

  t.is(mood.description, "Nova descrição detalhada");

});

test.serial("Atualizar data do mood", async (t) => {

  const newDate = new Date('2024-01-15T10:00:00Z');

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      recorded_at: newDate.toISOString()

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify update

  const mood = db.prepare("SELECT recorded_at FROM mood WHERE id = ?").get(moodId);

  t.truthy(mood.recorded_at.includes('2024-01-15'));

});

test.serial("Atualizar componentes emocionais do mood", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      mood_components: [

        { emotion: "sad", intensity: 4 },

        { emotion: "fear", intensity: 3 },

        { emotion: "angry", intensity: 2 }

      ]

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify old components were replaced

  const components = db.prepare("SELECT emotion, intensity FROM mood_components WHERE mood_id = ? ORDER BY emotion").all(moodId);

  t.is(components.length, 3);

  const emotions = components.map(c => c.emotion);

  t.true(emotions.includes('sad'));

  t.true(emotions.includes('fear'));

  t.true(emotions.includes('angry'));

  t.false(emotions.includes('joy')); // Old emotion should be gone

  t.false(emotions.includes('trust')); // Old emotion should be gone

});

test.serial("Remover todos os componentes emocionais enviando array vazio", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      mood_components: []

    });

  t.is(res.status, 200);

  t.true(res.body.success);

  // Verify components were deleted

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

  t.is(components.length, 0);

});

test.serial("Atualização deve modificar a coluna de atualização", async (t) => {

  // Get original updated_at

  const originalMood = db.prepare("SELECT updated_at FROM mood WHERE id = ?")

    .get(moodId);

  // Wait a bit to ensure timestamp difference

  await new Promise(resolve => setTimeout(resolve, 1100));

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      rating: 9

    });

  t.is(res.status, 200);

  // Verify updated_at changed

  const updatedMood = db.prepare("SELECT updated_at FROM mood WHERE id = ?")

    .get(moodId);

  t.not(updatedMood.updated_at, originalMood.updated_at);

});

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

  const res = await request(app)

    .put("/mood/99999")

    .send({

      rating: 8

    });

  t.is(res.status, 404);

  t.is(res.body.error, "Humor não encontrado");

});

test.serial("Falha ao atualizar com avaliação inválida", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      rating: 15

    });

  t.is(res.status, 400);

  t.is(res.body.error, "rating deve ser entre 1 e 10");

});

test.serial("Falha ao atualizar com nível de estresse inválido", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      stress_level: 0

    });

  t.is(res.status, 400);

  t.is(res.body.error, "stress_level deve ser entre 1 e 10");

});

test.serial("Falha ao atualizar com nível de ansiedade inválido", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      anxiety_level: 11

    });

  t.is(res.status, 400);

  t.is(res.body.error, "anxiety_level deve ser entre 1 e 10");

});

test.serial("Falha ao atualizar com nível de energia inválida", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      energy_level: -1

    });

  t.is(res.status, 400);

  t.is(res.body.error, "energy_level deve ser entre 1 e 10");

});

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

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      recorded_at: "data-invalida"

    });

  t.is(res.status, 400);

  t.is(res.body.error, "recorded_at deve ser uma data válida");

});

test.serial("Falha ao atualizar com data no futuro", async (t) => {

  const futureDate = new Date();

  futureDate.setDate(futureDate.getDate() + 1);

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      recorded_at: futureDate.toISOString()

    });

  t.is(res.status, 400);

  t.is(res.body.error, "recorded_at não pode ser no futuro");

});

test.serial("Falha ao atualizar com emoção inválida nos componentes", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      mood_components: [

        { emotion: "invalid", intensity: 5 }

      ]

    });

  t.is(res.status, 400);

  t.regex(res.body.error, /Invalid emotion/);

});

test.serial("Falha ao atualizar com emoções duplicadas", async (t) => {

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      mood_components: [

        { emotion: "joy", intensity: 5 },

        { emotion: "joy", intensity: 7 }

      ]

    });

  t.is(res.status, 400);

  t.regex(res.body.error, /Duplicate emotion/);

});

test.serial("Deletar humor existente", async (t) => {

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

  t.is(res.status, 200);

  t.true(res.body.success);

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

  // Verify mood is deleted

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

  t.falsy(mood);

});

test.serial("Deletar humor deve deletar seus componentes (em cascata)", async (t) => {

  // Verify components exist

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

  t.true(componentsBefore.length > 0);

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

  t.is(res.status, 200);

  // Verify components are deleted

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

  t.is(componentsAfter.length, 0);

});

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

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

  t.is(res.status, 404);

  t.is(res.body.error, "Humor não encontrado");

});

test.serial("Atualização parcial mantém valores não alterados", async (t) => {

  // Get original values

  const originalMood = db.prepare("SELECT * FROM mood WHERE id = ?").get(moodId);

  // Update only rating

  const res = await request(app)

    .put(`/mood/${moodId}`)

    .send({

      rating: 10

    });

  t.is(res.status, 200);

  // Verify only rating changed, others remained

  const updatedMood = db.prepare("SELECT * FROM mood WHERE id = ?").get(moodId);

  t.is(updatedMood.rating, 10);

  t.is(updatedMood.stress_level, originalMood.stress_level);

  t.is(updatedMood.anxiety_level, originalMood.anxiety_level);

  t.is(updatedMood.energy_level, originalMood.energy_level);

  t.is(updatedMood.title, originalMood.title);

  t.is(updatedMood.description, originalMood.description);

});