// src/orders/commands/impl/create-order.command.ts
export class CreateOrderCommand {
  constructor(
    public readonly userId: string,
    public readonly items: OrderItemDto[],
    public readonly shippingAddress: string
  ) {}
}

// src/orders/commands/impl/cancel-order.command.ts
export class CancelOrderCommand {
  constructor(
    public readonly orderId: string,
    public readonly reason: string
  ) {}
}

// src/orders/commands/handlers/create-order.handler.ts
import { CommandHandler, ICommandHandler, EventBus } from "@nestjs/cqrs";
import { CreateOrderCommand } from "../impl/create-order.command";
import { OrderCreatedEvent } from "../../events/impl/order-created.event";
import { OrderRepository } from "../../repositories/order.repository";
import { Order } from "../../entities/order.entity";

@CommandHandler(CreateOrderCommand)
export class CreateOrderHandler implements ICommandHandler<CreateOrderCommand> {
  constructor(
    private readonly orderRepository: OrderRepository,
    private readonly eventBus: EventBus
  ) {}

  async execute(command: CreateOrderCommand): Promise<string> {
    const { userId, items, shippingAddress } = command;

    // 1. 주문 생성
    const order = Order.create({
      userId,
      items,
      shippingAddress,
      status: "PENDING",
    });

    // 2. 저장
    await this.orderRepository.save(order);

    // 3. 이벤트 발행
    this.eventBus.publish(
      new OrderCreatedEvent(order.id, order.userId, order.totalAmount)
    );

    return order.id;
  }
}

// src/orders/commands/handlers/cancel-order.handler.ts
@CommandHandler(CancelOrderCommand)
export class CancelOrderHandler implements ICommandHandler<CancelOrderCommand> {
  constructor(
    private readonly orderRepository: OrderRepository,
    private readonly eventBus: EventBus
  ) {}

  async execute(command: CancelOrderCommand): Promise<void> {
    const { orderId, reason } = command;

    // 1. 주문 조회
    const order = await this.orderRepository.findById(orderId);
    if (!order) {
      throw new NotFoundException("주문을 찾을 수 없습니다");
    }

    // 2. 취소 가능 여부 확인
    if (order.status === "SHIPPED") {
      throw new BadRequestException("배송된 주문은 취소할 수 없습니다");
    }

    // 3. 주문 취소
    order.cancel(reason);
    await this.orderRepository.save(order);

    // 4. 이벤트 발행
    this.eventBus.publish(new OrderCancelledEvent(orderId, reason));
  }
}

// src/orders/queries/impl/get-order.query.ts
export class GetOrderQuery {
  constructor(public readonly orderId: string) {}
}

// src/orders/queries/impl/get-orders-by-user.query.ts
export class GetOrdersByUserQuery {
  constructor(
    public readonly userId: string,
    public readonly page: number = 1,
    public readonly limit: number = 10
  ) {}
}

// src/orders/queries/handlers/get-order.handler.ts
import { IQueryHandler, QueryHandler } from "@nestjs/cqrs";
import { GetOrderQuery } from "../impl/get-order.query";
import { OrderReadRepository } from "../../repositories/order-read.repository";

@QueryHandler(GetOrderQuery)
export class GetOrderHandler implements IQueryHandler<GetOrderQuery> {
  constructor(private readonly orderReadRepository: OrderReadRepository) {}

  async execute(query: GetOrderQuery): Promise<OrderDto> {
    const { orderId } = query;

    const order = await this.orderReadRepository.findById(orderId);
    if (!order) {
      throw new NotFoundException("주문을 찾을 수 없습니다");
    }

    return OrderDto.from(order);
  }
}

// src/orders/queries/handlers/get-orders-by-user.handler.ts
@QueryHandler(GetOrdersByUserQuery)
export class GetOrdersByUserHandler
  implements IQueryHandler<GetOrdersByUserQuery>
{
  constructor(private readonly orderReadRepository: OrderReadRepository) {}

  async execute(query: GetOrdersByUserQuery): Promise<PaginatedOrdersDto> {
    const { userId, page, limit } = query;

    const [orders, total] = await this.orderReadRepository.findByUserId(
      userId,
      page,
      limit
    );

    return {
      data: orders.map(OrderDto.from),
      total,
      page,
      limit,
      totalPages: Math.ceil(total / limit),
    };
  }
}

// src/orders/events/impl/order-created.event.ts
export class OrderCreatedEvent {
  constructor(
    public readonly orderId: string,
    public readonly userId: string,
    public readonly totalAmount: number
  ) {}
}

// src/orders/events/impl/order-cancelled.event.ts
export class OrderCancelledEvent {
  constructor(
    public readonly orderId: string,
    public readonly reason: string
  ) {}
}

// src/orders/events/handlers/order-created.handler.ts
import { EventsHandler, IEventHandler } from "@nestjs/cqrs";
import { OrderCreatedEvent } from "../impl/order-created.event";

@EventsHandler(OrderCreatedEvent)
export class OrderCreatedHandler implements IEventHandler<OrderCreatedEvent> {
  constructor(
    private readonly notificationService: NotificationService,
    private readonly analyticsService: AnalyticsService
  ) {}

  async handle(event: OrderCreatedEvent): Promise<void> {
    const { orderId, userId, totalAmount } = event;

    // 1. 알림 전송
    await this.notificationService.sendOrderConfirmation(userId, orderId);

    // 2. 분석 데이터 저장
    await this.analyticsService.trackOrder(orderId, totalAmount);

    console.log(`주문 생성됨: ${orderId}, 금액: ${totalAmount}`);
  }
}

// src/orders/events/handlers/order-cancelled.handler.ts
@EventsHandler(OrderCancelledEvent)
export class OrderCancelledHandler
  implements IEventHandler<OrderCancelledEvent>
{
  constructor(
    private readonly inventoryService: InventoryService,
    private readonly paymentService: PaymentService
  ) {}

  async handle(event: OrderCancelledEvent): Promise<void> {
    const { orderId, reason } = event;

    // 1. 재고 복구
    await this.inventoryService.restoreStock(orderId);

    // 2. 환불 처리
    await this.paymentService.refund(orderId);

    console.log(`주문 취소됨: ${orderId}, 사유: ${reason}`);
  }
}

// src/orders/orders.controller.ts
import { Controller, Post, Get, Body, Param, Query } from "@nestjs/common";
import { CommandBus, QueryBus } from "@nestjs/cqrs";
import { CreateOrderCommand } from "./commands/impl/create-order.command";
import { CancelOrderCommand } from "./commands/impl/cancel-order.command";
import { GetOrderQuery } from "./queries/impl/get-order.query";
import { GetOrdersByUserQuery } from "./queries/impl/get-orders-by-user.query";

@Controller("orders")
export class OrdersController {
  constructor(
    private readonly commandBus: CommandBus,
    private readonly queryBus: QueryBus
  ) {}

  // Command: 주문 생성
  @Post()
  async createOrder(@Body() dto: CreateOrderDto): Promise<{ orderId: string }> {
    const orderId = await this.commandBus.execute(
      new CreateOrderCommand(dto.userId, dto.items, dto.shippingAddress)
    );
    return { orderId };
  }

  // Command: 주문 취소
  @Post(":id/cancel")
  async cancelOrder(
    @Param("id") orderId: string,
    @Body() dto: CancelOrderDto
  ): Promise<void> {
    await this.commandBus.execute(new CancelOrderCommand(orderId, dto.reason));
  }

  // Query: 주문 조회
  @Get(":id")
  async getOrder(@Param("id") orderId: string): Promise<OrderDto> {
    return this.queryBus.execute(new GetOrderQuery(orderId));
  }

  // Query: 사용자 주문 목록
  @Get("user/:userId")
  async getOrdersByUser(
    @Param("userId") userId: string,
    @Query("page") page: number = 1,
    @Query("limit") limit: number = 10
  ): Promise<PaginatedOrdersDto> {
    return this.queryBus.execute(new GetOrdersByUserQuery(userId, page, limit));
  }
}

// src/orders/orders.module.ts
import { Module } from "@nestjs/common";
import { CqrsModule } from "@nestjs/cqrs";
import { TypeOrmModule } from "@nestjs/typeorm";
import { OrdersController } from "./orders.controller";
import { Order } from "./entities/order.entity";

// Command Handlers
import { CreateOrderHandler } from "./commands/handlers/create-order.handler";
import { CancelOrderHandler } from "./commands/handlers/cancel-order.handler";

// Query Handlers
import { GetOrderHandler } from "./queries/handlers/get-order.handler";
import { GetOrdersByUserHandler } from "./queries/handlers/get-orders-by-user.handler";

// Event Handlers
import { OrderCreatedHandler } from "./events/handlers/order-created.handler";
import { OrderCancelledHandler } from "./events/handlers/order-cancelled.handler";

// Repositories
import { OrderRepository } from "./repositories/order.repository";
import { OrderReadRepository } from "./repositories/order-read.repository";

const CommandHandlers = [CreateOrderHandler, CancelOrderHandler];
const QueryHandlers = [GetOrderHandler, GetOrdersByUserHandler];
const EventHandlers = [OrderCreatedHandler, OrderCancelledHandler];

@Module({
  imports: [CqrsModule, TypeOrmModule.forFeature([Order])],
  controllers: [OrdersController],
  providers: [
    ...CommandHandlers,
    ...QueryHandlers,
    ...EventHandlers,
    OrderRepository,
    OrderReadRepository,
  ],
})
export class OrdersModule {}

// src/orders/entities/order.entity.ts
import { AggregateRoot } from "@nestjs/cqrs";

@Entity()
export class Order extends AggregateRoot {
  @PrimaryGeneratedColumn("uuid")
  id: string;

  @Column()
  userId: string;

  @Column("jsonb")
  items: OrderItem[];

  @Column()
  shippingAddress: string;

  @Column()
  status: OrderStatus;

  @Column("decimal")
  totalAmount: number;

  @CreateDateColumn()
  createdAt: Date;

  static create(props: CreateOrderProps): Order {
    const order = new Order();
    order.userId = props.userId;
    order.items = props.items;
    order.shippingAddress = props.shippingAddress;
    order.status = "PENDING";
    order.totalAmount = props.items.reduce(
      (sum, item) => sum + item.price * item.quantity,
      0
    );
    return order;
  }

  cancel(reason: string): void {
    if (this.status === "SHIPPED") {
      throw new Error("배송된 주문은 취소 불가");
    }
    this.status = "CANCELLED";
  }
}

// src/orders/repositories/order.repository.ts
@Injectable()
export class OrderRepository {
  constructor(
    @InjectRepository(Order)
    private readonly repository: Repository<Order>
  ) {}

  async save(order: Order): Promise<Order> {
    return this.repository.save(order);
  }

  async findById(id: string): Promise<Order | null> {
    return this.repository.findOne({ where: { id } });
  }
}

// src/orders/repositories/order-read.repository.ts
// 읽기 전용 - 최적화된 쿼리
@Injectable()
export class OrderReadRepository {
  constructor(
    @InjectRepository(Order)
    private readonly repository: Repository<Order>
  ) {}

  async findById(id: string): Promise<Order | null> {
    return this.repository
      .createQueryBuilder("order")
      .select(["order.id", "order.status", "order.totalAmount"])
      .where("order.id = :id", { id })
      .getOne();
  }

  async findByUserId(
    userId: string,
    page: number,
    limit: number
  ): Promise<[Order[], number]> {
    return this.repository.findAndCount({
      where: { userId },
      skip: (page - 1) * limit,
      take: limit,
      order: { createdAt: "DESC" },
    });
  }
}

// src/orders/events/order-event-store.ts
@Injectable()
export class OrderEventStore {
  constructor(
    @InjectRepository(OrderEvent)
    private readonly repository: Repository<OrderEvent>
  ) {}

  async save(event: DomainEvent): Promise<void> {
    const orderEvent = new OrderEvent();
    orderEvent.aggregateId = event.aggregateId;
    orderEvent.eventType = event.constructor.name;
    orderEvent.payload = JSON.stringify(event);
    orderEvent.occurredAt = new Date();

    await this.repository.save(orderEvent);
  }

  async getEvents(aggregateId: string): Promise<DomainEvent[]> {
    const events = await this.repository.find({
      where: { aggregateId },
      order: { occurredAt: "ASC" },
    });

    return events.map((e) => JSON.parse(e.payload));
  }

  // 이벤트로부터 상태 복원
  async rehydrate(aggregateId: string): Promise<Order> {
    const events = await this.getEvents(aggregateId);
    const order = new Order();

    events.forEach((event) => {
      order.apply(event);
    });

    return order;
  }
}