jest.mock('@/api/doormile/endpoints', () => ({
  __esModule: true,
  getBookings: jest.fn(),
  getBooking: jest.fn(),
  getConsignments: jest.fn(),
  getAdminCustomers: jest.fn(),
  getAdminTenants: jest.fn(),
  getMilers: jest.fn(),
  getMiler: jest.fn(),
  getMilerSummary: jest.fn(),
  getMilerLogs: jest.fn(),
  notifyMiler: jest.fn(),
  getTenantLocations: jest.fn(),
  getHubs: jest.fn(),
  assignMilerToBooking: jest.fn(),
  cancelBooking: jest.fn(),
  updateConsignmentStatus: jest.fn(),
  getAdminPricing: jest.fn(),
  getReports: jest.fn(),
  getLocationsSummary: jest.fn(),
  getProfile: jest.fn()
}));
jest.mock('@/api/doormile/notify', () => ({
  __esModule: true,
  OpenToast: jest.fn(),
  messageOf: jest.fn((err, fallback) => err?.message || fallback)
}));

import * as endpoints from '@/api/doormile/endpoints';
import { OpenToast } from '@/api/doormile/notify';
import {
  fetchDeliveries,
  fetchCountAPI,
  cancelDeliveryAPI,
  changeRiderAPI,
  updateDeliveryAPI,
  getorderdetails
} from '@/api/doormile/queries';

/**
 * A booking as GET /admin/bookings returns it. Defaults make the row
 * "dispatched" (it carries an assigned rider), because fetchDeliveries only
 * surfaces dispatched rows.
 */
const booking = (over = {}) => ({
  bookingid: 4021,
  bookingno: 'DM-4021',
  status: 'Miler_Assigned',
  assignedmileruserid: 91,
  tenantid: 4,
  createdat: '2026-08-27T10:00:00',
  updatedat: '2026-08-27T10:05:00',
  pickupaddress: '12 MG Road, Bengaluru',
  deliveryaddress: '44 Indiranagar, Bengaluru',
  ...over
});

/** The query key every caller of fetchDeliveries builds. */
const key = ({ status = 'all', startdate, enddate, rowsPerPage = 100 } = {}) => [
  'deliveries',
  1,
  null,
  status,
  startdate,
  enddate,
  rowsPerPage
];

const withNoJoins = () => {
  endpoints.getAdminCustomers.mockResolvedValue([]);
  endpoints.getMilers.mockResolvedValue([]);
  endpoints.getAdminTenants.mockResolvedValue([]);
  endpoints.getConsignments.mockResolvedValue([]);
};

describe('deliveries data layer', () => {
  beforeEach(withNoJoins);

  describe('fetchDeliveries — dispatched filtering', () => {
    it('should surface a booking that already has a rider assigned', async () => {
      endpoints.getBookings.mockResolvedValue([booking()]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows).toHaveLength(1);
      expect(rows[0]).toMatchObject({ bookingid: 4021, deliveryid: 4021, orderheaderid: 4021 });
    });

    it.each(['pending_pickup', 'created', 'new', 'booked', 'order_placed', 'unassigned'])(
      'should exclude an undispatched %s booking with no rider and no consignment',
      async (status) => {
        endpoints.getBookings.mockResolvedValue([
          booking({ status, assignedmileruserid: null, consignmentid: null })
        ]);
        const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
        expect(rows).toEqual([]);
      }
    );

    it('should surface an undispatched-looking booking that nonetheless has a consignment', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ status: 'pending_pickup', assignedmileruserid: null, consignmentid: 40 })
      ]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows).toHaveLength(1);
      expect(rows[0].consignmentid).toBe(40);
    });

    it('should surface a booking whose status has moved past the pre-dispatch set', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ status: 'Out_for_Delivery', assignedmileruserid: null, consignmentid: null })
      ]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows).toHaveLength(1);
    });
  });

  describe('fetchDeliveries — row mapping', () => {
    it('should resolve the rider name from the joined miler list', async () => {
      endpoints.getBookings.mockResolvedValue([booking()]);
      endpoints.getMilers.mockResolvedValue([
        { userid: 91, milerprofileid: 11, firstname: 'Anita', lastname: 'Rao', phone: '9876543210' }
      ]);

      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0]).toMatchObject({
        ridername: 'Anita Rao',
        userid: 91,
        milerprofileid: 11,
        ridercontact: '9876543210'
      });
    });

    it('should fall back to a numbered rider label when the miler join fails', async () => {
      // A failed join must degrade a display field, not blank the page.
      endpoints.getBookings.mockResolvedValue([booking()]);
      endpoints.getMilers.mockRejectedValue(new Error('milers 500'));

      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows).toHaveLength(1);
      expect(rows[0].ridername).toBe('Rider #91');
    });

    it('should resolve the delivery customer from the joined customer list', async () => {
      endpoints.getBookings.mockResolvedValue([booking({ appcustomerid: 7 })]);
      endpoints.getAdminCustomers.mockResolvedValue([
        { appcustomerid: 7, firstname: 'Vikram', phone: '9000000000' }
      ]);

      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0]).toMatchObject({ deliverycustomer: 'Vikram', deliverycontactno: '9000000000', deliverytype: 'B' });
    });

    it('should mark a row with no matched customer as a C-type delivery', async () => {
      endpoints.getBookings.mockResolvedValue([booking()]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].deliverytype).toBe('C');
    });

    it('should bucket on the booking creation time, exposed as orderdate', async () => {
      // Batch bucketing and date filtering both read orderdate; if this stops
      // being createdat, rows are counted for a day but belong to no batch.
      endpoints.getBookings.mockResolvedValue([booking({ createdat: '2026-08-27T07:00:00' })]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].orderdate).toBe('2026-08-27T07:00:00');
    });

    it('should approximate distance as a straight line between the two coordinates', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({
          pickuplatitude: 12.9716,
          pickuplongitude: 77.5946,
          deliverylatitude: 12.9352,
          deliverylongitude: 77.6245
        })
      ]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].kms).toBeGreaterThan(4);
      expect(rows[0].kms).toBeLessThan(7);
    });

    it('should leave distance undefined — not zero — when a coordinate is missing', async () => {
      // A fabricated 0 km reads as a measured distance and feeds the rate card.
      endpoints.getBookings.mockResolvedValue([booking({ pickuplatitude: null })]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].kms).toBeUndefined();
    });

    it('should leave route-plan fields undefined rather than fabricating them', async () => {
      endpoints.getBookings.mockResolvedValue([booking()]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].transitminutes).toBeUndefined();
      expect(rows[0].cumulativekms).toBeUndefined();
      expect(rows[0].step).toBeUndefined();
    });

    it('should count parcels as the row quantity, defaulting to zero', async () => {
      endpoints.getBookings.mockResolvedValue([booking({ parcels: [{}, {}] }), booking({ bookingid: 4022 })]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].quantity).toBe(2);
      expect(rows[1].quantity).toBe(0);
    });

    it('should carry the service charge through to every amount field the table reads', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ serviceoptions: [{ estimatedprice: 240, estimateddeliveryat: '2026-08-27T12:00:00' }] })
      ]);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0]).toMatchObject({ deliverycharges: 240, deliveryamt: 240, deliveryamount: 240 });
      expect(rows[0].expecteddeliverytime).toBe('2026-08-27T12:00:00');
    });

    it('should let the consignment status drive the row status', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ status: 'Converted_To_Consignment', consignmentid: 40 })
      ]);
      endpoints.getConsignments.mockResolvedValue([{ consignmentid: 40, status: 'Out_for_Delivery' }]);

      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].orderstatus).toBe('active');
      expect(rows[0].statusfromconsignment).toBe(true);
    });

    it('should fall back to the booking status when the consignment join fails', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ status: 'Converted_To_Consignment', consignmentid: 40 })
      ]);
      endpoints.getConsignments.mockRejectedValue(new Error('consignments 500'));

      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows[0].orderstatus).toBe('picked');
    });
  });

  describe('fetchDeliveries — date range', () => {
    const threeDays = [
      booking({ bookingid: 1, createdat: '2026-08-25T10:00:00' }),
      booking({ bookingid: 2, createdat: '2026-08-26T10:00:00' }),
      booking({ bookingid: 3, createdat: '2026-08-27T10:00:00' })
    ];

    it('should return every row when no range is given', async () => {
      endpoints.getBookings.mockResolvedValue(threeDays);
      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows).toHaveLength(3);
    });

    it('should apply the requested range instead of ignoring it', async () => {
      // The regression: startdate/enddate were accepted and then dropped, so
      // today, yesterday and last week all produced a byte-identical row set.
      endpoints.getBookings.mockResolvedValue(threeDays);
      const { rows } = await fetchDeliveries({
        pageParam: 1,
        queryKey: key({ startdate: '2026-08-26', enddate: '2026-08-26' })
      });
      expect(rows.map((r) => r.bookingid)).toEqual([2]);
    });

    it('should include both range boundaries', async () => {
      endpoints.getBookings.mockResolvedValue(threeDays);
      const { rows } = await fetchDeliveries({
        pageParam: 1,
        queryKey: key({ startdate: '2026-08-25', enddate: '2026-08-27' })
      });
      expect(rows).toHaveLength(3);
    });

    it('should treat a missing bound as unbounded on that side', async () => {
      endpoints.getBookings.mockResolvedValue(threeDays);
      const from = await fetchDeliveries({ pageParam: 1, queryKey: key({ startdate: '2026-08-26' }) });
      expect(from.rows.map((r) => r.bookingid)).toEqual([2, 3]);

      const until = await fetchDeliveries({ pageParam: 1, queryKey: key({ enddate: '2026-08-26' }) });
      expect(until.rows.map((r) => r.bookingid)).toEqual([1, 2]);
    });

    it('should keep a late-evening row on its own day despite a false trailing Z', async () => {
      // Unstripped, 23:45Z shifts +5:30 into the next day and drops out of the
      // selected date entirely.
      endpoints.getBookings.mockResolvedValue([booking({ createdat: '2026-08-27T23:45:00Z' })]);
      const { rows } = await fetchDeliveries({
        pageParam: 1,
        queryKey: key({ startdate: '2026-08-27', enddate: '2026-08-27' })
      });
      expect(rows).toHaveLength(1);
    });

    it('should drop a row with an unparseable creation date when a range is set', async () => {
      endpoints.getBookings.mockResolvedValue([booking({ createdat: 'garbage' })]);
      const { rows } = await fetchDeliveries({
        pageParam: 1,
        queryKey: key({ startdate: '2026-08-27', enddate: '2026-08-27' })
      });
      expect(rows).toEqual([]);
    });

    it('should return an empty page for a range with no rows', async () => {
      endpoints.getBookings.mockResolvedValue(threeDays);
      const { rows } = await fetchDeliveries({
        pageParam: 1,
        queryKey: key({ startdate: '2026-01-01', enddate: '2026-01-02' })
      });
      expect(rows).toEqual([]);
    });
  });

  describe('fetchDeliveries — pagination and failure', () => {
    it('should advertise a next page when the server returned a full page', async () => {
      endpoints.getBookings.mockResolvedValue(Array.from({ length: 25 }, (_, i) => booking({ bookingid: i + 1 })));
      const result = await fetchDeliveries({ pageParam: 1, queryKey: key({ rowsPerPage: 25 }) });
      expect(result.nextPage).toBe(2);
    });

    it('should stop paginating on a partial page', async () => {
      endpoints.getBookings.mockResolvedValue(Array.from({ length: 9 }, (_, i) => booking({ bookingid: i + 1 })));
      const result = await fetchDeliveries({ pageParam: 1, queryKey: key({ rowsPerPage: 25 }) });
      expect(result.nextPage).toBeUndefined();
    });

    it('should request the page the caller asked for', async () => {
      endpoints.getBookings.mockResolvedValue([]);
      await fetchDeliveries({ pageParam: 3, queryKey: key({ rowsPerPage: 50 }) });
      expect(endpoints.getBookings).toHaveBeenCalledWith(3, 50);
    });

    it('should default to the first page when pageParam is omitted', async () => {
      endpoints.getBookings.mockResolvedValue([]);
      await fetchDeliveries({ queryKey: key({ rowsPerPage: 50 }) });
      expect(endpoints.getBookings).toHaveBeenCalledWith(1, 50);
    });

    it('should toast and return an empty page when the bookings call fails', async () => {
      // The one join it cannot recover from — previously it rejected uncaught,
      // with no toast anywhere across the four pages that call this.
      endpoints.getBookings.mockRejectedValue({ message: 'bookings 503' });

      const result = await fetchDeliveries({ pageParam: 1, queryKey: key() });

      expect(result).toEqual({ rows: [], nextPage: undefined });
      expect(OpenToast).toHaveBeenCalledWith('bookings 503', 'error', 2000);
    });

    it('should still render rows when every optional join fails', async () => {
      endpoints.getBookings.mockResolvedValue([booking()]);
      endpoints.getAdminCustomers.mockRejectedValue(new Error('x'));
      endpoints.getMilers.mockRejectedValue(new Error('x'));
      endpoints.getAdminTenants.mockRejectedValue(new Error('x'));
      endpoints.getConsignments.mockRejectedValue(new Error('x'));

      const { rows } = await fetchDeliveries({ pageParam: 1, queryKey: key() });
      expect(rows).toHaveLength(1);
    });

    it('should return an empty page for an account with no bookings', async () => {
      endpoints.getBookings.mockResolvedValue([]);
      await expect(fetchDeliveries({ pageParam: 1, queryKey: key() })).resolves.toEqual({
        rows: [],
        nextPage: undefined
      });
    });
  });

  describe('fetchCountAPI', () => {
    it('should count dispatched rows into the page chip buckets', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ bookingid: 1, status: 'Miler_Assigned' }),
        booking({ bookingid: 2, status: 'Pickup_Scheduled' }),
        booking({ bookingid: 3, status: 'Converted_To_Consignment' }),
        booking({ bookingid: 4, status: 'Out_for_Delivery' }),
        booking({ bookingid: 5, status: 'Delivered' }),
        booking({ bookingid: 6, status: 'Cancelled' })
      ]);

      await expect(fetchCountAPI()).resolves.toEqual({
        total: 6,
        uncoveredLength: 1,
        assignedLength: 1,
        arrivedLength: 0,
        pickedLength: 1,
        activeLength: 1,
        coveredLength: 1,
        cancelLength: 1,
        skippedLength: 0
      });
    });

    it('should count only dispatched bookings, matching what the table shows', async () => {
      endpoints.getBookings.mockResolvedValue([
        booking({ bookingid: 1, status: 'pending_pickup', assignedmileruserid: null }),
        booking({ bookingid: 2, status: 'Delivered' })
      ]);
      const counts = await fetchCountAPI();
      expect(counts.total).toBe(1);
      expect(counts.coveredLength).toBe(1);
    });

    it('should report zeroes — not undefined — for an empty account', async () => {
      endpoints.getBookings.mockResolvedValue([]);
      const counts = await fetchCountAPI();
      Object.values(counts).forEach((value) => expect(value).toBe(0));
    });

    it('should report zeroes rather than throwing when the source call fails', async () => {
      endpoints.getBookings.mockRejectedValue(new Error('boom'));
      const counts = await fetchCountAPI();
      expect(counts.total).toBe(0);
    });
  });

  describe('cancelDeliveryAPI', () => {
    it('should cancel through the booking-level cancel action', async () => {
      endpoints.cancelBooking.mockResolvedValue({ success: true });
      await cancelDeliveryAPI({ orderheaderid: 4021 }, 'customer unreachable');
      expect(endpoints.cancelBooking).toHaveBeenCalledWith(4021, { reason: 'customer unreachable' });
    });

    it('should fall back to deliveryid when the row carries no orderheaderid', async () => {
      endpoints.cancelBooking.mockResolvedValue({ success: true });
      await cancelDeliveryAPI({ deliveryid: 4022 }, 'duplicate');
      expect(endpoints.cancelBooking).toHaveBeenCalledWith(4022, { reason: 'duplicate' });
    });

    it('should send an undefined reason rather than inventing one', async () => {
      endpoints.cancelBooking.mockResolvedValue({ success: true });
      await cancelDeliveryAPI({ orderheaderid: 4021 });
      expect(endpoints.cancelBooking).toHaveBeenCalledWith(4021, { reason: undefined });
    });

    it('should surface a rejected cancel to the caller', async () => {
      endpoints.cancelBooking.mockRejectedValue({ message: 'already cancelled', httpStatus: 409 });
      await expect(cancelDeliveryAPI({ orderheaderid: 4021 }, 'x')).rejects.toMatchObject({ httpStatus: 409 });
    });

    describe('a row that has already converted to a consignment', () => {
      const converted = { bookingid: 41, deliveryid: 41, orderheaderid: 41, consignmentid: 61 };

      it('should cancel on the consignment, where the lifecycle now lives', async () => {
        // A booking freezes the moment the parcel is picked up; the booking-level
        // cancel route is refused for it.
        endpoints.updateConsignmentStatus.mockResolvedValue({ success: true });

        await cancelDeliveryAPI(converted, 'customer unreachable');

        expect(endpoints.updateConsignmentStatus).toHaveBeenCalledWith(61, { status: 'Cancelled' });
      });

      it('should NOT also call the booking cancel route', async () => {
        endpoints.updateConsignmentStatus.mockResolvedValue({ success: true });
        await cancelDeliveryAPI(converted, 'x');
        expect(endpoints.cancelBooking).not.toHaveBeenCalled();
      });

      it('should surface the consignment failure instead of retrying on the booking', async () => {
        // The reported bug: PUT /admin/consignments/61/status returned 500, the
        // code silently fell back to POST /admin/bookings/41/cancel, and the
        // operator was shown that route's 400 — an error about the wrong
        // endpoint entirely, which is why the real fault was invisible.
        endpoints.updateConsignmentStatus.mockRejectedValue({
          message: 'failed to update consignment status',
          httpStatus: 500
        });
        endpoints.cancelBooking.mockRejectedValue({ message: 'booking cannot be cancelled', httpStatus: 400 });

        await expect(cancelDeliveryAPI(converted, 'x')).rejects.toMatchObject({
          message: 'failed to update consignment status',
          httpStatus: 500
        });
        expect(endpoints.cancelBooking).not.toHaveBeenCalled();
      });

      it('should surface a refusal envelope from the consignment route unchanged', async () => {
        endpoints.updateConsignmentStatus.mockResolvedValue({ success: false, message: 'already delivered' });

        await expect(cancelDeliveryAPI(converted, 'x')).resolves.toEqual({
          success: false,
          message: 'already delivered'
        });
        expect(endpoints.cancelBooking).not.toHaveBeenCalled();
      });

      it('should never cancel a booking whose consignment is still live', async () => {
        // The integrity hazard behind the removed fallback: a cancelled booking
        // sitting against a consignment that is still out for delivery.
        endpoints.updateConsignmentStatus.mockRejectedValue({ httpStatus: 500, message: 'boom' });
        await cancelDeliveryAPI(converted, 'x').catch(() => { });
        expect(endpoints.cancelBooking).not.toHaveBeenCalled();
      });
    });

    it('should still use the booking route for a row that has not converted', async () => {
      endpoints.cancelBooking.mockResolvedValue({ success: true });
      await cancelDeliveryAPI({ bookingid: 41, consignmentid: null }, 'duplicate');
      expect(endpoints.cancelBooking).toHaveBeenCalledWith(41, { reason: 'duplicate' });
      expect(endpoints.updateConsignmentStatus).not.toHaveBeenCalled();
    });

    it('should refuse a row carrying neither id rather than calling an endpoint with undefined', async () => {
      await expect(cancelDeliveryAPI({}, 'x')).rejects.toThrow(/nothing to cancel/i);
      expect(endpoints.cancelBooking).not.toHaveBeenCalled();
      expect(endpoints.updateConsignmentStatus).not.toHaveBeenCalled();
    });
  });

  describe('changeRiderAPI', () => {
    it("should send the miler's USERID under the mileruserid key", async () => {
      // assign-miler is the one admin route keyed on userid rather than
      // milerprofileid. The previous guess was wrong on both key and value.
      endpoints.assignMilerToBooking.mockResolvedValue({ success: true });
      await changeRiderAPI({ userid: 91, milerprofileid: 11 }, { orderheaderid: 4021 });
      expect(endpoints.assignMilerToBooking).toHaveBeenCalledWith(4021, { mileruserid: 91 });
    });

    it('should not send the milerprofileid, which this route does not accept', async () => {
      endpoints.assignMilerToBooking.mockResolvedValue({ success: true });
      await changeRiderAPI({ userid: 91, milerprofileid: 11 }, { orderheaderid: 4021 });
      const [, body] = endpoints.assignMilerToBooking.mock.calls[0];
      expect(body).not.toHaveProperty('milerid');
      expect(body).not.toHaveProperty('milerprofileid');
    });

    it('should fall back to deliveryid for the booking id', async () => {
      endpoints.assignMilerToBooking.mockResolvedValue({ success: true });
      await changeRiderAPI({ userid: 91 }, { deliveryid: 4022 });
      expect(endpoints.assignMilerToBooking).toHaveBeenCalledWith(4022, { mileruserid: 91 });
    });

    it('should surface a rejected assignment to the caller', async () => {
      endpoints.assignMilerToBooking.mockRejectedValue({ message: 'miler unavailable', httpStatus: 409 });
      await expect(changeRiderAPI({ userid: 91 }, { orderheaderid: 4021 })).rejects.toMatchObject({
        httpStatus: 409
      });
    });
  });

  describe('updateDeliveryAPI', () => {
    beforeEach(() => endpoints.updateConsignmentStatus.mockResolvedValue({ success: true }));

    it.each([
      ['started', 'Out_for_Delivery'],
      ['active', 'Out_for_Delivery'],
      ['delivered', 'Delivered'],
      ['cancelled', 'Cancelled'],
      ['canceled', 'Cancelled']
    ])('should translate the dialog choice %s to the consignment enum %s', async (chosen, sent) => {
      await updateDeliveryAPI({ consignmentid: 40, orderstatus: chosen });
      expect(endpoints.updateConsignmentStatus).toHaveBeenCalledWith(40, { status: sent });
    });

    it('should be case-insensitive about the dialog choice', async () => {
      await updateDeliveryAPI({ consignmentid: 40, orderstatus: 'Delivered' });
      expect(endpoints.updateConsignmentStatus).toHaveBeenCalledWith(40, { status: 'Delivered' });
    });

    it('should target the CONSIGNMENT id, not the booking id', async () => {
      // deliveryid is always the bookingid, so `deliveryid ?? consignmentid`
      // never fell through — every submit hit the endpoint with the wrong id.
      await updateDeliveryAPI({ consignmentid: 40, deliveryid: 4021, orderstatus: 'delivered' });
      expect(endpoints.updateConsignmentStatus).toHaveBeenCalledWith(40, expect.anything());
    });

    it('should send only `status` — the other dialog fields have no field here', async () => {
      // Forwarding the whole dialog state produced 400 {"status is required"}.
      await updateDeliveryAPI({
        consignmentid: 40,
        orderstatus: 'delivered',
        deliveryamt: 240,
        cumulativekms: 12,
        userid: 91,
        notes: 'left with security'
      });
      const [, body] = endpoints.updateConsignmentStatus.mock.calls[0];
      expect(body).toEqual({ status: 'Delivered' });
    });

    it('should refuse with a prompt when no status was chosen', async () => {
      await expect(updateDeliveryAPI({ consignmentid: 40, orderstatus: '' })).resolves.toEqual({
        success: false,
        message: 'Choose a status first.'
      });
      expect(endpoints.updateConsignmentStatus).not.toHaveBeenCalled();
    });

    it.each([
      ['picked', 'already a consignment'],
      ['pending', 'only exists after pickup'],
      ['accepted', 'only exists after pickup'],
      ['arrived', 'nothing to set'],
      ['skipped', 'attempt count']
    ])('should refuse %s with a specific reason rather than guessing a status', async (chosen, fragment) => {
      const result = await updateDeliveryAPI({ consignmentid: 40, orderstatus: chosen });
      expect(result.success).toBe(false);
      expect(result.message).toContain(fragment);
      expect(endpoints.updateConsignmentStatus).not.toHaveBeenCalled();
    });

    it('should refuse an unrecognised status naming the value that was rejected', async () => {
      const result = await updateDeliveryAPI({ consignmentid: 40, orderstatus: 'teleported' });
      expect(result.success).toBe(false);
      expect(result.message).toContain('teleported');
      expect(endpoints.updateConsignmentStatus).not.toHaveBeenCalled();
    });

    it('should never write a pre-pickup booking state to the consignment endpoint', async () => {
      await Promise.all(
        ['picked', 'pending', 'accepted', 'arrived', 'skipped'].map((orderstatus) =>
          updateDeliveryAPI({ consignmentid: 40, orderstatus })
        )
      );
      expect(endpoints.updateConsignmentStatus).not.toHaveBeenCalled();
    });

    it('should surface a rejected status write to the caller', async () => {
      endpoints.updateConsignmentStatus.mockRejectedValue({ message: 'status is required', httpStatus: 400 });
      await expect(updateDeliveryAPI({ consignmentid: 40, orderstatus: 'delivered' })).rejects.toMatchObject({
        httpStatus: 400
      });
    });
  });

  describe('getorderdetails', () => {
    it('should read a single booking by id', async () => {
      endpoints.getBooking.mockResolvedValue({ bookingid: 4021 });
      await expect(getorderdetails(4021)).resolves.toEqual({ bookingid: 4021 });
      expect(endpoints.getBooking).toHaveBeenCalledWith(4021);
    });
  });
});