import {
  DayAssignmentsController,
  AssignmentOpsController,
} from '../../../src/nest/assignments/assignments.controller';
import type { AssignmentsService } from '../../../src/nest/assignments/assignments.service';
import type { User } from '../../../src/types';
import { ConflictException, HttpException } from '@nestjs/common';

import { describe, it, expect, vi } from 'vitest';

const user = { id: 1, role: 'user', email: 'u@example.test' } as User;
const trip = { user_id: 1 };

function svc(o: Partial<AssignmentsService> = {}): AssignmentsService {
  return {
    verifyTripAccess: vi.fn().mockReturnValue(trip),
    canEdit: vi.fn().mockReturnValue(true),
    broadcast: vi.fn(),
    dayExists: vi.fn().mockReturnValue(true),
    placeExists: vi.fn().mockReturnValue(true),
    reconcile: vi.fn().mockResolvedValue(undefined),
    ...o,
  } as unknown as AssignmentsService;
}

async function thrownAsync(fn: () => Promise<unknown>): Promise<{ status: number; body: unknown }> {
  try {
    await fn();
  } catch (err) {
    expect(err).toBeInstanceOf(HttpException);
    const e = err as HttpException;
    return { status: e.getStatus(), body: e.getResponse() };
  }
  throw new Error('expected throw');
}

describe('DayAssignmentsController (parity with the legacy day-assignments routes)', () => {
  // The 404 "Trip not found" and 403 "No permission" cases moved to
  // trip-access.guard.test.ts with the check itself.
  it('404 day on GET', async () => {
    const s = svc({ dayExists: vi.fn().mockReturnValue(false) } as Partial<AssignmentsService>);
    expect(await thrownAsync(() => new DayAssignmentsController(s).list(user, '5', '9'))).toEqual({
      status: 404,
      body: { error: 'Day not found' },
    });
  });

  it('GET returns assignments (access-only, no permission gate)', async () => {
    const s = svc({
      canEdit: vi.fn().mockReturnValue(false),
      listDayAssignments: vi.fn().mockReturnValue([{ id: 1 }]),
    } as Partial<AssignmentsService>);
    expect(await new DayAssignmentsController(s).list(user, '5', '3')).toEqual({ assignments: [{ id: 1 }] });
  });

  describe('POST', () => {
    it('404 place not found; then creates + hooks', async () => {
      expect(
        await thrownAsync(() =>
          new DayAssignmentsController(
            svc({ placeExists: vi.fn().mockReturnValue(false) } as Partial<AssignmentsService>),
          ).create(user, '5', '3', { place_id: 2 }),
        ),
      ).toEqual({ status: 404, body: { error: 'Place not found' } });
      const createAssignment = vi.fn().mockReturnValue({ id: 9 });
      const broadcast = vi.fn();
      const reconcile = vi.fn().mockResolvedValue(undefined);
      const s = svc({ createAssignment, broadcast, reconcile } as Partial<AssignmentsService>);
      expect(await new DayAssignmentsController(s).create(user, '5', '3', { place_id: 2, notes: 'n' }, 'sock')).toEqual(
        { assignment: { id: 9 } },
      );
      expect(createAssignment).toHaveBeenCalledWith('3', 2, 'n');
      expect(broadcast).toHaveBeenCalledWith('5', 'assignment:created', { assignment: { id: 9 } }, 'sock');
      expect(reconcile).toHaveBeenCalledWith('5', 'sock');
    });

    it('409 duplicate Tour assignment propagates without announcing a new assignment', async () => {
      const broadcast = vi.fn();
      const reconcile = vi.fn();
      const createAssignment = vi.fn().mockRejectedValue(new ConflictException('Tour is already assigned to this day'));
      const controller = new DayAssignmentsController(
        svc({ createAssignment, broadcast, reconcile } as Partial<AssignmentsService>),
      );

      expect(await thrownAsync(() => controller.create(user, '5', '3', { place_id: 42 }))).toMatchObject({
        status: 409,
      });
      expect(createAssignment).toHaveBeenCalledWith('3', 42, undefined);
      expect(broadcast).not.toHaveBeenCalled();
      expect(reconcile).not.toHaveBeenCalled();
    });
  });

  it('PUT /reorder 404 day, else reorders + broadcasts', async () => {
    expect(
      await thrownAsync(() =>
        new DayAssignmentsController(
          svc({ dayExists: vi.fn().mockReturnValue(false) } as Partial<AssignmentsService>),
        ).reorder(user, '5', '3', { orderedIds: [1, 2] }),
      ),
    ).toEqual({ status: 404, body: { error: 'Day not found' } });
    const reorderAssignments = vi.fn();
    const broadcast = vi.fn();
    expect(
      await new DayAssignmentsController(svc({ reorderAssignments, broadcast } as Partial<AssignmentsService>)).reorder(
        user,
        '5',
        '3',
        { orderedIds: [2, 1] },
        'sock',
      ),
    ).toEqual({ success: true });
    expect(reorderAssignments).toHaveBeenCalledWith('3', [2, 1]);
    expect(broadcast).toHaveBeenCalledWith('5', 'assignment:reordered', { dayId: 3, orderedIds: [2, 1] }, 'sock');
  });

  it('DELETE /:id 404 when not in day, else success', async () => {
    expect(
      await thrownAsync(() =>
        new DayAssignmentsController(
          svc({ assignmentExistsInDay: vi.fn().mockReturnValue(false) } as Partial<AssignmentsService>),
        ).remove(user, '5', '3', '9'),
      ),
    ).toEqual({ status: 404, body: { error: 'Assignment not found' } });
    const reconcile = vi.fn().mockResolvedValue(undefined);
    const s = svc({
      assignmentExistsInDay: vi.fn().mockReturnValue(true),
      deleteAssignment: vi.fn(),
      reconcile,
    } as Partial<AssignmentsService>);
    expect(await new DayAssignmentsController(s).remove(user, '5', '3', '9', 'sock')).toEqual({ success: true });
    expect(reconcile).toHaveBeenCalledWith('5', 'sock');
  });

  it('DELETE / (clear day) 404 day, else empties the day and announces every removal (#2470)', async () => {
    expect(
      await thrownAsync(() =>
        new DayAssignmentsController(
          svc({ dayExists: vi.fn().mockReturnValue(false) } as Partial<AssignmentsService>),
        ).clear(user, '5', '3'),
      ),
    ).toEqual({ status: 404, body: { error: 'Day not found' } });
    const clearDay = vi.fn().mockResolvedValue([7, 8]);
    const broadcast = vi.fn();
    const reconcile = vi.fn().mockResolvedValue(undefined);
    const s = svc({ clearDay, broadcast, reconcile } as Partial<AssignmentsService>);
    expect(await new DayAssignmentsController(s).clear(user, '5', '3', 'sock')).toEqual({
      success: true,
      removedIds: [7, 8],
    });
    expect(clearDay).toHaveBeenCalledWith('3');
    expect(broadcast).toHaveBeenCalledWith('5', 'assignment:deleted', { assignmentId: 7, dayId: 3 }, 'sock');
    expect(broadcast).toHaveBeenCalledWith('5', 'assignment:deleted', { assignmentId: 8, dayId: 3 }, 'sock');
    expect(reconcile).toHaveBeenCalledWith('5', 'sock');
  });

  it('DELETE / on an already empty day succeeds without a journey reconcile', async () => {
    const reconcile = vi.fn();
    const broadcast = vi.fn();
    const s = svc({ clearDay: vi.fn().mockResolvedValue([]), reconcile, broadcast } as Partial<AssignmentsService>);
    expect(await new DayAssignmentsController(s).clear(user, '5', '3')).toEqual({ success: true, removedIds: [] });
    expect(broadcast).not.toHaveBeenCalled();
    expect(reconcile).not.toHaveBeenCalled();
  });
});

describe('AssignmentOpsController (parity with the per-assignment op routes)', () => {
  it('PUT /:id/route takes a stop out of the route and back, scoped to the trip (#2532)', async () => {
    const setRouteExcluded = vi.fn().mockResolvedValue({ id: 9, route_excluded: true });
    const s = svc({
      getAssignmentForTrip: vi.fn().mockResolvedValue({ id: 9 }),
      setRouteExcluded,
    } as Partial<AssignmentsService>);
    const controller = new AssignmentOpsController(s);
    expect(await controller.route(user, '5', '9', { excluded: true }, 'sock')).toEqual({
      assignment: { id: 9, route_excluded: true },
    });
    expect(setRouteExcluded).toHaveBeenCalledWith('9', true);
    expect(s.broadcast).toHaveBeenCalledWith(
      '5',
      'assignment:updated',
      { assignment: { id: 9, route_excluded: true } },
      'sock',
    );
    vi.mocked(s.getAssignmentForTrip).mockResolvedValue(undefined);
    expect(await thrownAsync(() => controller.route(user, '5', '9', { excluded: false }))).toEqual({
      status: 404,
      body: { error: 'Assignment not found' },
    });
  });

  it('scopes explicit day ends to the trip and broadcasts the saved visit', async () => {
    const setEndDay = vi.fn().mockReturnValue({ id: 9, end_day: true });
    const s = svc({ getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }), setEndDay });
    const controller = new AssignmentOpsController(s);
    expect(await controller.endDay('5', '9', { end_day: true }, 'sock')).toEqual({
      assignment: { id: 9, end_day: true },
    });
    expect(s.getAssignmentForTrip).toHaveBeenCalledWith('9', '5');
    expect(setEndDay).toHaveBeenCalledWith('9', true);
    expect(s.broadcast).toHaveBeenCalledWith(
      '5',
      'assignment:updated',
      { assignment: { id: 9, end_day: true } },
      'sock',
    );
    vi.mocked(s.getAssignmentForTrip).mockReturnValue(undefined);
    expect(await thrownAsync(() => controller.endDay('5', '9', { end_day: false }))).toEqual({
      status: 404,
      body: { error: 'Assignment not found' },
    });
  });

  it('PUT /:id/move 404 assignment, 404 target day, else moves', async () => {
    expect(
      await thrownAsync(() =>
        new AssignmentOpsController(
          svc({ getAssignmentForTrip: vi.fn().mockReturnValue(undefined) } as Partial<AssignmentsService>),
        ).move(user, '5', '9', { new_day_id: 4 }),
      ),
    ).toEqual({ status: 404, body: { error: 'Assignment not found' } });
    expect(
      await thrownAsync(() =>
        new AssignmentOpsController(
          svc({
            getAssignmentForTrip: vi.fn().mockReturnValue({ day_id: 3 }),
            dayExists: vi.fn().mockReturnValue(false),
          } as Partial<AssignmentsService>),
        ).move(user, '5', '9', { new_day_id: 4 }),
      ),
    ).toEqual({ status: 404, body: { error: 'Target day not found' } });
    const moveAssignment = vi.fn().mockReturnValue({ assignment: { id: 9 }, oldDayId: 3 });
    const broadcast = vi.fn();
    const reconcile = vi.fn().mockResolvedValue(undefined);
    const s = svc({
      getAssignmentForTrip: vi.fn().mockReturnValue({ day_id: 3 }),
      moveAssignment,
      broadcast,
      reconcile,
    } as Partial<AssignmentsService>);
    expect(
      await new AssignmentOpsController(s).move(user, '5', '9', { new_day_id: 4, order_index: 0 }, 'sock'),
    ).toEqual({ assignment: { id: 9 } });
    expect(moveAssignment).toHaveBeenCalledWith('9', 4, 0);
    expect(broadcast).toHaveBeenCalledWith(
      '5',
      'assignment:moved',
      { assignment: { id: 9 }, oldDayId: 3, newDayId: 4 },
      'sock',
    );
    expect(reconcile).toHaveBeenCalledWith('5', 'sock');
  });

  it('GET /:id/participants 404 when the assignment is on another trip, else returns participants (access-only)', async () => {
    expect(
      await thrownAsync(() =>
        new AssignmentOpsController(
          svc({ getAssignmentForTrip: vi.fn().mockReturnValue(undefined) } as Partial<AssignmentsService>),
        ).participants(user, '5', '9'),
      ),
    ).toEqual({ status: 404, body: { error: 'Assignment not found' } });
    const s = svc({
      getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }),
      getParticipants: vi.fn().mockReturnValue([{ user_id: 2 }]),
    } as Partial<AssignmentsService>);
    expect(await new AssignmentOpsController(s).participants(user, '5', '9')).toEqual({
      participants: [{ user_id: 2 }],
    });
  });

  it('PUT /:id/time 404 missing, else updates', async () => {
    expect(
      await thrownAsync(() =>
        new AssignmentOpsController(
          svc({ getAssignmentForTrip: vi.fn().mockReturnValue(undefined) } as Partial<AssignmentsService>),
        ).time(user, '5', '9', {}),
      ),
    ).toEqual({ status: 404, body: { error: 'Assignment not found' } });
    const updateTime = vi.fn().mockReturnValue({ assignment: { id: 9 }, reordered: null, vias: null });
    const broadcast = vi.fn();
    const reconcile = vi.fn().mockResolvedValue(undefined);
    const s = svc({
      getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }),
      updateTime,
      broadcast,
      reconcile,
    } as Partial<AssignmentsService>);
    expect(await new AssignmentOpsController(s).time(user, '5', '9', { place_time: '10:00' }, 'sock')).toEqual({
      assignment: { id: 9 },
    });
    expect(updateTime).toHaveBeenCalledWith('9', '10:00', undefined);
    // Nothing moved, so the row is all collaborators hear about.
    expect(broadcast.mock.calls).toEqual([['5', 'assignment:updated', { assignment: { id: 9 } }, 'sock']]);
    expect(reconcile).toHaveBeenCalledWith('5', 'sock');
  });

  it('PUT /:id/time sends the whole day and the re-pinned vias to every socket when a start moved stops', async () => {
    const reordered = { dayId: 3, orderedIds: [7, 9, 8] };
    const vias = { dayId: 3, vias: [{ id: 40, day_id: 3, after_order_index: 1, sequence: 0, lat: 1, lng: 2 }] };
    const updateTime = vi.fn().mockReturnValue({ assignment: { id: 9 }, reordered, vias });
    const broadcast = vi.fn();
    const s = svc({
      getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }),
      updateTime,
      broadcast,
    } as Partial<AssignmentsService>);

    expect(await new AssignmentOpsController(s).time(user, '5', '9', { place_time: '10:00' }, 'sock')).toEqual({
      assignment: { id: 9 },
    });

    expect(broadcast.mock.calls).toEqual([
      ['5', 'assignment:updated', { assignment: { id: 9 } }, 'sock'],
      // The writer's socket too, so the order and the vias pinned to it arrive
      // together there as well, a replayed offline save included.
      ['5', 'assignment:reordered', reordered, undefined],
      ['5', 'roadtripVia:changed', vias, undefined],
    ]);
  });

  it('PUT /:id/notes 404 missing, else updates + broadcasts (#2163)', async () => {
    expect(
      await thrownAsync(() =>
        new AssignmentOpsController(
          svc({ getAssignmentForTrip: vi.fn().mockReturnValue(undefined) } as Partial<AssignmentsService>),
        ).notes(user, '5', '9', { notes: 'n' }),
      ),
    ).toEqual({ status: 404, body: { error: 'Assignment not found' } });
    const updateNotes = vi.fn().mockReturnValue({ id: 9, notes: 'Book the 10:00 entry' });
    const broadcast = vi.fn();
    const reconcile = vi.fn().mockResolvedValue(undefined);
    const s = svc({
      getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }),
      updateNotes,
      broadcast,
      reconcile,
    } as Partial<AssignmentsService>);
    expect(
      await new AssignmentOpsController(s).notes(user, '5', '9', { notes: 'Book the 10:00 entry' }, 'sock'),
    ).toEqual({ assignment: { id: 9, notes: 'Book the 10:00 entry' } });
    expect(updateNotes).toHaveBeenCalledWith('9', 'Book the 10:00 entry');
    expect(broadcast).toHaveBeenCalledWith(
      '5',
      'assignment:updated',
      { assignment: { id: 9, notes: 'Book the 10:00 entry' } },
      'sock',
    );
    // The note touches neither day order nor the journey skeleton — no reconcile.
    expect(reconcile).not.toHaveBeenCalled();
  });

  it("PUT /:id/participants 404 on a foreign assignment, else sets + broadcasts (non-array bodies are the Zod pipe's 400, covered in e2e)", async () => {
    const setParticipants = vi.fn().mockReturnValue([{ user_id: 2 }]);
    const broadcast = vi.fn();
    expect(
      await thrownAsync(() =>
        new AssignmentOpsController(
          svc({
            getAssignmentForTrip: vi.fn().mockReturnValue(undefined),
            setParticipants,
          } as Partial<AssignmentsService>),
        ).setParticipants(user, '5', '9', { user_ids: [2] }),
      ),
    ).toEqual({ status: 404, body: { error: 'Assignment not found' } });
    expect(setParticipants).not.toHaveBeenCalled();
    const s = svc({
      getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }),
      setParticipants,
      broadcast,
    } as Partial<AssignmentsService>);
    expect(await new AssignmentOpsController(s).setParticipants(user, '5', '9', { user_ids: [2] }, 'sock')).toEqual({
      participants: [{ user_id: 2 }],
    });
    // The trip comes along so the service can confine the ids to its roster.
    expect(setParticipants).toHaveBeenCalledWith('9', [2], '5');
    expect(broadcast).toHaveBeenCalledWith(
      '5',
      'assignment:participants',
      { assignmentId: 9, participants: [{ user_id: 2 }] },
      'sock',
    );
  });
});