// prisma/schema.prisma

model Order {
  id              String      @id
  customerId      String      @map("customer_id")
  status          String
  shippingStreet  String?     @map("shipping_street")
  shippingCity    String?     @map("shipping_city")
  shippingState   String?     @map("shipping_state")
  shippingPostal  String?     @map("shipping_postal")
  shippingCountry String?     @map("shipping_country")
  discountCents   Int         @default(0) @map("discount_cents")
  discountCurrency String?    @map("discount_currency")
  placedAt        DateTime?   @map("placed_at")
  shippedAt       DateTime?   @map("shipped_at")
  cancelledAt     DateTime?   @map("cancelled_at")
  version         Int         @default(0)
  createdAt       DateTime    @default(now()) @map("created_at")
  updatedAt       DateTime    @updatedAt @map("updated_at")
  items           OrderItem[]

  @@index([customerId])
  @@index([status])
  @@map("orders")
}

model OrderItem {
  id              String  @id
  orderId         String  @map("order_id")
  productId       String  @map("product_id")
  quantity        Int
  unitPriceCents  Int     @map("unit_price_cents")
  currency        String
  order           Order   @relation(fields: [orderId], references: [id], onDelete: Cascade)

  @@index([orderId])
  @@map("order_items")
}

// src/infrastructure/persistence/PrismaOrderRepository.ts
import { injectable, inject } from 'inversify';
import { PrismaClient, Order as PrismaOrder, OrderItem as PrismaOrderItem } from '@prisma/client';
import { IOrderRepository } from '../../domain/order/ports/IOrderRepository';
import { Order, OrderSnapshot } from '../../domain/order/Order';
import { OrderId, generateOrderId } from '../../domain/order/OrderId';
import { CustomerId } from '../../domain/customer/CustomerId';
import { OrderStatus } from '../../domain/order/OrderStatus';
import { LineItem } from '../../domain/order/LineItem';
import { Money } from '../../domain/payment/Money';
import { Address } from '../../domain/customer/Address';
import { DomainError } from '../../domain/shared/DomainError';
import { TYPES } from '../container/TYPES';

type PrismaOrderWithItems = PrismaOrder & { items: PrismaOrderItem[] };

@injectable()
export class PrismaOrderRepository implements IOrderRepository {
  constructor(
    @inject(TYPES.PrismaClient) private readonly prisma: PrismaClient
  ) {}

  async findById(id: OrderId): Promise<Order | null> {
    const raw = await this.prisma.order.findUnique({
      where: { id },
      include: { items: true },
    });
    return raw ? this.toDomain(raw) : null;
  }

  async findByCustomerId(customerId: CustomerId): Promise<Order[]> {
    const rows = await this.prisma.order.findMany({
      where: { customerId },
      include: { items: true },
      orderBy: { createdAt: 'desc' },
    });
    return rows.map(row => this.toDomain(row));
  }

  async save(order: Order): Promise<void> {
    const events = order.pullDomainEvents();

    await this.prisma.$transaction(async (tx) => {
      // ── 1. Optimistic concurrency check ──
      // Only applies to existing orders — new orders have version 0
      if (order.version > 0) {
        const current = await tx.order.findUnique({
          where: { id: order.id },
          select: { version: true },
        });

        if (!current) {
          throw new DomainError(`Order ${order.id} not found during save — possible concurrent deletion`);
        }

        if (current.version !== order.version) {
          throw new OptimisticConcurrencyError(
            `Order ${order.id} was modified by another process (expected version ${order.version}, found ${current.version})`
          );
        }
      }

      // ── 2. Upsert the Order root ──
      const shippingAddr = order.shippingAddress;
      await tx.order.upsert({
        where: { id: order.id },
        create: {
          id:              order.id,
          customerId:      order.customerId,
          status:          order.status,
          shippingStreet:  shippingAddr?.street ?? null,
          shippingCity:    shippingAddr?.city ?? null,
          shippingState:   shippingAddr?.state ?? null,
          shippingPostal:  shippingAddr?.postalCode ?? null,
          shippingCountry: shippingAddr?.countryCode ?? null,
          discountCents:   order.appliedDiscount?.amountCents ?? 0,
          discountCurrency: order.appliedDiscount?.currency ?? null,
          placedAt:        order.placedAt ?? null,
          version:         0,
        },
        update: {
          status:          order.status,
          shippingStreet:  shippingAddr?.street ?? null,
          shippingCity:    shippingAddr?.city ?? null,
          shippingState:   shippingAddr?.state ?? null,
          shippingPostal:  shippingAddr?.postalCode ?? null,
          shippingCountry: shippingAddr?.countryCode ?? null,
          discountCents:   order.appliedDiscount?.amountCents ?? 0,
          placedAt:        order.placedAt ?? null,
          shippedAt:       order.shippedAt ?? null,
          cancelledAt:     order.cancelledAt ?? null,
          version:         { increment: 1 }, // Increment version on every successful write
        },
      });

      // ── 3. Synchronize LineItems: delete-then-recreate ──
      // Full replacement is simpler and safer than diffing for small item collections
      await tx.orderItem.deleteMany({ where: { orderId: order.id } });

      if (order.items.length > 0) {
        await tx.orderItem.createMany({
          data: order.items.map(item => ({
            id:             item.id,
            orderId:        order.id,
            productId:      item.productId,
            quantity:       item.quantity,
            unitPriceCents: item.unitPrice.amountCents,
            currency:       item.unitPrice.currency,
          })),
        });
      }

      // ── 4. Write events to Outbox (same transaction — atomic) ──
      if (events.length > 0) {
        await tx.outboxEvent.createMany({
          data: events.map(event => ({
            id:          event.eventId,
            eventType:   event.eventType,
            aggregateId: event.aggregateId,
            payload:     JSON.stringify(event),
            occurredAt:  event.occurredAt,
            publishedAt: null,
          })),
        });
      }
    });
  }

  nextId(): OrderId {
    return generateOrderId();
  }
}

// Private method — only accessible within PrismaOrderRepository
private toDomain(raw: PrismaOrderWithItems): Order {
  // ── Translate each LineItem row → LineItem Entity ──
  const items: LineItem[] = raw.items.map(item =>
    LineItem.reconstitute({
      id:        item.id as LineItemId,
      productId: item.productId as ProductId,
      quantity:  item.quantity,
      unitPrice: Money.fromCents(
        item.currency as Currency,
        item.unitPriceCents,
      ),
    })
  );

  // ── Translate shipping address columns → Address Value Object ──
  const shippingAddress = raw.shippingStreet
    ? Address.reconstitute({
        street:      raw.shippingStreet,
        city:        raw.shippingCity!,
        state:       raw.shippingState!,
        postalCode:  raw.shippingPostal!,
        countryCode: raw.shippingCountry!,
      })
    : null;

  // ── Translate discount columns → Money Value Object (or null) ──
  const appliedDiscount = raw.discountCents > 0 && raw.discountCurrency
    ? Money.fromCents(raw.discountCurrency as Currency, raw.discountCents)
    : null;

  // ── Validate status is a known OrderStatus ──
  if (!Object.values(OrderStatus).includes(raw.status as OrderStatus)) {
    throw new DomainError(`Invalid OrderStatus loaded from database: '${raw.status}' for Order ${raw.id}`);
  }

  // ── Reconstitute the Aggregate from the snapshot ──
  const snapshot: OrderSnapshot = {
    id:              raw.id as OrderId,
    customerId:      raw.customerId as CustomerId,
    status:          raw.status as OrderStatus,
    items,
    shippingAddress,
    appliedDiscount,
    placedAt:        raw.placedAt ?? undefined,
    shippedAt:       raw.shippedAt ?? undefined,
    cancelledAt:     raw.cancelledAt ?? undefined,
    version:         raw.version,
  };

  return Order.reconstitute(snapshot);
}

// src/application/order/PlaceOrderUseCase.ts — retry on optimistic conflict
async execute(command: PlaceOrderCommand): Promise<OrderId> {
  const MAX_RETRIES = 3;
  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
    try {
      return await this.attemptExecution(command);
    } catch (err) {
      if (err instanceof OptimisticConcurrencyError && attempt < MAX_RETRIES - 1) {
        // Reload and retry — the Aggregate will have the new version on next load
        continue;
      }
      throw err;
    }
  }
  throw new DomainError('Order was modified concurrently — please retry');
}

// src/domain/payment/Money.ts (addition)
static fromCents(currency: Currency, amountCents: number): Money {
  if (!SupportedCurrencies.includes(currency))
    throw new DomainError(`Unsupported currency loaded from database: ${currency}`);
  if (!Number.isInteger(amountCents) || amountCents < 0)
    throw new DomainError(`Invalid cent value loaded from database: ${amountCents}`);
  return new Money({ amountCents, currency });
}

// tests/integration/PrismaOrderRepository.integration.test.ts
import { PrismaClient } from '@prisma/client';
import { PrismaOrderRepository } from '../../../src/infrastructure/persistence/PrismaOrderRepository';
import { orderRepositoryContract } from '../../shared/OrderRepositoryContract';
import { OptimisticConcurrencyError } from '../../../src/domain/shared/OptimisticConcurrencyError';

const prisma = new PrismaClient();
let repo: PrismaOrderRepository;

// Run the full shared contract suite
orderRepositoryContract(
  () => repo,
  async () => {
    repo = new PrismaOrderRepository(prisma);
    await prisma.$transaction([
      prisma.outboxEvent.deleteMany(),
      prisma.orderItem.deleteMany(),
      prisma.order.deleteMany(),
    ]);
  },
);

// Additional Prisma-specific tests (not part of the interface contract)
describe('PrismaOrderRepository — concurrency', () => {
  it('should throw OptimisticConcurrencyError when version conflicts', async () => {
    const order = Order.create('cust_001' as CustomerId);
    await repo.save(order); // version becomes 1 in DB

    // Load the same order twice — both have version=1
    const [copy1, copy2] = await Promise.all([
      repo.findById(order.id),
      repo.findById(order.id),
    ]);

    // First save succeeds — version becomes 2
    copy1!.addItem('prod_A' as ProductId, 1, Money.of('USD', 10));
    await repo.save(copy1!);

    // Second save fails — DB version is now 2, copy2 still has version=1
    copy2!.setShippingAddress(testAddress());
    await expect(repo.save(copy2!)).rejects.toThrow(OptimisticConcurrencyError);
  });
});

afterAll(() => prisma.$disconnect());