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 moodIds = [];

test.before(() => {

  db = setupTestDb();

  app = createApp(db);

});

test.beforeEach(async () => {

  cleanupTestDb();

  moodIds = [];

  // 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 multiple moods for testing

  const dates = [

    new Date('2024-01-15T10:00:00Z'),

    new Date('2024-01-20T14:30:00Z'),

    new Date('2024-02-01T08:00:00Z'),

    new Date('2024-02-15T16:45:00Z'),

    new Date('2024-03-01T12:00:00Z')

  ];

  for (let i = 0; i < dates.length; i++) {

    const moodRes = await request(app)

      .post("/mood")

      .send({

        user_id: userId,

        rating: 5 + i,

        stress_level: 3 + i,

        anxiety_level: 2 + i,

        energy_level: 6 - i,

        title: `Mood ${i + 1}`,

        recorded_at: dates[i].toISOString(),

        mood_components: i % 2 === 0 ? [

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

          { emotion: "trust", intensity: 4 + i }

        ] : []

      });

    moodIds.push(moodRes.body.id);

  }

});

test.serial("Obter mood específico por ID", async (t) => {

  const res = await request(app).get(`/mood/${moodIds[0]}`);

  t.is(res.status, 200);

  t.is(Number(res.body.id), Number(moodIds[0]));

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

  t.is(res.body.title, "Mood 1");

  t.truthy(res.body.first_name);

  t.truthy(res.body.last_name);

  t.true(Array.isArray(res.body.mood_components));

});

test.serial("Mood deve incluir componentes emocionais", async (t) => {

  const res = await request(app).get(`/mood/${moodIds[0]}`);

  t.is(res.status, 200);

  t.is(res.body.mood_components.length, 2);

  const emotions = res.body.mood_components.map(c => c.emotion);

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

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

});

test.serial("Mood deve incluir estatísticas emocionais quando houver componentes", async (t) => {

  const res = await request(app).get(`/mood/${moodIds[0]}`);

  t.is(res.status, 200);

  t.truthy(res.body.emotion_stats);

  t.truthy(res.body.emotion_stats.dominant);

  t.truthy(res.body.emotion_stats.average);

  t.truthy(res.body.emotion_stats.breakdown);

});

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

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

  t.is(res.status, 404);

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

});

test.serial("Obter todos os moods de um usuário", async (t) => {

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

  t.is(res.status, 200);

  t.truthy(res.body.moods);

  t.is(res.body.moods.length, 5);

  t.truthy(res.body.pagination);

  t.is(res.body.pagination.total, 5);

});

test.serial("Moods devem estar ordenados por data (mais recente primeiro)", async (t) => {

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

  t.is(res.status, 200);

  const dates = res.body.moods.map(m => new Date(m.recorded_at));

  for (let i = 1; i < dates.length; i++) {

    t.true(dates[i - 1] >= dates[i]);

  }

});

test.serial("Filtrar registros de humor por intervalo de datas", async (t) => {

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

    .query({

      start_date: '2024-01-01',

      end_date: '2024-01-31'

    });

  t.is(res.status, 200);

  t.is(res.body.moods.length, 2); // Only January moods

});

test.serial("Filtrar registros de humor apenas por data de início", async (t) => {

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

    .query({

      start_date: '2024-02-01'

    });

  t.is(res.status, 200);

  t.is(res.body.moods.length, 3); // Feb and March moods

});

test.serial("Filtrar registros de humor apenas por data de fim", async (t) => {

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

    .query({

      end_date: '2024-01-31'

    });

  t.is(res.status, 200);

  t.is(res.body.moods.length, 2); // Only January moods

});

test.serial("Paginação de moods", async (t) => {

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

    .query({

      page: 2,

      limit: 2

    });

  t.is(res.status, 200);

  t.is(res.body.moods.length, 2);

  t.is(res.body.pagination.page, 2);

  t.is(res.body.pagination.limit, 2);

  t.is(res.body.pagination.total_pages, 3);

});

test.serial("Paginação com limite máximo de 100", async (t) => {

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

    .query({

      limit: 200

    });

  t.is(res.status, 200);

  t.is(res.body.pagination.limit, 100); // Should be capped at 100

});

test.serial("Falha ao filtrar com intervalo de datas inválido", async (t) => {

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

    .query({

      start_date: '2024-02-01',

      end_date: '2024-01-01' // End before start

    });

  t.is(res.status, 400);

  t.is(res.body.error, "Intervalo de datas inválido");

});

test.serial("Falha ao filtrar com data de início inválida", async (t) => {

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

    .query({

      start_date: 'data-invalida'

    });

  t.is(res.status, 400);

  t.is(res.body.error, "Data de início inválida");

});

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

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

    .query({

      end_date: 'data-invalida'

    });

  t.is(res.status, 400);

  t.is(res.body.error, "Data de fim inválida");

});

test.serial("Obter estatísticas de mood do usuário", async (t) => {

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

  t.is(res.status, 200);

  t.truthy(res.body.overall);

  t.is(res.body.overall.total_entries, 5);

  t.truthy(res.body.overall.avg_rating);

  t.truthy(res.body.overall.avg_stress);

  t.truthy(res.body.overall.avg_anxiety);

  t.truthy(res.body.overall.avg_energy);

  t.truthy(res.body.emotions);

  t.truthy(res.body.trends);

});

test.serial("Estatísticas devem incluir frequência de emoções", async (t) => {

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

  t.is(res.status, 200);

  t.true(Array.isArray(res.body.emotions));

  // We created 3 moods with components

  const joyStats = res.body.emotions.find(e => e.emotion === 'joy');

  t.truthy(joyStats);

  t.is(joyStats.frequency, 3);

});

test.serial("Estatísticas com filtro de data", async (t) => {

  const res = await request(app).get(`/mood/user/${userId}/stats`)

    .query({

      start_date: '2024-01-01',

      end_date: '2024-01-31'

    });

  t.is(res.status, 200);

  t.is(res.body.overall.total_entries, 2); // Only January

  t.is(res.body.date_range.start, '2024-01-01');

  t.is(res.body.date_range.end, '2024-01-31');

});

test.serial("Estatísticas devem incluir tendências por dia da semana", async (t) => {

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

  t.is(res.status, 200);

  t.true(Array.isArray(res.body.trends.by_day_of_week));

  const hasDay = res.body.trends.by_day_of_week.some(d =>

    ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'].includes(d.day_of_week)

  );

  t.true(hasDay);

});

test.serial("Usuário sem moods deve retornar lista vazia", async (t) => {

  // Create another user without moods

  const newUserRes = await request(app)

    .post("/users")

    .send({

      email: "nomood@example.com",

      password: "senha123",

      first_name: "No",

      last_name: "Mood"

    });

  const res = await request(app).get(`/mood/user/${newUserRes.body.id}`);

  t.is(res.status, 200);

  t.is(res.body.moods.length, 0);

  t.is(res.body.pagination.total, 0);

});

test.serial("Estatísticas de usuário sem moods", async (t) => {

  // Create another user without moods

  const newUserRes = await request(app)

    .post("/users")

    .send({

      email: "nostats@example.com",

      password: "senha123",

      first_name: "No",

      last_name: "Stats"

    });

  const res = await request(app).get(`/mood/user/${newUserRes.body.id}/stats`);

  t.is(res.status, 200);

  t.is(res.body.overall.total_entries, 0);

  t.is(res.body.emotions.length, 0);

});