import express from "express";

import {

  validateMoodComponents,

  isValidLevel,

  isValidRating,

  calculateEmotionStats

} from "../utils/emotions.js";

import {

  validateRequiredFields,

  isValidDate,

  isNotFutureDate,

  isValidDateRange,

  sanitizeString,

  validatePagination

} from "../utils/validators.js";

const router = express.Router();

router.get('/', (req, res) => {

});

// Create new mood entry with components

router.post("/", (req, res) => {

  const {

    user_id,

    rating,

    stress_level,

    anxiety_level,

    energy_level,

    title,

    description,

    recorded_at,

    mood_components

  } = req.body;

  // Validate required fields

  const requiredValidation = validateRequiredFields(req.body, [

    'user_id', 'stress_level', 'anxiety_level', 'energy_level', 'recorded_at'

  ]);

  if (!requiredValidation.valid) {

    return res.status(400).json({

      error: "Campos faltantes",

      missing: requiredValidation.missing

    });

  }

  // Validate levels

  if (!isValidLevel(stress_level)) {

    return res.status(400).json({ error: "stress_level deve ser entre 1 e 10" });

  }

  if (!isValidLevel(anxiety_level)) {

    return res.status(400).json({ error: "anxiety_level deve ser entre 1 e 10" });

  }

  if (!isValidLevel(energy_level)) {

    return res.status(400).json({ error: "energy_level deve ser entre 1 e 10" });

  }

  // Validate optional rating

  if (rating && !isValidRating(rating)) {

    return res.status(400).json({ error: "rating deve ser entre 1 e 10" });

  }

  // Validate date

  if (!isValidDate(recorded_at)) {

    return res.status(400).json({ error: "recorded_at deve ser uma data válida" });

  }

  if (!isNotFutureDate(recorded_at)) {

    return res.status(400).json({ error: "recorded_at não pode ser no futuro" });

  }

  // Validate mood components if provided

  if (mood_components) {

    const componentValidation = validateMoodComponents(mood_components);

    if (!componentValidation.valid) {

      return res.status(400).json({ error: componentValidation.error });

    }

  }

  const db = req.db;

  try {

    // Start transaction

    db.prepare("BEGIN").run();

    // Insert mood entry

    const moodStmt = db.prepare(`

      INSERT INTO mood (

        user_id, rating, stress_level, anxiety_level, energy_level,

        title, description, recorded_at

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

    `);

    const moodResult = moodStmt.run(

      user_id,

      rating || null,

      stress_level,

      anxiety_level,

      energy_level,

      sanitizeString(title) || null,

      sanitizeString(description) || null,

      recorded_at

    );

    const moodId = moodResult.lastInsertRowid;

    // Insert mood components if provided

    if (mood_components && mood_components.length > 0) {

      const componentStmt = db.prepare(`

        INSERT INTO mood_components (mood_id, emotion, intensity)

        VALUES (?, ?, ?)

      `);

      for (const component of mood_components) {

        componentStmt.run(

          moodId,

          component.emotion.toLowerCase(),

          component.intensity

        );

      }

    }

    // Commit transaction

    db.prepare("COMMIT").run();

    res.status(201).json({ id: moodId });

  } catch (err) {

    // Rollback on error

    db.prepare("ROLLBACK").run();

    console.error('Error creating mood:', err);

    res.status(500).json({ error: "Erro ao criar registro de humor" });

  }

});

// Get single mood entry with components

router.get("/:mood_id", (req, res) => {

  const moodId = req.params.mood_id;

  const db = req.db;

  const moodStmt = db.prepare(`

    SELECT m.*, u.first_name, u.last_name

    FROM mood m

    JOIN users u ON m.user_id = u.id

    WHERE m.id = ?

  `);

  const mood = moodStmt.get(moodId);

  if (!mood) {

    return res.status(404).json({ error: "Humor não encontrado" });

  }

  // Get mood components

  const componentsStmt = db.prepare(`

    SELECT emotion, intensity

    FROM mood_components

    WHERE mood_id = ?

  `);

  const components = componentsStmt.all(moodId);

  mood.mood_components = components;

  // Calculate emotion stats

  if (components.length > 0) {

    mood.emotion_stats = calculateEmotionStats(components);

  }

  res.json(mood);

});

// Update mood entry

router.put("/:mood_id", (req, res) => {

  const moodId = req.params.mood_id;

  const {

    rating,

    stress_level,

    anxiety_level,

    energy_level,

    title,

    description,

    recorded_at,

    mood_components

  } = req.body;

  const db = req.db;

  // Check if mood exists

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

  if (!existingMood) {

    return res.status(404).json({ error: "Humor não encontrado" });

  }

  // Build update query dynamically

  const updates = [];

  const values = [];

  if (rating !== undefined) {

    if (!isValidRating(rating)) {

      return res.status(400).json({ error: "rating deve ser entre 1 e 10" });

    }

    updates.push("rating = ?");

    values.push(rating);

  }

  if (stress_level !== undefined) {

    if (!isValidLevel(stress_level)) {

      return res.status(400).json({ error: "stress_level deve ser entre 1 e 10" });

    }

    updates.push("stress_level = ?");

    values.push(stress_level);

  }

  if (anxiety_level !== undefined) {

    if (!isValidLevel(anxiety_level)) {

      return res.status(400).json({ error: "anxiety_level deve ser entre 1 e 10" });

    }

    updates.push("anxiety_level = ?");

    values.push(anxiety_level);

  }

  if (energy_level !== undefined) {

    if (!isValidLevel(energy_level)) {

      return res.status(400).json({ error: "energy_level deve ser entre 1 e 10" });

    }

    updates.push("energy_level = ?");

    values.push(energy_level);

  }

  if (title !== undefined) {

    updates.push("title = ?");

    values.push(sanitizeString(title) || null);

  }

  if (description !== undefined) {

    updates.push("description = ?");

    values.push(sanitizeString(description) || null);

  }

  if (recorded_at !== undefined) {

    if (!isValidDate(recorded_at)) {

      return res.status(400).json({ error: "recorded_at deve ser uma data válida" });

    }

    if (!isNotFutureDate(recorded_at)) {

      return res.status(400).json({ error: "recorded_at não pode ser no futuro" });

    }

    updates.push("recorded_at = ?");

    values.push(recorded_at);

  }

  updates.push("updated_at = CURRENT_TIMESTAMP");

  try {

    db.prepare("BEGIN").run();

    // Update mood if there are changes

    if (updates.length > 0) {

      const updateQuery = `UPDATE mood SET ${updates.join(', ')} WHERE id = ?`;

      values.push(moodId);

      db.prepare(updateQuery).run(...values);

    }

    // Update mood components if provided

    if (mood_components !== undefined) {

      const componentValidation = validateMoodComponents(mood_components);

      if (!componentValidation.valid) {

        db.prepare("ROLLBACK").run();

        return res.status(400).json({ error: componentValidation.error });

      }

      // Delete existing components

      db.prepare("DELETE FROM mood_components WHERE mood_id = ?").run(moodId);

      // Insert new components

      if (mood_components.length > 0) {

        const componentStmt = db.prepare(`

          INSERT INTO mood_components (mood_id, emotion, intensity)

          VALUES (?, ?, ?)

        `);

        for (const component of mood_components) {

          componentStmt.run(

            moodId,

            component.emotion.toLowerCase(),

            component.intensity

          );

        }

      }

    }

    db.prepare("COMMIT").run();

    res.json({ success: true, id: moodId });

  } catch (err) {

    db.prepare("ROLLBACK").run();

    console.error('Error updating mood:', err);

    res.status(500).json({ error: "Erro ao atualizar humor" });

  }

});

// Delete mood entry

router.delete("/:mood_id", (req, res) => {

  const moodId = req.params.mood_id;

  const db = req.db;

  const result = db.prepare("DELETE FROM mood WHERE id = ?").run(moodId);

  if (result.changes === 0) {

    return res.status(404).json({ error: "Humor não encontrado" });

  }

  res.json({ success: true, deleted: moodId });

});

// Get user's moods with optional date range

router.get("/user/:user_id", (req, res) => {

  const userId = req.params.user_id;

  const { start_date, end_date, page, limit } = req.query;

  const db = req.db;

  // Validate pagination

  const { page: validPage, limit: validLimit, offset } = validatePagination(page, limit);

  let query = `

    SELECT m.*,

           COUNT(mc.id) as component_count

    FROM mood m

    LEFT JOIN mood_components mc ON m.id = mc.mood_id

    WHERE m.user_id = ?

  `;

  const params = [userId];

  // Add date range filtering

  if (start_date && end_date) {

    if (!isValidDateRange(start_date, end_date)) {

      return res.status(400).json({ error: "Intervalo de datas inválido" });

    }

    query += " AND m.recorded_at BETWEEN ? AND ?";

    params.push(start_date, end_date);

  } else if (start_date) {

    if (!isValidDate(start_date)) {

      return res.status(400).json({ error: "Data de início inválida" });

    }

    query += " AND m.recorded_at >= ?";

    params.push(start_date);

  } else if (end_date) {

    if (!isValidDate(end_date)) {

      return res.status(400).json({ error: "Data de fim inválida" });

    }

    query += " AND m.recorded_at <= ?";

    params.push(end_date);

  }

  query += " GROUP BY m.id ORDER BY m.recorded_at DESC LIMIT ? OFFSET ?";

  params.push(validLimit, offset);

  const moods = db.prepare(query).all(...params);

  // Get components for each mood

  const moodIds = moods.map(m => m.id);

  if (moodIds.length > 0) {

    const componentsQuery = `

      SELECT mood_id, emotion, intensity

      FROM mood_components

      WHERE mood_id IN (${moodIds.map(() => '?').join(',')})

    `;

    const components = db.prepare(componentsQuery).all(...moodIds);

    // Group components by mood_id

    const componentsByMood = {};

    components.forEach(c => {

      if (!componentsByMood[c.mood_id]) {

        componentsByMood[c.mood_id] = [];

      }

      componentsByMood[c.mood_id].push({

        emotion: c.emotion,

        intensity: c.intensity

      });

    });

    // Attach components to moods

    moods.forEach(mood => {

      mood.mood_components = componentsByMood[mood.id] || [];

      if (mood.mood_components.length > 0) {

        mood.emotion_stats = calculateEmotionStats(mood.mood_components);

      }

    });

  }

  // Get total count for pagination

  let countQuery = "SELECT COUNT(*) as total FROM mood WHERE user_id = ?";

  const countParams = [userId];

  if (start_date && end_date) {

    countQuery += " AND recorded_at BETWEEN ? AND ?";

    countParams.push(start_date, end_date);

  } else if (start_date) {

    countQuery += " AND recorded_at >= ?";

    countParams.push(start_date);

  } else if (end_date) {

    countQuery += " AND recorded_at <= ?";

    countParams.push(end_date);

  }

  const { total } = db.prepare(countQuery).get(...countParams);

  res.json({

    moods,

    pagination: {

      page: validPage,

      limit: validLimit,

      total,

      total_pages: Math.ceil(total / validLimit)

    }

  });

});

// Get mood statistics for a user

router.get("/user/:user_id/stats", (req, res) => {

  const userId = req.params.user_id;

  const { start_date, end_date } = req.query;

  const db = req.db;

  let baseQuery = "FROM mood WHERE user_id = ?";

  const params = [userId];

  if (start_date && end_date) {

    if (!isValidDateRange(start_date, end_date)) {

      return res.status(400).json({ error: "Intervalo de datas inválido" });

    }

    baseQuery += " AND recorded_at BETWEEN ? AND ?";

    params.push(start_date, end_date);

  }

  // Get aggregated stats

  const statsQuery = `

    SELECT

      COUNT(*) as total_entries,

      AVG(rating) as avg_rating,

      AVG(stress_level) as avg_stress,

      AVG(anxiety_level) as avg_anxiety,

      AVG(energy_level) as avg_energy,

      MIN(stress_level) as min_stress,

      MAX(stress_level) as max_stress,

      MIN(anxiety_level) as min_anxiety,

      MAX(anxiety_level) as max_anxiety,

      MIN(energy_level) as min_energy,

      MAX(energy_level) as max_energy

    ${baseQuery}

  `;

  const stats = db.prepare(statsQuery).get(...params);

  // Get emotion frequency

  const emotionQuery = `

    SELECT

      mc.emotion,

      COUNT(*) as frequency,

      AVG(mc.intensity) as avg_intensity

    FROM mood_components mc

    JOIN mood m ON mc.mood_id = m.id

    WHERE m.user_id = ?

    ${start_date && end_date ? 'AND m.recorded_at BETWEEN ? AND ?' : ''}

    GROUP BY mc.emotion

    ORDER BY frequency DESC

  `;

  const emotionParams = [...params];

  const emotions = db.prepare(emotionQuery).all(...emotionParams);

  // Get mood trends by day of week

  const dayTrendsQuery = `

    SELECT

      CASE CAST(strftime('%w', recorded_at) AS INTEGER)

        WHEN 0 THEN 'Sunday'

        WHEN 1 THEN 'Monday'

        WHEN 2 THEN 'Tuesday'

        WHEN 3 THEN 'Wednesday'

        WHEN 4 THEN 'Thursday'

        WHEN 5 THEN 'Friday'

        WHEN 6 THEN 'Saturday'

      END as day_of_week,

      AVG(stress_level) as avg_stress,

      AVG(anxiety_level) as avg_anxiety,

      AVG(energy_level) as avg_energy,

      COUNT(*) as entries

    ${baseQuery}

    GROUP BY strftime('%w', recorded_at)

  `;

  const dayTrends = db.prepare(dayTrendsQuery).all(...params);

  res.json({

    overall: stats,

    emotions: emotions,

    trends: {

      by_day_of_week: dayTrends

    },

    date_range: {

      start: start_date || 'all time',

      end: end_date || 'all time'

    }

  });

});

export default router;

import express from "express";

import bcrypt from "bcryptjs";

import {

  isValidEmail,

  isValidPassword,

  sanitizeString,

  validateRequiredFields

} from "../utils/validators.js";

const router = express.Router();

// Create user

router.post("/", (req, res) => {

  const { email, password, first_name, last_name, timezone } = req.body;

  // Validate required fields

  const requiredValidation = validateRequiredFields(req.body, [

    'email', 'password', 'first_name', 'last_name'

  ]);

  if (!requiredValidation.valid) {

    return res.status(400).json({

      error: "Campos faltantes",

      missing: requiredValidation.missing

    });

  }

  // Validate email format

  if (!isValidEmail(email)) {

    return res.status(400).json({ error: "Email inválido" });

  }

  // Validate password strength

  if (!isValidPassword(password)) {

    return res.status(400).json({ error: "Senha deve ter pelo menos 6 caracteres" });

  }

  const hashed = bcrypt.hashSync(password, 10);

  const db = req.db;

  try {

    const stmt = db.prepare(`

      INSERT INTO users (email, password, first_name, last_name, timezone)

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

    `);

    const result = stmt.run(

      email.toLowerCase(),

      hashed,

      sanitizeString(first_name),