/**
 * Port-scoped global reservations list — locks in feat(marina): the new
 * `GET /api/v1/berth-reservations` endpoint that powers the
 * `[portSlug]/berth-reservations` page. The route is thin (parseQuery →
 * listReservations); the test guarantees port scoping at the handler
 * boundary so a future refactor of the service can't accidentally leak
 * cross-port rows.
 */
import { describe, it, expect } from 'vitest';

import { listHandler } from '@/app/api/v1/berth-reservations/handlers';
import { createHandler as createReservationHandler } from '@/app/api/v1/berths/[id]/reservations/handlers';
import { makeMockCtx, makeMockRequest } from '../../helpers/route-tester';
import {
  makeBerth,
  makeClient,
  makeFullPermissions,
  makePort,
  makeYacht,
} from '../../helpers/factories';

async function seedReservation(portId: string) {
  const berth = await makeBerth({ portId });
  const client = await makeClient({ portId });
  const yacht = await makeYacht({ portId, ownerType: 'client', ownerId: client.id });
  const ctx = makeMockCtx({ portId, permissions: makeFullPermissions() });
  const res = await createReservationHandler(
    makeMockRequest('POST', `http://localhost/api/v1/berths/${berth.id}/reservations`, {
      body: {
        clientId: client.id,
        yachtId: yacht.id,
        startDate: new Date().toISOString(),
      },
    }),
    ctx,
    { id: berth.id },
  );
  return ((await res.json()) as any).data as { id: string; berthId: string };
}

describe('GET /api/v1/berth-reservations', () => {
  it('returns all reservations for the requesting port', async () => {
    const port = await makePort();
    const r1 = await seedReservation(port.id);
    const r2 = await seedReservation(port.id);

    const ctx = makeMockCtx({ portId: port.id, permissions: makeFullPermissions() });
    const res = await listHandler(
      makeMockRequest('GET', 'http://localhost/api/v1/berth-reservations'),
      ctx,
    );
    expect(res.status).toBe(200);

    const body = (await res.json()) as any;
    const ids = (body.data as Array<{ id: string }>).map((r) => r.id).sort();
    expect(ids).toEqual([r1.id, r2.id].sort());
    expect(body.pagination).toMatchObject({ page: 1, total: 2 });
  });

  it('does not leak reservations from a different port', async () => {
    const portA = await makePort();
    const portB = await makePort();
    const reservationInB = await seedReservation(portB.id);

    // Caller is operating in portA; portB's reservation must not appear.
    const ctx = makeMockCtx({ portId: portA.id, permissions: makeFullPermissions() });
    const res = await listHandler(
      makeMockRequest('GET', 'http://localhost/api/v1/berth-reservations'),
      ctx,
    );
    expect(res.status).toBe(200);

    const body = (await res.json()) as any;
    const ids = (body.data as Array<{ id: string }>).map((r) => r.id);
    expect(ids).not.toContain(reservationInB.id);
  });

  it('honors pagination via query params', async () => {
    const port = await makePort();
    await seedReservation(port.id);
    await seedReservation(port.id);
    await seedReservation(port.id);

    const ctx = makeMockCtx({ portId: port.id, permissions: makeFullPermissions() });
    const res = await listHandler(
      makeMockRequest('GET', 'http://localhost/api/v1/berth-reservations?page=1&limit=2'),
      ctx,
    );
    expect(res.status).toBe(200);

    const body = (await res.json()) as any;
    expect(body.data).toHaveLength(2);
    expect(body.pagination).toMatchObject({
      page: 1,
      pageSize: 2,
      total: 3,
      totalPages: 2,
      hasNextPage: true,
      hasPreviousPage: false,
    });
  });
});
