import { createFlowEngine } from '@classytic/flow';
import mongoose from 'mongoose';

// 1. Create the engine
const flow = createFlowEngine({
  mongoose: mongoose.connection,
  mode: 'standard',
  catalog: {
    resolveSku: async (skuRef) => productService.findBySku(skuRef),
  },
});

// 2. Access models
const { InventoryNode, Location, StockMoveGroup, StockMove, StockQuant, Reservation } = flow.models;

// 3. Context carries tenant + actor — never mixed into domain inputs
const ctx = { organizationId: 'org_1', actorId: 'user_1' };

// 4. Use services (pure async functions — no HTTP, no framework)
const availability = await flow.services.quant.getAvailability({
  skuRef: 'SKU-RED-M',
  nodeId: 'warehouse_1',
}, ctx);

// 5. Create and execute a transfer
const group = await flow.services.moveGroup.create({
  groupType: 'transfer',
  sourceNodeId: 'warehouse_1',
  destinationNodeId: 'store_1',
  items: [{
    moveGroupId: '',            // auto-assigned
    operationType: 'transfer',
    skuRef: 'SKU-RED-M',
    sourceLocationId: 'loc_storage_wh1',
    destinationLocationId: 'loc_storage_store1',
    quantityPlanned: 50,
  }],
}, ctx);

await flow.services.moveGroup.executeAction(group._id, 'confirm', {}, ctx);
await flow.services.moveGroup.executeAction(group._id, 'dispatch', {}, ctx);
await flow.services.moveGroup.executeAction(group._id, 'receive', {}, ctx);

// 6. Subscribe to events (bridge to your ledger, notifications, etc.)
flow.events.on('inventory.move.done', async (payload) => {
  // payload: { organizationId, moveId, skuRef, quantityDone, ... }
  await ledger.postInventoryMovement(payload);
});

// 7. Query active config at runtime
flow.services.mode;      // 'standard'
flow.services.routing;   // { putaway: false, removal: false, crossDock: false }
flow.services.valuation; // { method: 'wac' }

const ctx = { organizationId: 'org_1', actorId: 'user_1' };

// Check availability
const stock = await flow.services.quant.getAvailability({ skuRef: 'SKU-RED-M' }, ctx);
// → { quantityOnHand: 50, quantityReserved: 5, quantityAvailable: 45, quantityIncoming: 20, quantityOutgoing: 0 }

// Reserve stock for an order
await flow.services.reservation.reserve({
  reservationType: 'hard',
  skuRef: 'SKU-RED-M',
  locationId: 'loc_default',
  quantity: 3,
  ownerType: 'order',
  ownerId: 'order_123',
}, ctx);

const flow = createFlowEngine({
  // Required
  mongoose: connection,

  // Required — how Flow resolves product details
  catalog: {
    resolveSku: async (skuRef) => ({ sku: skuRef, displayName: '...', trackingMode: 'none', uom: 'unit' }),
  },

  // Optional — deployment mode (default: 'standard')
  mode: 'standard',

  // Optional — multi-tenant (omit for single-tenant)
  multiTenant: { orgField: 'organizationId' },

  // Optional — valuation method (default: 'wac')
  valuation: { method: 'wac' },

  // Optional — allocation policy (default: 'fifo') — resolves to built-in FifoStrategy/FefoStrategy/LifoStrategy
  allocation: { defaultPolicy: 'fifo' },

  // Optional — routing (enterprise mode)
  routing: { putaway: true, removal: true, crossDock: false },

  // Optional — custom allocation policy (overrides allocation.defaultPolicy)
  policies: { allocation: myCustomPolicy },

  // Optional — custom event emitter (default: in-process)
  events: { adapter: myRedisEventBus },

  // Optional — idempotency store
  idempotency: myRedisIdempotency,

  // Optional — MongoKit plugins per repository
  plugins: {
    quant: [cachePlugin({ adapter: redis, ttl: 30 })],
    move: [auditTrailPlugin()],
  },
});

const flow = createFlowEngine(config);

flow.models         // All Mongoose models
flow.repositories   // All MongoKit repositories
flow.services       // All domain services + active config (mode, routing, valuation)
flow.events         // In-process event emitter
flow.registerPolicy // Register custom allocation policies at runtime