basil/packages/api/src/routes/meal-plans.routes.real.test.ts

import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import request from 'supertest';
import app from '../index';
import prisma from '../config/database';

describe('Meal Plans Routes - Real Integration Tests', () => {
  let authToken: string;
  let testUserId: string;
  let testRecipeId: string;

  beforeAll(async () => {
    // Create test user and get auth token
    const userResponse = await request(app)
      .post('/api/auth/register')
      .send({
        email: `mealplan-test-${Date.now()}@example.com`,
        password: 'TestPassword123!',
        name: 'Meal Plan Test User',
      });

    testUserId = userResponse.body.data.user.id;
    authToken = userResponse.body.data.accessToken;

    // Create test recipe
    const recipeResponse = await request(app)
      .post('/api/recipes')
      .set('Authorization', `Bearer ${authToken}`)
      .send({
        title: 'Test Recipe for Meal Plans',
        description: 'A test recipe',
        servings: 4,
        ingredients: [
          { name: 'Flour', amount: '2', unit: 'cups', order: 0 },
          { name: 'Sugar', amount: '1', unit: 'cup', order: 1 },
          { name: 'Eggs', amount: '3', unit: '', order: 2 },
        ],
        instructions: [
          { step: 1, text: 'Mix dry ingredients' },
          { step: 2, text: 'Add eggs and mix well' },
        ],
      });

    testRecipeId = recipeResponse.body.data.id;
  });

  afterAll(async () => {
    // Cleanup in order: meal plans (cascade deletes meals), recipes, user
    await prisma.mealPlan.deleteMany({ where: { userId: testUserId } });

    // Delete recipe and its relations
    await prisma.ingredient.deleteMany({ where: { recipeId: testRecipeId } });
    await prisma.instruction.deleteMany({ where: { recipeId: testRecipeId } });
    await prisma.recipe.delete({ where: { id: testRecipeId } });

    // Delete user
    await prisma.user.delete({ where: { id: testUserId } });
  });

  beforeEach(async () => {
    // Clean meal plans before each test
    await prisma.mealPlan.deleteMany({ where: { userId: testUserId } });
  });

  describe('Full CRUD Flow', () => {
    it('should create, read, update, and delete meal plan', async () => {
      // CREATE
      const createResponse = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-01-15',
          notes: 'Test meal plan',
        })
        .expect(201);

      const mealPlanId = createResponse.body.data.id;
      expect(createResponse.body.data.notes).toBe('Test meal plan');
      expect(createResponse.body.data.meals).toEqual([]);

      // READ by ID
      const getResponse = await request(app)
        .get(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(getResponse.body.data.id).toBe(mealPlanId);
      expect(getResponse.body.data.notes).toBe('Test meal plan');

      // READ by date
      const getByDateResponse = await request(app)
        .get('/api/meal-plans/date/2025-01-15')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(getByDateResponse.body.data.id).toBe(mealPlanId);

      // READ list
      const listResponse = await request(app)
        .get('/api/meal-plans?startDate=2025-01-01&endDate=2025-01-31')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(listResponse.body.data).toHaveLength(1);
      expect(listResponse.body.data[0].id).toBe(mealPlanId);

      // UPDATE
      const updateResponse = await request(app)
        .put(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({ notes: 'Updated notes' })
        .expect(200);

      expect(updateResponse.body.data.notes).toBe('Updated notes');

      // DELETE
      await request(app)
        .delete(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      // Verify deletion
      await request(app)
        .get(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(404);
    });

    it('should create meal plan with meals', async () => {
      const createResponse = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-01-16',
          notes: 'Meal plan with meals',
          meals: [
            {
              mealType: 'BREAKFAST',
              recipeId: testRecipeId,
              servings: 4,
              notes: 'Morning meal',
            },
            {
              mealType: 'LUNCH',
              recipeId: testRecipeId,
              servings: 6,
            },
          ],
        })
        .expect(201);

      expect(createResponse.body.data.meals).toHaveLength(2);
      expect(createResponse.body.data.meals[0].mealType).toBe('BREAKFAST');
      expect(createResponse.body.data.meals[0].servings).toBe(4);
      expect(createResponse.body.data.meals[1].mealType).toBe('LUNCH');
      expect(createResponse.body.data.meals[1].servings).toBe(6);
    });
  });

  describe('Meal Management', () => {
    let mealPlanId: string;

    beforeEach(async () => {
      // Create a meal plan for each test
      const response = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-01-20',
          notes: 'Test plan for meals',
        });

      mealPlanId = response.body.data.id;
    });

    it('should add meal to meal plan', async () => {
      const addMealResponse = await request(app)
        .post(`/api/meal-plans/${mealPlanId}/meals`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          mealType: 'DINNER',
          recipeId: testRecipeId,
          servings: 4,
          notes: 'Dinner notes',
        })
        .expect(201);

      expect(addMealResponse.body.data.mealType).toBe('DINNER');
      expect(addMealResponse.body.data.servings).toBe(4);
      expect(addMealResponse.body.data.notes).toBe('Dinner notes');

      // Verify meal was added
      const getResponse = await request(app)
        .get(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(getResponse.body.data.meals).toHaveLength(1);
    });

    it('should update meal', async () => {
      // Add a meal first
      const addResponse = await request(app)
        .post(`/api/meal-plans/${mealPlanId}/meals`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          mealType: 'BREAKFAST',
          recipeId: testRecipeId,
          servings: 4,
        });

      const mealId = addResponse.body.data.id;

      // Update the meal
      const updateResponse = await request(app)
        .put(`/api/meal-plans/meals/${mealId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          servings: 8,
          notes: 'Updated meal notes',
          mealType: 'BRUNCH',
        })
        .expect(200);

      expect(updateResponse.body.data.servings).toBe(8);
      expect(updateResponse.body.data.notes).toBe('Updated meal notes');
    });

    it('should delete meal', async () => {
      // Add a meal first
      const addResponse = await request(app)
        .post(`/api/meal-plans/${mealPlanId}/meals`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          mealType: 'LUNCH',
          recipeId: testRecipeId,
          servings: 4,
        });

      const mealId = addResponse.body.data.id;

      // Delete the meal
      await request(app)
        .delete(`/api/meal-plans/meals/${mealId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      // Verify meal was deleted
      const getResponse = await request(app)
        .get(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(getResponse.body.data.meals).toHaveLength(0);
    });

    it('should auto-increment order for meals of same type', async () => {
      // Add first BREAKFAST meal
      const meal1Response = await request(app)
        .post(`/api/meal-plans/${mealPlanId}/meals`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          mealType: 'BREAKFAST',
          recipeId: testRecipeId,
          servings: 4,
        });

      // Add second BREAKFAST meal
      const meal2Response = await request(app)
        .post(`/api/meal-plans/${mealPlanId}/meals`)
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          mealType: 'BREAKFAST',
          recipeId: testRecipeId,
          servings: 2,
        });

      expect(meal1Response.body.data.order).toBe(0);
      expect(meal2Response.body.data.order).toBe(1);
    });
  });

  describe('Shopping List Generation', () => {
    it('should generate shopping list correctly', async () => {
      // Create meal plan with meals
      await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-02-01',
          meals: [
            { mealType: 'BREAKFAST', recipeId: testRecipeId, servings: 4 },
          ],
        });

      // Generate shopping list
      const response = await request(app)
        .post('/api/meal-plans/shopping-list')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          startDate: '2025-02-01',
          endDate: '2025-02-28',
        })
        .expect(200);

      expect(response.body.data.items).toHaveLength(3); // Flour, Sugar, Eggs
      expect(response.body.data.dateRange.start).toBe('2025-02-01');
      expect(response.body.data.dateRange.end).toBe('2025-02-28');
      expect(response.body.data.recipeCount).toBe(1);

      // Verify ingredients
      const flourItem = response.body.data.items.find((item: any) => item.ingredientName === 'Flour');
      expect(flourItem).toBeDefined();
      expect(flourItem.totalAmount).toBe(2);
      expect(flourItem.unit).toBe('cups');
      expect(flourItem.recipes).toContain('Test Recipe for Meal Plans');
    });

    it('should aggregate ingredients from multiple meals', async () => {
      // Create meal plans with same recipe
      await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-03-01',
          meals: [
            { mealType: 'BREAKFAST', recipeId: testRecipeId, servings: 4 },
          ],
        });

      await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-03-02',
          meals: [
            { mealType: 'DINNER', recipeId: testRecipeId, servings: 4 },
          ],
        });

      // Generate shopping list
      const response = await request(app)
        .post('/api/meal-plans/shopping-list')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          startDate: '2025-03-01',
          endDate: '2025-03-31',
        })
        .expect(200);

      // Flour should be doubled (2 cups per recipe * 2 recipes = 4 cups)
      const flourItem = response.body.data.items.find((item: any) => item.ingredientName === 'Flour');
      expect(flourItem.totalAmount).toBe(4);
      expect(response.body.data.recipeCount).toBe(2);
    });

    it('should apply servings multiplier', async () => {
      // Create meal plan with doubled servings
      await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-04-01',
          meals: [
            { mealType: 'DINNER', recipeId: testRecipeId, servings: 8 }, // double the recipe servings (4 -> 8)
          ],
        });

      // Generate shopping list
      const response = await request(app)
        .post('/api/meal-plans/shopping-list')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          startDate: '2025-04-01',
          endDate: '2025-04-30',
        })
        .expect(200);

      // Flour should be doubled (2 cups * 2 = 4 cups)
      const flourItem = response.body.data.items.find((item: any) => item.ingredientName === 'Flour');
      expect(flourItem.totalAmount).toBe(4);

      // Sugar should be doubled (1 cup * 2 = 2 cups)
      const sugarItem = response.body.data.items.find((item: any) => item.ingredientName === 'Sugar');
      expect(sugarItem.totalAmount).toBe(2);
    });

    it('should return empty list for date range with no meals', async () => {
      const response = await request(app)
        .post('/api/meal-plans/shopping-list')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          startDate: '2025-12-01',
          endDate: '2025-12-31',
        })
        .expect(200);

      expect(response.body.data.items).toHaveLength(0);
      expect(response.body.data.recipeCount).toBe(0);
    });
  });

  describe('Upsert Behavior', () => {
    it('should update existing meal plan when creating with same date', async () => {
      // Create initial meal plan
      const createResponse = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-05-01',
          notes: 'Initial notes',
        })
        .expect(201);

      const firstId = createResponse.body.data.id;

      // Create again with same date (should upsert)
      const upsertResponse = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-05-01',
          notes: 'Updated notes',
        })
        .expect(201);

      const secondId = upsertResponse.body.data.id;

      // IDs should be the same (upserted, not created new)
      expect(firstId).toBe(secondId);
      expect(upsertResponse.body.data.notes).toBe('Updated notes');

      // Verify only one meal plan exists for this date
      const listResponse = await request(app)
        .get('/api/meal-plans?startDate=2025-05-01&endDate=2025-05-01')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(listResponse.body.data).toHaveLength(1);
    });
  });

  describe('Cascade Deletes', () => {
    it('should cascade delete meals when deleting meal plan', async () => {
      // Create meal plan with meals
      const createResponse = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-06-01',
          notes: 'Test cascade',
          meals: [
            { mealType: 'BREAKFAST', recipeId: testRecipeId, servings: 4 },
            { mealType: 'LUNCH', recipeId: testRecipeId, servings: 4 },
          ],
        });

      const mealPlanId = createResponse.body.data.id;
      const mealIds = createResponse.body.data.meals.map((m: any) => m.id);

      // Delete meal plan
      await request(app)
        .delete(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      // Verify meals were also deleted
      for (const mealId of mealIds) {
        const mealCount = await prisma.meal.count({
          where: { id: mealId },
        });
        expect(mealCount).toBe(0);
      }
    });
  });

  describe('Authorization', () => {
    let otherUserToken: string;
    let otherUserId: string;
    let mealPlanId: string;

    beforeAll(async () => {
      // Create another user
      const userResponse = await request(app)
        .post('/api/auth/register')
        .send({
          email: `other-user-${Date.now()}@example.com`,
          password: 'OtherPassword123!',
          name: 'Other User',
        });

      otherUserId = userResponse.body.data.user.id;
      otherUserToken = userResponse.body.data.accessToken;
    });

    afterAll(async () => {
      // Cleanup other user
      await prisma.mealPlan.deleteMany({ where: { userId: otherUserId } });
      await prisma.user.delete({ where: { id: otherUserId } });
    });

    beforeEach(async () => {
      // Create meal plan for main user
      const response = await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          date: '2025-07-01',
          notes: 'User 1 plan',
        });

      mealPlanId = response.body.data.id;
    });

    it('should not allow user to read another users meal plan', async () => {
      await request(app)
        .get(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${otherUserToken}`)
        .expect(403);
    });

    it('should not allow user to update another users meal plan', async () => {
      await request(app)
        .put(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${otherUserToken}`)
        .send({ notes: 'Hacked notes' })
        .expect(403);
    });

    it('should not allow user to delete another users meal plan', async () => {
      await request(app)
        .delete(`/api/meal-plans/${mealPlanId}`)
        .set('Authorization', `Bearer ${otherUserToken}`)
        .expect(403);
    });

    it('should not allow user to add meal to another users meal plan', async () => {
      await request(app)
        .post(`/api/meal-plans/${mealPlanId}/meals`)
        .set('Authorization', `Bearer ${otherUserToken}`)
        .send({
          mealType: 'DINNER',
          recipeId: testRecipeId,
        })
        .expect(403);
    });

    it('should not include other users meal plans in list', async () => {
      // Create meal plan for other user
      await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${otherUserToken}`)
        .send({
          date: '2025-07-01',
          notes: 'User 2 plan',
        });

      // Get list for main user
      const response = await request(app)
        .get('/api/meal-plans?startDate=2025-07-01&endDate=2025-07-31')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      // Should only see own meal plan
      expect(response.body.data).toHaveLength(1);
      expect(response.body.data[0].id).toBe(mealPlanId);
    });

    it('should not include other users meals in shopping list', async () => {
      // Create meal plan for other user with same recipe
      await request(app)
        .post('/api/meal-plans')
        .set('Authorization', `Bearer ${otherUserToken}`)
        .send({
          date: '2025-07-02',
          meals: [
            { mealType: 'BREAKFAST', recipeId: testRecipeId, servings: 4 },
          ],
        });

      // Generate shopping list for main user (who has no meals)
      const response = await request(app)
        .post('/api/meal-plans/shopping-list')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          startDate: '2025-07-01',
          endDate: '2025-07-31',
        })
        .expect(200);

      // Should be empty (other user's meals not included)
      expect(response.body.data.items).toHaveLength(0);
      expect(response.body.data.recipeCount).toBe(0);
    });
  });

  describe('Date Range Queries', () => {
    beforeEach(async () => {
      // Create meal plans for multiple dates
      const dates = ['2025-08-01', '2025-08-15', '2025-08-31', '2025-09-01'];

      for (const date of dates) {
        await request(app)
          .post('/api/meal-plans')
          .set('Authorization', `Bearer ${authToken}`)
          .send({
            date,
            notes: `Plan for ${date}`,
          });
      }
    });

    it('should return only meal plans within date range', async () => {
      const response = await request(app)
        .get('/api/meal-plans?startDate=2025-08-01&endDate=2025-08-31')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      expect(response.body.data).toHaveLength(3); // Aug 1, 15, 31 (not Sep 1)
    });

    it('should return meal plans in chronological order', async () => {
      const response = await request(app)
        .get('/api/meal-plans?startDate=2025-08-01&endDate=2025-09-30')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);

      const dates = response.body.data.map((mp: any) => mp.date.split('T')[0]);
      expect(dates).toEqual(['2025-08-01', '2025-08-15', '2025-08-31', '2025-09-01']);
    });
  });
});