import { jest } from '@jest/globals';

jest.unstable_mockModule('../../../database/database.js', () => ({
  listObjects: jest.fn(),
  getObject: jest.fn(),
  editObject: jest.fn(),
  editObjects: jest.fn(),
  newObject: jest.fn(),
  deleteObject: jest.fn(),
  listObjectsByProperties: jest.fn(),
  getModelStats: jest.fn(),
  getModelHistory: jest.fn(),
  checkStates: jest.fn(),
}));

jest.unstable_mockModule('../../../database/schemas/inventory/shipment.schema.js', () => ({
  shipmentModel: { modelName: 'Shipment' },
}));

jest.unstable_mockModule('../../../database/schemas/inventory/orderitem.schema.js', () => ({
  orderItemModel: { modelName: 'OrderItem' },
}));

jest.unstable_mockModule('log4js', () => ({
  default: {
    getLogger: () => ({
      level: 'info',
      debug: jest.fn(),
      error: jest.fn(),
      warn: jest.fn(),
      trace: jest.fn(),
    }),
  },
}));

const {
  listShipmentsRouteHandler,
  getShipmentRouteHandler,
  newShipmentRouteHandler,
  shipShipmentRouteHandler,
} = await import('../shipments.js');

const { listObjects, getObject, editObject, newObject, checkStates } = await import(
  '../../../database/database.js'
);
const { shipmentModel } = await import('../../../database/schemas/inventory/shipment.schema.js');
const { orderItemModel } = await import('../../../database/schemas/inventory/orderitem.schema.js');

describe('Shipment Service Route Handlers', () => {
  let req, res;

  beforeEach(() => {
    req = {
      params: {},
      query: {},
      body: {},
      user: { id: 'test-user-id' },
    };
    res = {
      send: jest.fn(),
      status: jest.fn().mockReturnThis(),
    };
    jest.clearAllMocks();
  });

  describe('listShipmentsRouteHandler', () => {
    it('should list shipments', async () => {
      const mockResult = [{ _id: '1', trackingNumber: 'TRACK123' }];
      listObjects.mockResolvedValue(mockResult);

      await listShipmentsRouteHandler(req, res);

      expect(listObjects).toHaveBeenCalledWith(expect.objectContaining({ model: shipmentModel }));
      expect(res.send).toHaveBeenCalledWith(mockResult);
    });
  });

  describe('newShipmentRouteHandler', () => {
    it('should create a new shipment', async () => {
      req.body = { order: 'order123', trackingNumber: 'TRACK456' };
      const mockShipment = { _id: '456', ...req.body, state: { type: 'draft' } };
      newObject.mockResolvedValue(mockShipment);

      await newShipmentRouteHandler(req, res);

      expect(newObject).toHaveBeenCalled();
      expect(res.send).toHaveBeenCalledWith(mockShipment);
    });
  });

  describe('shipShipmentRouteHandler', () => {
    it('should ship a planned shipment and update order items', async () => {
      req.params.id = '507f1f77bcf86cd799439011';
      checkStates.mockResolvedValue(true);

      listObjects.mockResolvedValue([
        { _id: 'oi1', state: { type: 'ordered' } },
        { _id: 'oi2', state: { type: 'ordered' } },
      ]);

      editObject.mockResolvedValue({ _id: '507f1f77bcf86cd799439011', state: { type: 'shipped' } });

      await shipShipmentRouteHandler(req, res);

      expect(checkStates).toHaveBeenCalledWith(expect.objectContaining({ states: ['planned'] }));
      expect(editObject).toHaveBeenCalledTimes(3); // 2 order items + 1 shipment
      expect(res.send).toHaveBeenCalled();
    });
  });
});