// shared/money/value-objects/money.vo.ts

export class Money {
	private constructor(
		private readonly _amount: number,
		private readonly _currency: string,
	) {}

	static of(amount: number, currency: string): Money {
		const normalizedCurrency = String(currency ?? "").toUpperCase();
		const normalizedAmount = Number(amount);

		if (!Number.isFinite(normalizedAmount) || normalizedAmount <= 0) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.MONEY_AMOUNT_INVALID,
				{
					details: { amount },
				},
			);
		}
		if (!normalizedCurrency) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.MONEY_CURRENCY_REQUIRED,
			);
		}

		return new Money(normalizedAmount, normalizedCurrency);
	}
}

// modules/ordering/domains/entities/aggregates/order/order.aggregate.ts

export class Order extends BaseEntity {
	private constructor(
		id: string,
		private readonly _userId: string,
		private _status: OrderStatus,
		private readonly _total: Money,
		private readonly _items: OrderItem[],
		private _paymentId: string | null,
		private readonly _orderedAt: Date,
		private _paidAt: Date | null,
	) {
		super(id);
	}

	attachPayment(paymentId: string): void {
		const normalized = String(paymentId ?? "").trim();
		if (!normalized) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.ORDER_PAYMENT_ID_REQUIRED,
			);
		}
		if (this._status !== OrderStatus.PENDING_PAYMENT) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.ORDER_PAYMENT_ATTACH_INVALID_STATUS,
				{
					message: `cannot attach payment when order is ${this._status}`,
					details: { status: this._status },
				},
			);
		}
		if (this._paymentId && this._paymentId !== normalized) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.ORDER_PAYMENT_ALREADY_ATTACHED,
			);
		}

		this._paymentId = normalized;
	}

	markPaid(): void {
		if (this._status === OrderStatus.PAID) {
			return;
		}
		if (this._status !== OrderStatus.PENDING_PAYMENT) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.ORDER_MARK_PAID_INVALID_STATUS,
				{
					message: `cannot mark paid when order is ${this._status}`,
					details: { status: this._status },
				},
			);
		}
		if (!this._paymentId) {
			throw DomainErrorFactory.create(
				ORDERING_DOMAIN_ERRORS.ORDER_PAYMENT_NOT_ATTACHED,
			);
		}
		this._status = OrderStatus.PAID;
		this._paidAt = new Date();
	}
}

// shared/errors/catalogs/ordering.errors.ts
export const ORDERING_DOMAIN_ERRORS = {
	ORDER_USER_ID_REQUIRED: {
		code: "ORDER_USER_ID_REQUIRED",
		message: "userId is required",
		status: 400,
	},
	ORDER_ITEMS_REQUIRED: {
		code: "ORDER_ITEMS_REQUIRED",
		message: "order must contain at least one item",
		status: 400,
	},
	ORDER_PAYMENT_ID_REQUIRED: {
		code: "ORDER_PAYMENT_ID_REQUIRED",
		message: "paymentId is required",
		status: 400,
	},
	ORDER_PAYMENT_ATTACH_INVALID_STATUS: {
		code: "ORDER_PAYMENT_ATTACH_INVALID_STATUS",
		message: "cannot attach payment in current status",
		status: 409,
	},
	ORDER_MARK_PAID_INVALID_STATUS: {
		code: "ORDER_MARK_PAID_INVALID_STATUS",
		message: "cannot mark paid in current status",
		status: 409,
	},
	MONEY_AMOUNT_INVALID: {
		code: "MONEY_AMOUNT_INVALID",
		message: "amount must be a positive number",
		status: 400,
	},
	MONEY_CURRENCY_REQUIRED: {
		code: "MONEY_CURRENCY_REQUIRED",
		message: "currency is required",
		status: 400,
	},
} as const satisfies Record<string, ErrorTemplate>;

// modules/ordering/domains/entities/aggregates/order/order.aggregate.ts
throw DomainErrorFactory.create(
	ORDERING_DOMAIN_ERRORS.ORDER_PAYMENT_ATTACH_INVALID_STATUS,
	{
		message: `cannot attach payment when order is ${this._status}`,
		details: { status: this._status },
	},
);

// common/filters/global-http-exception.filter.ts
@Catch()
export class GlobalHttpExceptionFilter implements ExceptionFilter {
	catch(exception: unknown, host: ArgumentsHost): void {
		const http = host.switchToHttp();
		const req = http.getRequest<Request>();
		const res = http.getResponse<Response>();

		const mapped = this.mapException(exception);
		const body: ErrorResponse = {
			type: `about:blank#${mapped.code}`,
			title: this.getTitle(mapped.status),
			status: mapped.status,
			detail: mapped.detail,
			instance: req.originalUrl || req.url,
			code: mapped.code,
			timestamp: new Date().toISOString(),
		};

		res.status(mapped.status).json(ResponseHelper.error(body));
	}
}

// modules/ordering/domains/repositories/i.order.repository.ts
import { Order } from "@/modules/ordering/domains/entities/aggregates/order/order.aggregate";
import type {
	RepositoryGetByIdOptions,
	RepositoryPageOptions,
} from "@/lib/database/repository-get-options";

export interface IOrderRepository {
	persist(order: Order): Promise<void>;
	findById(id: string): Promise<Order | null>;
	getById(id: string, options?: RepositoryGetByIdOptions): Promise<Order>;
	findRecent(options: RepositoryPageOptions<Order>): Promise<Order[]>;
	findByUserId(
		userId: string,
		options: RepositoryPageOptions<Order>,
	): Promise<Order[]>;
	countAll(): Promise<number>;
}

export const IOrderRepositorySymbol = Symbol("I_ORDER_REPOSITORY");

// contracts/payments/events/payment-fulfillment-requested.event.ts
export const PAYMENT_FULFILLMENT_REQUESTED_EVENT_TYPE =
	"PAYMENT_WEBHOOK.PAYMENT_FULFILLMENT_REQUESTED" as const;

import { PAYMENTS_APPLICATION_ERRORS } from "@/shared/errors";
import {
	requireTrimmedString,
	toTrimmedString,
} from "@/common/cqrs/input-normalizer";

export class PaymentFulfillmentRequestedEvent {
	static readonly eventType = PAYMENT_FULFILLMENT_REQUESTED_EVENT_TYPE;
	public readonly orderId: string;

	constructor(input: { orderId: string }) {
		this.orderId = requireTrimmedString(
			input.orderId,
			PAYMENTS_APPLICATION_ERRORS.PAYMENT_WEBHOOK_PAYLOAD_INVALID,
			{ reason: "orderId" },
		);
	}

	static fromRaw(
		payload: Record<string, unknown>,
	): PaymentFulfillmentRequestedEvent | null {
		const orderId = toTrimmedString(payload.orderId);
		if (!orderId) return null;
		return new PaymentFulfillmentRequestedEvent({ orderId });
	}
}