// internal/order/domain/money.go
package domain

import (
	"errors"
	"fmt"
)

// Money 金额值对象
// 使用不可变设计，所有运算都返回新对象
type Money struct {
	amount   int64  // 以分为单位，避免浮点精度问题
	currency string // ISO 4217 货币代码
}

// NewMoney 创建金额
func NewMoney(amount int64, currency string) (Money, error) {
	if amount < 0 {
		return Money{}, errors.New("amount cannot be negative")
	}
	if !isValidCurrency(currency) {
		return Money{}, fmt.Errorf("invalid currency: %s", currency)
	}
	return Money{amount: amount, currency: currency}, nil
}

// Zero 零金额
func Zero(currency string) Money {
	return Money{amount: 0, currency: currency}
}

// Amount 获取金额（以分为单位）
func (m Money) Amount() int64 {
	return m.amount
}

// Currency 获取货币
func (m Money) Currency() string {
	return m.currency
}

// Add 加法
func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, fmt.Errorf("cannot add different currencies: %s and %s",
			m.currency, other.currency)
	}
	return Money{
		amount:   m.amount + other.amount,
		currency: m.currency,
	}, nil
}

// Subtract 减法
func (m Money) Subtract(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, fmt.Errorf("cannot subtract different currencies")
	}
	if m.amount < other.amount {
		return Money{}, errors.New("insufficient funds")
	}
	return Money{
		amount:   m.amount - other.amount,
		currency: m.currency,
	}, nil
}

// Multiply 乘法（用于计算折扣、税费等）
func (m Money) Multiply(multiplier float64) Money {
	// 注意浮点精度问题，生产环境建议使用 shopspring/decimal
	newAmount := int64(float64(m.amount) * multiplier)
	return Money{
		amount:   newAmount,
		currency: m.currency,
	}
}

// IsZero 是否为零
func (m Money) IsZero() bool {
	return m.amount == 0
}

// GreaterThan 是否大于另一个金额
func (m Money) GreaterThan(other Money) bool {
	if m.currency != other.currency {
		return false
	}
	return m.amount > other.amount
}

// Equals 是否相等（值对象按值比较）
func (m Money) Equals(other Money) bool {
	return m.amount == other.amount && m.currency == other.currency
}

// String 字符串表示
func (m Money) String() string {
	return fmt.Sprintf("%s %.2f", m.currency, float64(m.amount)/100)
}

// MarshalJSON 序列化为 JSON
func (m Money) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf(`{"amount":%d,"currency":"%s"}`, m.amount, m.currency)), nil
}

func isValidCurrency(currency string) bool {
	validCurrencies := map[string]bool{
		"USD": true, "EUR": true, "CNY": true,
		"GBP": true, "JPY": true, "KRW": true,
	}
	return validCurrencies[currency]
}

// internal/order/domain/address.go
package domain

import (
	"errors"
	"fmt"
	"strings"
)

// Address 地址值对象
type Address struct {
	country    string
	province   string
	city       string
	district   string
	street     string
	postalCode string
	recipient  string
	phone      string
}

// NewAddress 创建地址
func NewAddress(country, province, city, district, street, postalCode, recipient, phone string) (Address, error) {
	a := Address{
		country:    country,
		province:   province,
		city:       city,
		district:   district,
		street:     street,
		postalCode: postalCode,
		recipient:  recipient,
		phone:      phone,
	}

	if err := a.Validate(); err != nil {
		return Address{}, err
	}

	return a, nil
}

// Validate 验证地址
func (a Address) Validate() error {
	if strings.TrimSpace(a.country) == "" {
		return errors.New("country is required")
	}
	if strings.TrimSpace(a.city) == "" {
		return errors.New("city is required")
	}
	if strings.TrimSpace(a.street) == "" {
		return errors.New("street address is required")
	}
	if strings.TrimSpace(a.recipient) == "" {
		return errors.New("recipient is required")
	}
	if !isValidPhone(a.phone) {
		return errors.New("invalid phone number")
	}
	return nil
}

// Equals 值对象按值比较
func (a Address) Equals(other Address) bool {
	return a.country == other.country &&
		a.province == other.province &&
		a.city == other.city &&
		a.district == other.district &&
		a.street == other.street &&
		a.postalCode == other.postalCode &&
		a.recipient == other.recipient &&
		a.phone == other.phone
}

// FullAddress 返回完整地址字符串
func (a Address) FullAddress() string {
	parts := []string{a.country, a.province, a.city, a.district, a.street}
	return strings.Join(parts, " ")
}

// Getters...
func (a Address) Country() string    { return a.country }
func (a Address) Province() string   { return a.province }
func (a Address) City() string       { return a.city }
func (a Address) District() string   { return a.district }
func (a Address) Street() string     { return a.street }
func (a Address) PostalCode() string { return a.postalCode }
func (a Address) Recipient() string  { return a.recipient }
func (a Address) Phone() string      { return a.phone }

func isValidPhone(phone string) bool {
	// 简单验证，生产环境使用更严格的正则
	return len(phone) >= 8 && len(phone) <= 15
}

// String 实现 fmt.Stringer 接口
func (a Address) String() string {
	return fmt.Sprintf("%s, %s, %s", a.recipient, a.FullAddress(), a.phone)
}

// internal/order/domain/order.go
package domain

import (
	"errors"
	"fmt"
	"time"
)

// OrderID 订单 ID（强类型标识）
type OrderID string

// Order 订单聚合根
// 聚合根是修改聚合内对象的唯一入口
type Order struct {
	id            OrderID
	userID        string
	items         []OrderItem           // 实体集合
	shippingAddr  Address
	totalAmount   Money
	status        OrderStatus
	paymentID     string
	cancelReason  string
	events        []DomainEvent         // 领域事件集合
	createdAt     time.Time
	updatedAt     time.Time
}

// NewOrder 创建新订单（工厂方法）
func NewOrder(id OrderID, userID string, items []OrderItem, shippingAddr Address, currency string) (*Order, error) {
	if len(items) == 0 {
		return nil, errors.New("order must have at least one item")
	}

	// 计算总金额
	total := Zero(currency)
	for _, item := range items {
		itemTotal, err := item.Subtotal()
		if err != nil {
			return nil, err
		}
		total, err = total.Add(itemTotal)
		if err != nil {
			return nil, err
		}
	}

	now := time.Now()
	order := &Order{
		id:           id,
		userID:       userID,
		items:        items,
		shippingAddr: shippingAddr,
		totalAmount:  total,
		status:       StatusPending,
		events:       []DomainEvent{},
		createdAt:    now,
		updatedAt:    now,
	}

	// 发布领域事件
	order.addEvent(&OrderCreatedEvent{
		OrderID:     string(id),
		UserID:      userID,
		TotalAmount: total,
		Items:       items,
		CreatedAt:   now,
	})

	return order, nil
}

// ID 获取订单 ID
func (o *Order) ID() OrderID {
	return o.id
}

// UserID 获取用户 ID
func (o *Order) UserID() string {
	return o.userID
}

// Items 获取订单项（返回副本，防止外部修改）
func (o *Order) Items() []OrderItem {
	result := make([]OrderItem, len(o.items))
	copy(result, o.items)
	return result
}

// TotalAmount 获取总金额
func (o *Order) TotalAmount() Money {
	return o.totalAmount
}

// Status 获取订单状态
func (o *Order) Status() OrderStatus {
	return o.status
}

// ShippingAddress 获取收货地址
func (o *Order) ShippingAddress() Address {
	return o.shippingAddr
}

// ConfirmPayment 确认支付
// 这是一个业务操作，包含业务规则
func (o *Order) ConfirmPayment(paymentID string) error {
	// 业务规则：只有待支付订单可以确认
	if o.status != StatusPending {
		return fmt.Errorf("cannot confirm payment for order in status %s", o.status)
	}

	if paymentID == "" {
		return errors.New("payment ID is required")
	}

	o.status = StatusPaid
	o.paymentID = paymentID
	o.updatedAt = time.Now()

	// 发布领域事件
	o.addEvent(&OrderPaidEvent{
		OrderID:   string(o.id),
		PaymentID: paymentID,
		Amount:    o.totalAmount,
		PaidAt:    o.updatedAt,
	})

	return nil
}

// Ship 发货
func (o *Order) Ship(trackingNumber string) error {
	if o.status != StatusPaid {
		return fmt.Errorf("cannot ship order in status %s, must be paid first", o.status)
	}

	if trackingNumber == "" {
		return errors.New("tracking number is required")
	}

	o.status = StatusShipped
	o.updatedAt = time.Now()

	o.addEvent(&OrderShippedEvent{
		OrderID:        string(o.id),
		TrackingNumber: trackingNumber,
		ShippedAt:      o.updatedAt,
	})

	return nil
}

// Cancel 取消订单
func (o *Order) Cancel(reason string) error {
	// 业务规则：已发货的订单不能取消
	if o.status == StatusShipped || o.status == StatusDelivered {
		return fmt.Errorf("cannot cancel order in status %s", o.status)
	}

	if reason == "" {
		return errors.New("cancel reason is required")
	}

	oldStatus := o.status
	o.status = StatusCancelled
	o.cancelReason = reason
	o.updatedAt = time.Now()

	o.addEvent(&OrderCancelledEvent{
		OrderID:    string(o.id),
		Reason:     reason,
		OldStatus:  string(oldStatus),
		CancelledAt: o.updatedAt,
	})

	return nil
}

// AddItem 添加商品项
func (o *Order) AddItem(item OrderItem) error {
	// 业务规则：只有待支付的订单可以添加商品
	if o.status != StatusPending {
		return fmt.Errorf("cannot add items to order in status %s", o.status)
	}

	// 检查是否已有相同商品
	for _, existing := range o.items {
		if existing.ProductID() == item.ProductID() {
			return fmt.Errorf("product %s already in order, use UpdateItemQuantity instead",
				item.ProductID())
		}
	}

	o.items = append(o.items, item)

	// 重新计算总金额
	if err := o.recalculateTotal(); err != nil {
		return err
	}

	o.updatedAt = time.Now()
	return nil
}

// UpdateItemQuantity 更新商品数量
func (o *Order) UpdateItemQuantity(productID string, newQuantity int) error {
	if o.status != StatusPending {
		return fmt.Errorf("cannot update items in order with status %s", o.status)
	}

	for i, item := range o.items {
		if item.ProductID() == productID {
			if err := o.items[i].SetQuantity(newQuantity); err != nil {
				return err
			}
			if err := o.recalculateTotal(); err != nil {
				return err
			}
			o.updatedAt = time.Now()
			return nil
		}
	}

	return fmt.Errorf("product %s not found in order", productID)
}

// recalculateTotal 重新计算总金额（私有方法）
func (o *Order) recalculateTotal() error {
	total := Zero(o.totalAmount.Currency())
	for _, item := range o.items {
		subtotal, err := item.Subtotal()
		if err != nil {
			return err
		}
		total, err = total.Add(subtotal)
		if err != nil {
			return err
		}
	}
	o.totalAmount = total
	return nil
}

// Events 获取并发布领域事件
func (o *Order) Events() []DomainEvent {
	events := o.events
	o.events = nil // 发布后清空
	return events
}

// addEvent 添加领域事件（私有方法）
func (o *Order) addEvent(event DomainEvent) {
	o.events = append(o.events, event)
}

// Equals 实体按标识比较
func (o *Order) Equals(other *Order) bool {
	if other == nil {
		return false
	}
	return o.id == other.id
}

// internal/order/domain/order_item.go
package domain

import (
	"errors"
	"fmt"
)

// OrderItemID 订单项 ID
type OrderItemID string

// OrderItem 订单项（实体）
type OrderItem struct {
	id        OrderItemID
	productID string
	name      string
	price     Money
	quantity  int
}

// NewOrderItem 创建订单项
func NewOrderItem(id OrderItemID, productID, name string, price Money, quantity int) (OrderItem, error) {
	if productID == "" {
		return OrderItem{}, errors.New("product ID is required")
	}
	if name == "" {
		return OrderItem{}, errors.New("product name is required")
	}
	if quantity <= 0 {
		return OrderItem{}, errors.New("quantity must be greater than zero")
	}

	return OrderItem{
		id:        id,
		productID: productID,
		name:      name,
		price:     price,
		quantity:  quantity,
	}, nil
}

// ID 获取 ID
func (i OrderItem) ID() OrderItemID {
	return i.id
}

// ProductID 获取商品 ID
func (i OrderItem) ProductID() string {
	return i.productID
}

// Name 获取商品名
func (i OrderItem) Name() string {
	return i.name
}

// Price 获取单价
func (i OrderItem) Price() Money {
	return i.price
}

// Quantity 获取数量
func (i OrderItem) Quantity() int {
	return i.quantity
}

// Subtotal 计算小计金额
func (i OrderItem) Subtotal() (Money, error) {
	return i.price.Multiply(float64(i.quantity)), nil
}

// SetQuantity 设置数量（只允许 Order 聚合内部调用）
// 注意：Go 没有访问修饰符，我们通过约定和接口来控制
func (i *OrderItem) SetQuantity(qty int) error {
	if qty <= 0 {
		return fmt.Errorf("quantity must be greater than zero, got %d", qty)
	}
	if qty > 1000 {
		return errors.New("quantity cannot exceed 1000")
	}
	i.quantity = qty
	return nil
}

// Equals 实体按标识比较
func (i OrderItem) Equals(other OrderItem) bool {
	return i.id == other.id
}

// internal/order/domain/events.go
package domain

import (
	"time"

	"github.com/google/uuid"
)

// DomainEvent 领域事件接口
type DomainEvent interface {
	EventID() string
	EventName() string
	OccurredAt() time.Time
}

// BaseEvent 基础事件实现
type BaseEvent struct {
	id         string
	name       string
	occurredAt time.Time
}

func NewBaseEvent(name string) BaseEvent {
	return BaseEvent{
		id:         uuid.New().String(),
		name:       name,
		occurredAt: time.Now(),
	}
}

func (e BaseEvent) EventID() string      { return e.id }
func (e BaseEvent) EventName() string    { return e.name }
func (e BaseEvent) OccurredAt() time.Time { return e.occurredAt }

// OrderCreatedEvent 订单创建事件
type OrderCreatedEvent struct {
	BaseEvent
	OrderID     string
	UserID      string
	TotalAmount Money
	Items       []OrderItem
	CreatedAt   time.Time
}

func NewOrderCreatedEvent(orderID, userID string, total Money, items []OrderItem) *OrderCreatedEvent {
	return &OrderCreatedEvent{
		BaseEvent:   NewBaseEvent("order.created"),
		OrderID:     orderID,
		UserID:      userID,
		TotalAmount: total,
		Items:       items,
		CreatedAt:   time.Now(),
	}
}

// OrderPaidEvent 订单支付事件
type OrderPaidEvent struct {
	BaseEvent
	OrderID   string
	PaymentID string
	Amount    Money
	PaidAt    time.Time
}

// OrderShippedEvent 订单发货事件
type OrderShippedEvent struct {
	BaseEvent
	OrderID        string
	TrackingNumber string
	ShippedAt      time.Time
}

// OrderCancelledEvent 订单取消事件
type OrderCancelledEvent struct {
	BaseEvent
	OrderID     string
	Reason      string
	OldStatus   string
	CancelledAt time.Time
}

// InventoryReservedEvent 库存预留事件（由库存上下文发出）
type InventoryReservedEvent struct {
	BaseEvent
	ReservationID string
	OrderID       string
	Items         []ReservedItem
}

// ReservedItem 预留商品项
type ReservedItem struct {
	ProductID string
	Quantity  int
}

// InventoryReservationFailedEvent 库存预留失败事件
type InventoryReservationFailedEvent struct {
	BaseEvent
	OrderID       string
	FailedProduct string
	Reason        string
}

// pkg/events/bus.go
package events

import (
	"context"
	"sync"
)

// Event 通用事件接口
type Event interface {
	EventName() string
}

// Handler 事件处理器
type Handler func(ctx context.Context, event Event) error

// Bus 事件总线
type Bus interface {
	Publish(ctx context.Context, event Event) error
	Subscribe(eventName string, handler Handler)
}

// InMemoryBus 内存事件总线（开发和测试用）
type InMemoryBus struct {
	mu       sync.RWMutex
	handlers map[string][]Handler
}

func NewInMemoryBus() *InMemoryBus {
	return &InMemoryBus{
		handlers: make(map[string][]Handler),
	}
}

func (b *InMemoryBus) Publish(ctx context.Context, event Event) error {
	b.mu.RLock()
	handlers, ok := b.handlers[event.EventName()]
	b.mu.RUnlock()

	if !ok {
		return nil
	}

	// 异步执行所有处理器
	var wg sync.WaitGroup
	for _, handler := range handlers {
		wg.Add(1)
		go func(h Handler) {
			defer wg.Done()
			_ = h(ctx, event) // 生产环境应该处理错误
		}(handler)
	}
	wg.Wait()

	return nil
}

func (b *InMemoryBus) Subscribe(eventName string, handler Handler) {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.handlers[eventName] = append(b.handlers[eventName], handler)
}

// Dispatch 从聚合根中发布所有领域事件
func Dispatch(ctx context.Context, bus Bus, events []Event) error {
	for _, event := range events {
		if err := bus.Publish(ctx, event); err != nil {
			return err
		}
	}
	return nil
}

// internal/order/domain/repository.go
package domain

import (
	"context"
)

// OrderRepository 订单仓储接口
// 注意：接口定义在领域层，由基础设施层实现
// 这样领域层不依赖任何持久化技术
type OrderRepository interface {
	// Save 保存订单（插入或更新）
	Save(ctx context.Context, order *Order) error

	// GetByID 根据 ID 获取订单
	GetByID(ctx context.Context, id OrderID) (*Order, error)

	// GetByUserID 根据用户 ID 查询订单
	GetByUserID(ctx context.Context, userID string, offset, limit int) ([]*Order, error)

	// GetByStatus 根据状态查询订单
	GetByStatus(ctx context.Context, status OrderStatus) ([]*Order, error)

	// NextID 生成新的订单 ID
	NextID(ctx context.Context) (OrderID, error)
}

// UnitOfWork 工作单元（保证聚合的事务完整性）
type UnitOfWork interface {
	// Execute 在事务中执行操作
	Execute(ctx context.Context, fn func(ctx context.Context) error) error
}

// internal/order/infrastructure/persistence/postgres_order_repo.go
package persistence

import (
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"time"

	"github.com/google/uuid"

	"github.com/yourusername/eshop/internal/order/domain"
)

// postgresOrderRepo 基于 PostgreSQL 的订单仓储实现
type postgresOrderRepo struct {
	db *sql.DB
}

// NewPostgresOrderRepository 创建仓储
func NewPostgresOrderRepository(db *sql.DB) domain.OrderRepository {
	return &postgresOrderRepo{db: db}
}

func (r *postgresOrderRepo) Save(ctx context.Context, order *domain.Order) error {
	// 序列化聚合根为 JSON（或使用多表存储）
	itemsJSON, err := json.Marshal(order.Items())
	if err != nil {
		return fmt.Errorf("failed to marshal items: %w", err)
	}

	addrJSON, err := json.Marshal(order.ShippingAddress())
	if err != nil {
		return fmt.Errorf("failed to marshal address: %w", err)
	}

	query := `
		INSERT INTO orders (id, user_id, items, shipping_address, total_amount, currency, status, payment_id, cancel_reason, created_at, updated_at)
		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
		ON CONFLICT (id) DO UPDATE SET
			items = EXCLUDED.items,
			total_amount = EXCLUDED.total_amount,
			status = EXCLUDED.status,
			payment_id = EXCLUDED.payment_id,
			cancel_reason = EXCLUDED.cancel_reason,
			updated_at = EXCLUDED.updated_at
	`

	_, err = r.db.ExecContext(ctx, query,
		order.ID(),
		order.UserID(),
		itemsJSON,
		addrJSON,
		order.TotalAmount().Amount(),
		order.TotalAmount().Currency(),
		order.Status(),
		order.PaymentID(),
		order.CancelReason(),
		order.CreatedAt(),
		order.UpdatedAt(),
	)

	return err
}

func (r *postgresOrderRepo) GetByID(ctx context.Context, id domain.OrderID) (*domain.Order, error) {
	var (
		userID        string
		itemsJSON     []byte
		addrJSON      []byte
		amount        int64
		currency      string
		status        string
		paymentID     sql.NullString
		cancelReason  sql.NullString
		createdAt     time.Time
		updatedAt     time.Time
	)

	query := `
		SELECT user_id, items, shipping_address, total_amount, currency, status, payment_id, cancel_reason, created_at, updated_at
		FROM orders
		WHERE id = $1
	`

	err := r.db.QueryRowContext(ctx, query, id).Scan(
		&userID, &itemsJSON, &addrJSON, &amount, &currency, &status,
		&paymentID, &cancelReason, &createdAt, &updatedAt,
	)

	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, fmt.Errorf("order %s not found: %w", id, err)
		}
		return nil, err
	}

	// 反序列化
	var items []domain.OrderItem
	if err := json.Unmarshal(itemsJSON, &items); err != nil {
		return nil, err
	}

	var addr domain.Address
	if err := json.Unmarshal(addrJSON, &addr); err != nil {
		return nil, err
	}

	total, err := domain.NewMoney(amount, currency)
	if err != nil {
		return nil, err
	}

	// 重建聚合根（使用工厂方法）
	order := domain.ReconstructOrder(
		id, userID, items, addr, total,
		domain.OrderStatus(status),
		paymentID.String,
		cancelReason.String,
		createdAt, updatedAt,
	)

	return order, nil
}

func (r *postgresOrderRepo) NextID(ctx context.Context) (domain.OrderID, error) {
	return domain.OrderID(uuid.New().String()), nil
}

// ... 其他方法实现 ...