// modules/inventory/domains/entities/inventory-item.entity.ts

export class InventoryItem extends BaseEntity {
	private constructor(
		id: string,
		private readonly _sku: string,
		private readonly _priceCurrency: string,
		private readonly _priceAmountMinor: number,
		private _availableQuantity: number,
		private _reservedQuantity: number,
	) {
		super(id);
	}

	reserve(quantity: number): void {
		const normalized = Number(quantity ?? 0);
		if (!Number.isFinite(normalized) || normalized <= 0) {
			throw DomainErrorFactory.create(
				INVENTORY_DOMAIN_ERRORS.INVENTORY_QUANTITY_INVALID,
				{ details: { quantity } },
			);
		}
		if (this._availableQuantity < normalized) {
			throw DomainErrorFactory.create(
				INVENTORY_DOMAIN_ERRORS.INVENTORY_STOCK_INSUFFICIENT,
				{
					message: `insufficient stock: sku=${this._sku} available=${this._availableQuantity} need=${normalized}`,
					details: {
						sku: this._sku,
						availableQuantity: this._availableQuantity,
						requestedQuantity: normalized,
					},
				},
			);
		}

		this._availableQuantity -= normalized;
		this._reservedQuantity += normalized;
	}
}

// lib/database/unit-of-work.ts
@Injectable()
export class UnitOfWork {
	constructor(private readonly rootEm: EntityManager) {}

	async transaction<T>(
		work: (em: EntityManager) => Promise<T>,
		options: { requiresNew?: boolean } = {},
	): Promise<T> {
		const existing = unitOfWorkStorage.getStore();
		if (existing && !options.requiresNew) {
			existing.depth += 1;
			try {
				return await work(existing.em);
			} finally {
				existing.depth -= 1;
			}
		}

		return await this.rootEm.transactional(async (tx) => {
			return await RequestContext.create(tx, async () => {
				return await unitOfWorkStorage.run(
					{ em: tx, depth: 1 },
					async () => {
						const result = await work(tx);
						await tx.flush();
						return result;
					},
				);
			});
		});
	}
}

// modules/ordering/application/commands/create-order.command.ts
export class CreateOrderCommand extends Command<{ orderId: string }> {
	public readonly userId: string;
	public readonly amount: number;
	public readonly currency: string;
	public readonly items?: Array<{ sku: string; quantity: number }>;

	constructor(input: {
		userId: string;
		amount: number;
		currency: string;
		items?: Array<{ sku: string; quantity: number }>;
	}) {
		super();
		this.userId = input.userId;
		this.amount = input.amount;
		this.currency = input.currency;
		this.items = input.items;
	}
}

// modules/ordering/application/commands/handlers/create-order.handler.ts
@CommandHandler(CreateOrderCommand)
export class CreateOrderHandler implements ICommandHandler<CreateOrderCommand> {
	constructor(
		@Inject(IOrderRepositorySymbol)
		private readonly orderRepository: IOrderRepository,
		private readonly uow: UnitOfWork,
	) {}

	async execute(command: CreateOrderCommand): Promise<{ orderId: string }> {
		return this.uow.transaction(async () => {
			const { userId, amount, currency } = command;
			const total = Money.of(amount, currency);
			const items =
				command.items?.map((item) =>
					OrderItem.of(item.sku, item.quantity),
				) ?? [];
			const order = Order.create({ userId, total, items });

			await this.orderRepository.persist(order);

			return { orderId: order.id };
		});
	}
}

// modules/inventory/application/commands/handlers/reserve-inventory-for-order.handler.ts
@CommandHandler(ReserveInventoryForOrderCommand)
export class ReserveInventoryForOrderHandler implements ICommandHandler<ReserveInventoryForOrderCommand> {
	constructor(
		@Inject(InventoryReservationService)
		private readonly InventoryReservationService: InventoryReservationService,
		private readonly uow: UnitOfWork,
	) {}

	@LogAsyncExecution<[ReserveInventoryForOrderCommand], void>({
		completed: {
			step: "reserve_inventory_for_order_completed",
			durationFieldName: "handlerTotalMs",
			getPayload: ([command]) => ({
				orderId: command.orderId,
				itemCount: command.items.length,
			}),
		},
	})
	async execute(command: ReserveInventoryForOrderCommand): Promise<void> {
		await this.uow.transaction(async () => {
			await this.InventoryReservationService.reserve(command);
		});
	}
}

// common/logging/log-async-execution.decorator.ts
@LogAsyncExecution<[ReserveInventoryForOrderCommand], void>({
	completed: {
		step: "reserve_inventory_for_order_completed",
		durationFieldName: "handlerTotalMs",
		getPayload: ([command]) => ({
			orderId: command.orderId,
			itemCount: command.items.length,
		}),
	},
})

// modules/outbox/application/commands/handlers/dispatch-outbox-event.handler.ts
writeStructuredLog(DispatchOutboxEventHandler.name, {
	step: "outbox_event_enqueued",
	outboxId,
	messageGroupId,
	enqueueMs,
	markPublishedMs,
	totalMs: Date.now() - startedAt,
});

writeStructuredLog(
	DispatchOutboxEventHandler.name,
	{
		step: "outbox_enqueue_failed",
		outboxId,
		messageGroupId,
		error: message,
		markFailureMs,
		totalMs: Date.now() - startedAt,
	},
	"error",
);

// shared/outbox/domain/entities/outbox-event.entity.ts
recordFailure(error: string, nextAttemptAt: Date): void {
	this._status = OutboxEventStatus.FAILED;
	this._attempt += 1;
	this._lastError = error;
	this._nextAttemptAt = nextAttemptAt;
	this._lockedUntil = null;
}